Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:45
📄 Document.py class Document: def __init__(self, mod, node, env): self.mod = mod self.env = env self.kindbrackets = mod.kindbrackets self.eitherbrackets = mod.eitherbrackets self.anykind = mod.anykind self.out = [] self.localstack = [] self.outstack = [] self.output_directives = [] self.document_title = None self.specified_definitions = None self.macro_args = None self.subdoc = None self.in_in = 0 self.macro_stack = [] node.accept(self) self.result = self.node_of_taci('string', '', self.out, 0) @property def doc_name_node(self): return self.node_of_taci('text', self.get_doc_name()) def _visit_children(self, node): E = self.mod.ReportedError for ch in node.children: try: ch.accept(self) except E: pass def _visit_subjects(self, subjects): for s in subjects: self.out.append(self.node_of_taci('symbol', s.tgtfullname)) def _visit_gets(self, node, what): self._visit_subjects( getattr(self.get_arg_subject(node), 'get_%s' % what)()) def ap_text(self, text): self.out.append(self.node_of_taci('text', text, (), 0)) def close(self, chktag=None, n=1, chk=None, get=False): for i in range(n): out, tag, arg = self.outstack.pop() node = self.node_of_taci(tag, arg, self.out) if not get: out.append(node) self.out = out if chk is not None: assert chk is out if chktag is not None: assert chktag == tag return node def error(self, msg, context=None, kwds): msg = 'Document: ' + msg more = [('Macro call site.', ms[0]) for ms in self.macro_stack] more.reverse() self.env.error(msg, context, more=more, kwds) def error_no_sub_element(self, node, subelement): self.error('No such subelement allowed in the enclosing element %r.' % node.tag, subelement, exception=None) def expand_arg(self, arg): i = len(self.localstack) - 1 while i >= 0: argnode = self.localstack[i].get(arg) if argnode is not None: assert argnode.tag == 'symbol' return argnode.arg.strip() i -= 1 return arg def expand_list(self, li): oldout = self.out self.out = newout = [] for node in li: node.accept(self) self.out = oldout return newout def expand_node(self, node, optarg=0, optmore=0): arg, rest = self.get_arg_rest( node, optarg=optarg, optmore=optmore, nostrip=1) return self.node_of_taci(node.tag, arg, rest, node.index, node.src) def gen_char(self, char): self.gen_tag('char', char) def gen_document_header(self): self.open('document_header') self.close() def gen_document_trailer(self): self.open('document_trailer') self.close() def gen_link_to(self, s, text=None, children=()): if text is not None: children = list(children) children.append(self.node_of_taci('text', text)) ln = self.get_link_name(s) self.gen_tag('link_to', ln, children) def gen_localname(self, s): self.gen_link_to(s, s.get_local_name()) def gen_symbol(self, arg): self.out.append(self.node_of_taci('symbol', arg)) def gen_tag(self, tag, arg='', children=()): self.out.append(self.node_of_taci(tag, arg, children)) def gen_text(self, text): self.gen_tag('text', text) def get_arg_only(self, node): arg, rest = self.get_arg_rest(node) if rest: self.error('Node has extra children, only 1 arg or child expected') return arg def get_arg_rest(self, node, optarg=0, optmore=0, nostrip=0): arg, rest = node.get_arg_rest(nostrip=nostrip) rest = self.expand_list(rest) if arg: arg = self.expand_arg(arg) else: if not (rest and rest[0].tag == 'symbol'): if not optarg: self.error( 'Argument on line or as next children expected.', node) else: arg = rest[0].arg.strip() rest = rest[1:] if rest and rest[0].tag == 'symbol': if not optmore: self.error('More arguments than expected.', rest[0]) return arg, rest def get_arg_subject(self, node): arg = self.get_arg_only(node) return self.get_subject(arg, node) def get_arg_subjects_rest(self, node): args, rest = self.get_arglist_rest(node) return [self.get_subject(a, node) for a in args], rest def get_arglist_only(self, node): args, rest = self.get_arglist_rest(node) if rest: self.error_no_sub_element(node, rest[0]) return args def get_arglist_rest(self, node): args = [] for arg in node.get_arglist(): if not arg: self.error("Empty argument in arg list", node) arg = self.expand_arg(arg) args.append(arg) rest = [] for a in self.expand_list(node.children): if a.tag == 'symbol': if rest: self.error( 'Argument elements must be first in subelements.', a, exception=None) args.append(a.arg.strip()) else: rest.append(a) return args, rest def get_cur_subject(self, node): sd = self.subdoc if not sd: self.error('No subject defined in current environment.', node) return sd.subject def get_doc_name(self): return self.document_name def get_filers(self, output_dir): if not self.output_directives: print('Document %r: No output directives' % self.name) filers = [] r = self.get_result() name = self.get_doc_name() for (handler, opts) in self.output_directives: print('processing', handler, opts, name) filers.append(handler.doc2filer( self, r, name, output_dir, opts, self.mod.IO)) return filers def get_link_name(self, a): return a.get_link_name() def get_macro_args(self, node): args = self.macro_args if args is None: self.error('Is not in macro', node) return args def get_result(self): return self.result def get_subject(self, name, node=None): return self.env.get_descr_by_name(name, node) def node_of_taci(self, args): return self.mod.node_of_taci(args) def open(self, tag, arg=''): self.outstack.append((self.out, tag, arg)) self.out = [] return self.out def subdoc_do(self, m, f): sd = SubDoc(self, m) osd = self.subdoc self.subdoc = sd sd.subdoc = sd try: f(sd) finally: self.subdoc = osd def visit_args(self, node): if self.macro_args is None: self.error('Not in macro', node) else: names = self.get_arglist_only(node) if len(names) != len(self.macro_args): self.error('%d args passed, here is %d names' % (len(self.macro_args), len(names)), node) self.localstack.append(dict([(x.strip(), self.macro_args[i]) for i, x in enumerate(names)])) def visit_arguments_of(self, node): self._visit_gets(node, 'arguments') def visit_attr_name_of(self, node): self.gen_symbol(self.get_arg_subject(node).get_attr_name()) def visit_attributes_of(self, node): self._visit_gets(node, 'attributes') def visit_block(self, node): self.out.append(self.expand_node(node, optarg=1)) def visit_default(self, node): self.out.append(self.expand_node(node, optarg=1, optmore=1)) def visit_define(self, node): arg, rest = self.get_arg_rest(node) arg = self.get_link_name(self.get_subject(arg, node)) self.out.append(self.node_of_taci( node.tag, arg, rest, node.index, node.src)) def visit_defines(self, node): sd = self.specified_definitions if sd is None: sd = self.specified_definitions = [] sd.extend(self.get_arglist_only(node)) def visit_description_of(self, node): self.get_arg_subject(node).gen_description_doc(self) def visit_document(self, node): self.document_name = node.arg.strip() self.open('document') self._visit_children(node) if self.document_title is None: self.open('document_title') self.gen_text('GSL document %s' % self.document_name) self.close() self.close() def visit_document_title(self, node): self.document_title = node self.out.append(self.document_title) def visit_for(self, node): varname = node.get_namearg() if not node.children: self.error('For loop without subelements.', node) if not (node.children[0].tag == 'in'): self.error("First subelement of for loop must be 'in'.", node.children[0]) inode = node.children[0] names = self.get_arglist_only(inode) body = node.children[1:] if not body: self.error('For loop without body.', node) for name in names: self.localstack.append({ varname: self.node_of_taci( 'symbol', name, (), node.index)}) try: for ch in body: ch.accept(self) finally: self.localstack.pop() def visit_gsml(self, node): arg, rest = node.get_arg_rest() if arg: rest = [self.mod.node_of_taci( 'text', arg, (), node.index, node.src)]+list(rest) self.open('block') for a in rest: if a.tag == 'text': a = self.mod.node_of_gsml(a.arg.strip()) a.accept(self) self.close() def visit_id_of(self, node): self.ap_text(self.get_arg_subject(node).get_id_name()) def visit_in(self, node): self.in_in += 1 self.visit_default(node) self.in_in -= 1 def visit_kind_of(self, node): self.gen_symbol(self.get_arg_subject(node).get_kind_name()) def visit_label(self, node): subject = self.get_cur_subject(node) arg, rest = self.get_arg_rest(node) name = subject.get_link_name() + '.label:'+arg self.open('define', name) self.close() for r in rest: self.out.append(r) def visit_link_to(self, node): arg, rest = self.get_arg_rest(node) self.gen_link_to(self.get_subject(arg, node), children=rest) def visit_man_page_of(self, node): self.open('to_document_only') self.open('man_page_mode') subjects, rest = self.get_arg_subjects_rest(node) if rest: self.error_no_sub_element(node, rest[0]) for subject in subjects: self.subdoc_do(subject, lambda sd: sd.gen_man_page(subject)) self.close() self.close() def visit_mappings_of(self, node): self._visit_gets(node, 'mappings') def visit_meta(self, node): arg = node.arg.strip() if arg: colon = arg.find(':') if colon <= 0: self.error('Argument to meta, if any, must be of the form <name>:<content>.', node) name = arg[:colon].strip() content = arg[colon+1:].strip() mknode = self.mod.node_of_taci ch = (mknode('name', name), mknode( 'content', content)) + node.children node = mknode('meta', '', ch) self.out.append(node) def visit_name_of(self, node): self.gen_text(self.get_arg_subject(node).get_name()) def visit_output(self, node): mode, rest = self.get_arg_rest(node) modes = [x.strip() for x in mode.split(',')] for mode in modes: try: handler_name = self.mod.output_handlers[mode.lower()] except KeyError: self.error('Unknown output mode: %r. Expected one of %r.' % ( mode, list(self.mod.output_handlers.keys())), node, exception=None) else: handler = getattr(self.mod, handler_name) self.output_directives.append((handler, rest)) def visit_ref(self, node): self.gen_text(' ') subject = self.get_cur_subject(node) arg, rest = self.get_arg_rest(node) text = arg if arg.startswith('.'): dl = arg.find('.', 1) if dl < 0: dl = len(arg) tag = arg[1:dl].strip() name = arg[dl+1:].strip() else: tag = 'myfile' name = arg if tag == 'mykind': idn = subject.get_link_name() if name: idn = idn + '.' + name text = name else: text = idn.split('.')[-1] elif tag == 'myfile': idn = subject.get_link_name() idn = '.'.join(idn.split('.')[:2]) if name: idn = idn + '.' + name text = name else: self.error('Invalid tag: %r in reference.' % tag, node) if not rest: rest = [self.node_of_taci('text', text)] self.out.append(self.node_of_taci( 'link_to', idn, rest, node.index)) def visit_specified_definitions(self, node): if node.arg.strip() or node.children: self.error('No argument or subelement allowed for element %r.' % node.tag, node, exception=None) if self.specified_definitions is None: self.error('No definitions have been specified.', node) for s in self.specified_definitions: self.out.append(self.node_of_taci( 'symbol', s, (), node.index, node.src)) def visit_symbol(self, node): arg = self.get_arg_only(node) if arg != node.arg.strip(): node = self.node_of_taci(node.tag, arg, (), node.index, node.src) self.out.append(node) def visit_synopsis_of(self, node): self.open('to_document_only') self.open('man_page_mode') m = self.get_arg_subject(node) self.subdoc_do(m, lambda sd: sd.gen_mapping_doc(m)) self.close() self.close() def visit_test_of(self, node): args, rest = self.get_arg_subjects_rest(node) for kind in args: self.open('to_tester_only') self.out.append(self.node_of_taci( node.tag, kind, rest, node.index, node.src)) self.close() def visit_take_all(self, node): for a in self.get_macro_args(node): self.out.append(a) def visit_take_first(self, node): args = self.get_macro_args(node) if not args: self.error('No argument passed', node) self.out.append(args[0]) def visit_take_rest(self, node): args = self.get_macro_args(node) if not args: self.error('No argument passed', node) for ch in args[1:]: self.out.append(ch) def visit_text(self, node): self.out.append(node) def visit_use(self, node): macrocolonarg, args = self.get_arg_rest(node) colonpos = macrocolonarg.find(':') if colonpos <= 0: macroname = macrocolonarg else: macroname = macrocolonarg[:colonpos].strip() macroarg = macrocolonarg[colonpos+1:].strip() if not macroarg: self.error('Argument must be of form <macroname> or <macroname>:<macroarg>.', node) macroarg = self.expand_arg(macroarg) args = [self.node_of_taci('symbol', macroarg)] + args macro = self.get_subject(macroname, node) o = (self.localstack, self.macro_args) try: self.macro_stack.append([node]) self.localstack = [] self.macro_args = args self._visit_children(macro.use(args)) finally: (self.localstack, self.macro_args) = o self.macro_stack.pop() class Attributes: d_tag = 'attributes' def __init__(self, as_): self.as_ = as_ def find_kind_aspects(self): return self.as_[0].find_kind_aspects() def get_link_name(self): return self.as_[0].mod.tgt_prefix+'(%s)' % ','.join([x.get_link_name() for x in self.as_]) def get_name(self): return ', '.join([x.get_name() for x in self.as_]) def get_kind(self): return self.as_[0].get_kind() def get_self_name(self): return self.as_[0].get_self_name() def find_aspects(self, tag): return self.as_[0].find_aspects(tag) def is_method(self): self.as_[0].is_method() class SubDoc(Document): def __init__(self, parent, subject): self.__dict__.update(parent.__dict__) self.parent = parent self.subject = subject self.level = 0 self.no_ret = 0 self.use_self = None def combine_attrs_of_same_kind(self, kas): if len(kas) <= 1: return kas nkas = [] attrs = [] for ka in kas: t = ka.d_tag if t != 'attribute': nkas.append(ka) continue for (i, as_) in attrs: a = as_[0] if (a.src.node is ka.src.node and len(a.aspects) == len(ka.aspects)): as_.append(ka) break else: attrs.append((len(nkas), [ka])) nkas.append(ka) for (i, as_) in attrs: if len(as_) > 1: nkas[i] = Attributes(as_) return nkas def combine_attrs_of_same_kind_and_description(self, kas): return self.combine_attrs_of_same_kind(kas) def gen_anything(self): self.open('strong') self.gen_text(' ' + self.anykind) self.close() def gen_argref(self, a): # a : kind # a = kind t = a.d_tag if t == 'arg': self.gen_posarg_name(a) self.gen_colon() elif t == 'key_arg': self.gen_keyarg_name(a) self.gen_assign() else: assert 0 self.gen_ref(a.get_kind()) def gen_arguments(self, args): def flatten(args): f = [] for a in args: if a.d_tag in ('args', 'seq'): f.extend(flatten(a.find_arg_aspects())) else: f.append(a) return f def gen_sycomma(): if sycomma: self.gen_text(sycomma[0]) sycomma[:] = [', '] def clr_sycomma(): sycomma[:] = [] def gen_lbracket(b): if sycomma: self.gen_text(' ') self.gen_text(b) clr_sycomma() def gen_rbracket(b): self.gen_text(b) sycomma[:] = [' '] def gen_su(text, sup='sup'): self.open(sup) self.open('strong') self.gen_text(text) self.close() self.close() def gen_taggy(tag, args, func, brackets='[]'): su = 'sup' colon = ':' if tag: self.gen_text(' ') gen_su(tag+colon, su) sycomma[:] = [] if len(args) != 1: gen_lbracket(brackets[0]) func(args) gen_rbracket(brackets[1]) else: clr_sycomma() func(args) def gen_or(asp, sep, orparneed=False, # Set to True if sequences needs parentheses between or sup=1 ): if asp: if len(asp) == 1: gen_arg(asp[0]) return gen_arg(asp[0], parneed=orparneed) for ch in asp[1:]: if sup: self.open('sup') self.open('strong') if callable(sep): sep() else: self.gen_text(sep) if sup: self.close() self.close() clr_sycomma() gen_arg(ch, parneed=orparneed) def gen_arg(a, parneed=0): t = a.d_tag if t in ('arg', 'key_arg'): gen_sycomma() self.gen_argref(a) elif t == 'alt': args = a.find_arg_aspects() gen_taggy('alt', args, lambda args: gen_or(args, ' or ')) elif t == 'no_arg': self.gen_text('[]') elif t == 'draw': args = a.find_arg_aspects() if len(args) <= 1: gen_lbracket(' [') gen_arg(args[0]) gen_rbracket(']') else: gen_taggy('draw', args, lambda args: gen_or( args, ' , ', sup=0)) elif t == 'optionals': args = a.find_arg_aspects() for s in args: gen_lbracket(' [') gen_arg(s) gen_rbracket(']'len(args)) elif t == 'superkind': gen_sycomma() self.gen_localname(a) elif t in ('seq', ): args = a.find_arg_aspects() gen_taggy('seq', args, lambda args: gen_or(args, ' , ', sup=0)) elif t in ('args', 'seq'): gen_args(a.find_arg_aspects(), parneed) elif t == 'repeat': gen_taggy(a.get_arg(), a.find_arg_aspects(), gen_args) else: assert 0 def gen_args(args, parneed=0): args = flatten(args) def ga(args): for a in args: gen_arg(a) if parneed and len(args) > 1: #gen_taggy('', args, ga, brackets='<>') gen_taggy('1', args, ga) else: ga(args) sycomma = [] gen_args(args) def gen_assign(self): self.open('strong') self.gen_char('nbsp') self.gen_text('=') self.gen_char('nbsp') self.close() def gen_attribute_def(self, a): def gen_dt(do_kind=0): if dt_done: return dt_done.append(1) self.open('dd') if not define_done: link_name = self.get_link_name(a) self.open('define', link_name) if s: self.out.append(s) if s: self.open('code') self.gen_text('.') self.close() self.open('strong') self.open('big') self.gen_attribute_name(a) self.close() self.close() if not define_done: self.close() define_done.append(1) if do_kind or not kas: if len(kas) == 1 and kas[0].d_tag == 'mapping': self.gen_mapping_kind(kas[0], 1) self.open('dl') self.gen_mapping_description(kas[0]) self.close() else: self.gen_colon() self.gen_def(a.get_kind()) kind_done.append(1) self.close('dd') def gen_afterkind(a): dt_done.pop() gen_dt(1) kind_done.append(1) define_done = [] dt_done = [] kind_done = [] kas = a.find_kind_aspects() s = self.get_self_node(a) self.level += 1 for d in a.find_aspects(''): t = d.d_tag if t == 'description': gen_dt(0) self.open('dd') self.open('dl') self.gen_description_def(d) self.close() self.close() continue if d in kas: if dt_done or kind_done: pass if not dt_done: gen_dt(do_kind=1) elif not kind_done: gen_afterkind(a) elif t == 'self': pass else: assert 0 if not dt_done: gen_dt(do_kind=1) self.level -= 1 def gen_attribute_name(self, a): self.gen_name(a) def gen_attribute_ref(self, a): s = self.get_self_node(a) if s: self.out.append(s) self.open('big') if s: self.open('code') self.gen_text('.') self.close() link_name = self.get_link_name(a) self.open('link_to', link_name) self.gen_attribute_name(a) self.close() self.close() kas = a.find_kind_aspects() if len(kas) == 1 and kas[0].d_tag == 'mapping': self.gen_mapping_kind(kas[0]) else: self.gen_colon() self.gen_ref(a.get_kind()) def gen_attributes_def(self, a): self.gen_attribute_def(a) def gen_attributes_ref(self, a): self.gen_attribute_ref(a) def gen_colon(self): self.open('spc_colonkind') self.close() def gen_comment_def(self, d): pass def gen_comment_ref(self, d): pass def gen_condition_def(self, cond): self.open('dt') self.gen_condition_ref(cond, 1) self.close() self.level += 1 for d in cond.find_aspects(''): t = d.d_tag if t == 'description': self.gen_description_dd(d) elif t == 'python_code': self.open('dd') self.open('dl') self.open('dt') self.open('strong') self.gen_text('Python code: ') self.close() self.open('code') self.gen_text(d.src.node.arg.strip()) self.close() self.close() ctx = d.find_aspects('in context') if ctx: self.open('dd') self.open('dl') for ct in ctx: self.open('dt') self.open('strong') self.gen_text('in context: ') self.close() self.open('code') self.gen_text(ct.src.node.arg.strip()) self.close() self.close() self.close() self.close() self.close('dl') self.close('dd') self.level -= 1 def gen_condition_ref(self, cond, define=0): link_name = self.get_link_name(cond) if define: self.open('define', link_name) else: self.open('link_to', link_name) self.open('strong') self.open('big') self.gen_text(cond.get_def_name()) self.close() self.close() self.close() # define self.gen_text('(') self.gen_text(', '.join(cond.get_arg_names())) self.gen_text(')') def gen_constructor_def(self, c): self.open('define', self.get_link_name(c)) self.close() for cc in c.args: self.open('dt') self.gen_link_to(cc) self.close() for d in c.find_aspects('description'): self.gen_description_dd(d) def gen_constructor_ref(self, c): self.gen_self(c) self.gen_text(' = ') self.gen_ref(c.args[0]) def gen_constructor_descriptions(self, li): self.gen_constructor_syn(li, 1) def gen_constructor_syn(self, li, desc=0): ccs = [] descs = [] cdccs = [] for c in li: ds = c.find_aspects('description') descs.extend(ds) ccs.extend(c.args) cdccs.append((c, ds, c.args)) if desc and not descs: return self.open('dt') if desc: self.open('h2') else: self.open('big') self.open('strong') if descs: if desc: self.open('define', li[0].get_link_name()) else: self.open('link_to', li[0].get_link_name()) hd = 'Constructors' if len(ccs) == 1: hd = hd.rstrip('s') self.gen_text(hd) if descs: self.close() self.close() if not desc: self.close() self.close('dt') self.open('dd') self.open('dl') for c, ds, ccs in cdccs: for cc in ccs: self.open('block') self.gen_ref(cc.env) conselfnode = self.close(get=1) self.open('dt') self.use_self = conselfnode self.gen_ref(cc) self.use_self = None self.close('dt') if desc: for d in ds: self.gen_description_dd(d) self.close('dl') self.close('dd') def gen_def(self, a): getattr(self, 'gen_%s_def' % a.d_tag)(a) def gen_delitem_def(self, op): self.open('dt') self.gen_delitem_ref(op, 1) self.close() self.gen_mapping_description(op) def gen_delitem_ref(self, op, subdescript=0): link_name = self.get_link_name(op) if subdescript: self.open('define', link_name) self.open('strong') self.open('big') self.gen_text('del ') self.close() self.close() self.close() else: self.open('link_to', link_name) self.gen_text('del ') self.close() self.gen_self(op) args = op.get_arguments() self.gen_text('[') self.gen_arguments(args) self.gen_text(']') def gen_description(self, k): ats = k.find_aspects('') ats = self.combine_attrs_of_same_kind_and_description(ats) self.gen_descriptions(ats) def gen_description_dd(self, d): self.open('dd') d.gen_doc(self) self.close() def gen_description_def(self, d): self.gen_description_dd(d) def gen_description_descriptions(self, li): self.gen_outer_dt('Description') for d in li: self.gen_description_dd(d) def gen_description_ref(self, d): pass def gen_description_syn(self, li): pass def gen_descriptions(self, ats, use_attr_header=1): if not ats: return tab = self.sortup_aspects(ats) for typ, li in tab: try: try: gen_desc = getattr(self, 'gen_%s_descriptions' % typ) except AttributeError: hd = typ if (len(li) > 1): hd = hd + 's' hd = hd.capitalize().replace('_', ' ') self.gen_outer_dt(hd) for a in li: self.gen_def(a) else: gen_desc(li) except self.mod.ReportedError: pass def gen_either_def(self, k): self.gen_either_ref(k) def gen_either_ref(self, k): self.open('strong') self.open('sup') self.gen_text(' either:') self.close() self.close() self.gen_text(self.eitherbrackets[0]) kas = k.get_alt_kinds() self.gen_ref(kas[0]) for ka in kas[1:]: self.open('strong') self.open('sup') self.gen_text(' or ') self.close() self.close() self.gen_ref(ka) self.gen_text(self.eitherbrackets[1]) def gen_example_descriptions(self, egs): e = 'Example' if len(egs) > 1: e += 's' self.gen_outer_dt(e) for eg in egs: self.open('dd') self.open('pre') ct = eg.get_ctx_text() if ct: if not ct.endswith('\n'): ct += '\n' self.gen_text(ct) et = eg.get_ex_text() self.open('strong') self.gen_text('return ') self.gen_text(eg.get_ex_text()) self.close() self.close() self.close() continue self.open('dd') self.open('code') self.gen_text(eg.get_ex_text()) ct = eg.get_ctx_text() self.close() if ct: self.open('em') self.gen_text(' # in context:') self.close() self.close() if ct: if '\n' in ct: self.open('pre') self.gen_text(ct) self.close() else: self.open('dd') self.open('code') self.gen_text(ct) self.close() self.close() return self.open('dd') self.open('dl') self.open('dt') self.open('strong') self.gen_text('In context') self.close() self.close() self.open('dd') if '\n' in ct: self.open('pre') else: self.open('code') self.gen_text(ct) self.close() self.close() self.close() self.close('dd') def gen_example_syn(self, eg): pass def gen_function_operator_def(self, op): self.open('dd') self.gen_function_operator_ref(op, 1) self.open('dl') self.gen_mapping_description(op) self.close() self.close() def gen_function_operator_ref(self, op, subdescript=0): link_name = self.get_link_name(op) if not subdescript: self.open('link_to', link_name) else: self.open('define', link_name) self.open('big') self.open('strong') self.gen_text(op.src.node.arg.strip()) self.close() self.close() self.close() self.gen_text('(') self.gen_self(op) for a in op.get_arguments(): t = a.d_tag if t == 'arg': self.gen_argref(a) else: assert 0 self.gen_text(')') self.gen_returns(op, subdescript) def gen_header(self, m): link_name = self.get_link_name(m) self.open('define', link_name) self.open('h1') self.gen_text(m.get_name()) self.close() self.close() def gen_inplace_operator_def(self, op): self.gen_operator_def(op) def gen_inplace_operator_ref(self, op, subdescript=0): self.gen_operator_ref(op, subdescript) def gen_keyarg_name(self, a): self.open('code') self.gen_name(a) self.close() def gen_kind_aspects(self, ats, defi): if not ats: self.gen_anything() return self.gen_text(self.kindbrackets[0]) self.open('dl') for a in ats: if a.d_tag in ('kind',) and not a.is_synthetic: self.open('dd') self.open('em') self.gen_text('Subkind of: ') self.close() if defi: self.gen_def(a) else: self.gen_ref(a) self.close() else: if defi: self.open('dd') self.gen_def(a) self.close() else: self.open('dd') self.gen_ref(a) self.close() self.open('dd') self.gen_text(self.kindbrackets[1]) self.close() self.close() def gen_kind_def(self, k): kas = k.find_kind_aspects() self.gen_kind_refodef(k, 1) def gen_kind_of_def(self, k): self.gen_kind_of_ref(k) def gen_kind_of_ref(self, k): kas = k.find_kind_aspects() if len(kas) == 1: self.gen_ref(kas[0]) else: assert 0 # to be tested def gen_kind_ref(self, k, defi=0): self.gen_kind_refodef(k, 0) def gen_kind_refodef(self, k, defi=0): if not k.is_synthetic: self.gen_localname(k) return kas = k.find_kind_aspects() kas = self.combine_attrs_of_same_kind(kas) self.gen_kind_aspects(kas, defi) def gen_man_page(self, m): self.gen_header(m) self.open('dl') self.gen_Name(m) self.gen_synopsis(m) self.gen_description(m) self.close() def gen_mapping_def(self, a): self.gen_mapping_tag(a, 1) self.gen_mapping_kind(a, 1, 1) self.open('dl') self.gen_mapping_description(a) self.close() def gen_mapping_description(self, m): def find_named_args(m): na = [] asp = m.find_arg_aspects() for a in asp: t = a.d_tag if t in ('arg', 'key_arg'): na.append(a) else: na.extend(find_named_args(a)) return na def gen_arguments_descriptions(m): na = find_named_args(m) if not na: return namedesc = {} ada = [] for a in na: t = a.d_tag if t in ('arg', 'key_arg'): da = a.find_aspects('description') ada.append((a, da)) if da: namedesc[(t, a.get_name())] = 1 else: assert 0 if namedesc: label = 'Argument' if len(namedesc) > 1: label += 's' self.gen_outer_dt(label) self.open('dd') self.open('dl') for a, da in ada: t = a.d_tag if not da and (t, a.get_name()) in namedesc: # This arg is considered to be described elsewhere, Notes Aug 10 2005. # This is a bit sublte, may do for now... continue self.open('dt') self.gen_argref(a) self.close() for d in da: self.gen_description_dd(d) self.close() self.close('dd') def gen_condition_ref(a): if a.is_not: self.gen_text('not ') d = a.get_definition() if d is None: self.gen_text(a.cond_doc_name) else: self.open('link_to', self.get_link_name(d)) self.gen_text(a.cond_doc_name) self.close() if a.arg_names: self.gen_text('(') # self.open('var') comma = 0 for an in a.arg_names: if comma: self.gen_text(', ') comma = 1 if an.startswith('<') and an.endswith('>'): self.open('em') self.gen_text(an[1:-1]) self.close() else: # I think it normally is clearer to not have # slanted argument names self.gen_text(an) # self.close() self.gen_text(')') def gen_condition_desc(a): ds = a.find_aspects('description') for d in ds: self.gen_description_dd(d) def gen_conditions_description(m, asp='precondition'): self.open('dd') self.open('dl') pres = m.find_aspects(asp) if pres: self.open('dt') self.open('strong') hd = asp.capitalize() if len(pres) > 1: hd = hd + 's' self.gen_text(hd) self.close() self.close() self.open('dd') self.open('dl') for pre in pres: self.open('dt') gen_condition_ref(pre) self.close() gen_condition_desc(pre) self.close() self.close() self.close() self.close() def gen_description(m): asp = m.find_aspects() args_described = 0 pre_described = 0 post_described = 0 last_t = None last_h = None for a in asp: t = a.d_tag if t == 'description': self.gen_description_dd(a) elif t == 'returns': rds = a.find_aspects('description') if rds: self.open('dd') self.open('dl') self.open('dt') self.open('strong') self.gen_text('Returns ') self.close() rds[0].gen_doc(self) rds = rds[1:] self.close('dt') for rd in rds: self.gen_description_dd(rd) self.close('dl') self.close('dd') elif t in ('precondition', ): if not pre_described: gen_conditions_description(m, t) pre_described = 1 elif t in ('postcondition',): if not post_described: gen_conditions_description(m, t) post_described = 1 elif t in ('equation',): self.open('dd') self.open('dl') self.open('dt') self.open('strong') self.gen_text('Equation') self.close() self.close() self.open('dd') self.open('dl') eqconds_done = 0 for asp in a.find_aspects(''): t = asp.d_tag if t == 'description': self.gen_description_dd(asp) elif not eqconds_done: eqconds_done = 1 self.open('dt') cs = a.find_aspects( 'precondition', 'postcondition') for cr in cs: if cr.d_tag == 'precondition': self.open('strong') self.open('sup') self.gen_text('pre:') self.close() self.close() elif cr.d_tag == 'postcondition': self.open('strong') self.open('sup') self.gen_text('post:') self.close() self.close() gen_condition_ref(cr) if cr is not cs[-1]: self.open('big') self.gen_text(' == ') self.close() self.close() self.close() self.close() self.close() self.close() else: if not args_described: self.open('dd') self.open('dl') gen_arguments_descriptions(m) args_described = 1 self.close() self.close() else: t = last_t last_t = t self.level += 1 gen_description(m) self.level -= 1 def gen_getitem_def(self, op): self.open('dt') self.gen_getitem_ref(op, 1) self.close() self.gen_mapping_description(op) def gen_getitem_ref(self, op, subdescript=0): link_name = self.get_link_name(op) if subdescript: self.open('define', link_name) if subdescript: self.close() else: self.open('link_to', link_name) self.gen_text('# ') self.close() self.gen_self(op) self.gen_index(op) self.gen_returns(op, subdescript) def gen_index(self, op): self.gen_text('[') self.gen_arguments(op.get_arguments()) self.gen_text(']') def gen_link_to_operator(self, link_name): self.open('to_html_only') self.open('link_to', link_name) self.gen_text('# ') self.close() self.close() def gen_mapping_doc(self, m): def gen_synopsis(m): self.gen_outer_dt('Synopsis') self.open('dd') self.gen_mapping_ref(m) self.close() self.gen_header(m) self.open('dl') self.gen_Name(m) gen_synopsis(m) self.gen_mapping_description(m) self.close() def gen_mapping_kind(self, m, subdescript=0, withself=0): if withself and self.get_self_node(m): self.gen_self(m) self.gen_text('(') self.gen_arguments(m.get_arguments()) self.gen_text(')') self.gen_returns(m, subdescript) def gen_mapping_ref(self, m): self.gen_mapping_tag(m) self.gen_mapping_kind(m, 0, 1) def gen_mapping_tag(self, a, subdescript=0): link_name = self.get_link_name(a) if not subdescript: self.open('link_to', link_name) else: self.open('define', link_name) self.open('strong') self.gen_text('callable') self.close() self.close() self.gen_colon() def gen_Name(self, m): self.gen_outer_dt('Name') self.open('dd') self.open('h2') self.gen_text(m.get_Name()) self.close() self.close() def gen_name(self, a): self.gen_text(a.get_name()) def gen_operator_def(self, op): self.open('dd') self.gen_operator_ref(op, 1) self.open('dl') self.gen_mapping_description(op) self.close() self.close() def gen_operator_ref(self, op, subdescript=0): # self.gen_text('(') link_name = self.get_link_name(op) if subdescript: self.open('define', link_name) if subdescript: self.close() else: self.gen_link_to_operator(link_name) self.gen_self(op) self.gen_text(' ') self.open('big') self.open('strong') self.gen_text(op.src.node.arg.strip()) self.close() self.close() for a in op.get_arguments(): self.gen_text(' ') t = a.d_tag if t == 'arg': self.gen_argref(a) else: assert 0 # self.gen_text(')') self.gen_returns(op, subdescript) def gen_outer_dt(self, text): # Synopsis, Description etc self.open('dt') if not self.level: self.open('h2') else: self.open('strong') if self.level == 1: self.open('big') if callable(text): text() else: self.gen_text(text) if self.level == 1: self.close('big') self.close() self.close() def gen_posarg_name(self, a): self.open('var') self.gen_name(a) self.close() def gen_ref(self, k): t = k.d_tag getattr(self, 'gen_%s_ref' % t)(k) def gen_returns(self, m, subdescript): if self.no_ret: return ars = m.find_aspects('returns') if not ars: return self.open('spc_mapsto') self.close() rk = m.get_return_kind() if subdescript: t = rk.d_tag if t in ('mapping',): self.gen_kind_aspects([rk], 1) else: self.gen_def(rk) else: self.gen_ref(rk) def gen_reverse_operator_def(self, op): self.open('dd') self.gen_reverse_operator_ref(op, 1) self.open('dl') self.gen_mapping_description(op) self.close() self.close() def gen_reverse_operator_ref(self, op, subdescript=0): # self.gen_text('(') link_name = self.get_link_name(op) if subdescript: self.open('define', link_name) self.close() else: self.gen_link_to_operator(link_name) for a in op.get_arguments(): t = a.d_tag if t == 'arg': self.gen_argref(a) else: assert 0 self.open('big') self.gen_text(' ') self.open('strong') self.gen_text(op.src.node.arg.strip()) self.close() self.gen_text(' ') self.close() self.gen_self(op) # self.gen_text(')') self.gen_returns(op, subdescript) def gen_self(self, op): s = self.get_self_node(op) if not s: self.open('em') self.gen_text('self') self.close() else: self.out.append(s) def gen_self_def(self, k): pass def gen_self_descriptions(self, li): pass def gen_self_ref(self, k): self.open('h3') self.gen_text('For any object ') self.open('var') self.gen_text(k.src.node.arg.strip()) self.close() self.gen_text(' of kind ') self.gen_localname(k.env) self.gen_text(':') self.close() def gen_self_syn(self, li): for k in li: self.open('dt') self.gen_self_ref(k) self.close() def gen_setitem_def(self, op): self.open('dt') self.gen_setitem_ref(op, 1) self.close() self.gen_mapping_description(op) def gen_setitem_ref(self, op, subdescript=0): link_name = self.get_link_name(op) if subdescript: self.open('define', link_name) if subdescript: self.close() else: self.gen_link_to_operator(link_name) self.gen_self(op) args = op.get_arguments() self.gen_text('[') self.gen_arguments(args[:-1]) self.gen_text(']') self.open('strong') self.open('big') self.gen_text(' = ') self.close() self.close() self.gen_arguments(args[-1:]) def gen_subkind_of_def(self, k): ds = k.find_aspects('description') if not ds: return self.open('dt') self.gen_subkind_of_ref(k, 1) self.close() self.level += 1 for d in ds: self.gen_description_dd(d) self.level -= 1 def gen_subkind_of_descriptions(self, li): for a in li: self.gen_outer_dt(lambda: self.gen_subkind_of_ref(a, 1)) for d in a.find_aspects('description'): self.gen_description_dd(d) def gen_subkind_of_ref(self, k, subdescript=0): link_name = self.get_link_name(k) if subdescript: self.open('define', link_name) else: self.open('link_to', link_name) self.gen_text('Subkind of') self.close() self.gen_colon() comma = 0 for a in k.args: if comma: self.gen_text(', ') comma = 1 self.gen_localname(a) def gen_subkind_of_syn(self, li): for a in li: self.gen_outer_dt(lambda: self.gen_subkind_of_ref(a, 0)) def gen_superkind_of_ref(self, k): kas = k.find_kind_aspects() if len(kas) == 1: self.gen_ref(kas[0]) else: assert 0 # to be tested def gen_superkind_ref(self, k): self.gen_localname(k) def gen_synopsis(self, m): ats = m.find_aspects('') ats = self.combine_attrs_of_same_kind(ats) tab = self.sortup_aspects(ats, synopsis=1) if tab: self.gen_outer_dt('Synopsis') self.open('dd') self.open('dl') self.level += 1 for typ, li in tab: try: gen_syn = getattr(self, 'gen_%s_syn' % typ) except AttributeError: name = typ.capitalize().replace('_', ' ') if len(li) != 1: name = name+'s' self.gen_outer_dt(name) for a in li: self.open('dd') self.gen_ref(a) self.close() else: gen_syn(li) self.level -= 1 self.close() self.close() def get_self_node(self, a): sn = self.use_self if sn is None: sn = a.get_self_name() if sn is not None: sn = self.node_of_taci('text', sn) return sn def sortup_aspects(self, ats, synopsis=0): # Get aspects sorted up in the same order for synopsis and main description order = ('description', 'subkind_of', 'constructor', 'self', 'method', 'operator', 'mapping', 'attribute', 'condition', 'example', ) tab = {} def gen_outer(what): assert what in order if what not in tab: tab[what] = [] tab[what].append(a) for a in ats: t = a.d_tag if t == 'comment' or t == 'description' and synopsis: pass elif t in ('attribute', 'attributes', 'either'): if a.is_method(): gen_outer('method') else: gen_outer('attribute') elif a.d_type == 'operator' or t in ('getitem', 'delitem', 'setitem'): gen_outer('operator') else: gen_outer(t) otab = [] for typ in order: if not typ in tab: continue li = tab[typ] otab.append((typ, li)) return otab class _GLUECLAMP_: _imports_ = ( '_parent.FileIO:IO', '_parent.Gsml:node_of_gsml', '_parent:Html', '_parent:Latex', '_parent.Main:ReportedError', '_parent.SpecNodes:node_of_string', '_parent.SpecNodes:node_of_taci', '_parent.SpecNodes:node_aliases', '_parent:Tester', '_parent:XHTML' ) # Map from output mode spelling in output directive to handler name # -- Why should we need to map anyway? # or should we just say they are case insensitive? # If they are case insenitive, we need to map here. # I hereby decide they are case insensitive! output_handlers = {'html': 'Html', 'xhtml': 'XHTML', 'latex': 'Latex', 'tester': 'Tester'} # Brackets to use when rendering kind references kindbrackets = ('[', ']') #kindbrackets = ('{','\n}') kindbrackets = (' (', ' )') #kindbrackets = ' ' # Brackets to use when rendering either kinds eitherbrackets = '[]' # Text to use to render any kind anykind = 'anything' def document(self, node, env): return Document(self, node, env) def _test_main_(self): class TestSubject: def __init__(self, mod, name): self.mod = mod self.name = name self.node_of_string = mod._parent.SpecNodes.node_of_string def use(self, args): name = self.name if name == 'A': return self.node_of_string("""\ .text: hello """) elif name == 'reverse': args.reverse() return self.mod.node_of_taci('string', '', args, 0) else: assert 0 class TestEnv: def __init__(self, mod): self.mod = mod def get_descr_by_name(self, name, node): return TestSubject(self.mod, name) env = TestEnv(self) x = """ .h1: Description of subject ..em ...use: A .h1: Reversing arguments .use: reverse ..text: A ..text: B ..text: C """ node = self._parent.SpecNodes.node_of_string(x) y = self.document(node, env) r = y.get_result() # FIXME: Assert equals to something? print(r) h = self._parent.Html.node2text(r) assert h == ''' <h1>Description of subject<em> hello </em></h1> <h1>Reversing arguments</h1> C B A'''	57.55 KB	2026-01-20 12:58
📄 DottedTree.py """ Handling of tree structures given in a special 'dotted' syntax. This represents trees of nodes with strings as tags, in a readable and writable and easy to parse syntax. There are two main functions, unparse_sexpr and parse_string. When parsing, the result is by default given in 'sexpr' format: each node is a tuple of the form (tag, ) or (tag, node) or (tag, node, node) ... The following invariant is intended to hold for every node x, parse_string(unparse_sexpr(x)) == x Currently the following invariant has been tested for some strings: unparse_sexpr(parse_string(s)).strip() == s.strip() [It only holds on stripped results but may be fixed sometime.] """ class Node(object): __slots__ = 'tag', 'children', 'index', def __init__(self, tag, children, index): self.tag = tag self.children = children self.index = index def as_sexpr(self): return (self.tag,) + tuple([c.as_sexpr() for c in self.children]) def __repr__(self): return '%s(%r, %r, %r)' % ( self.__class__.__name__, self.tag, self.children, self.index) class _GLUECLAMP_: _imports_ = ( '_parent.FileIO:IO', ) ## # The name of attributes that are configurable in instances. # _chgable_ = 'node', 'dotchar' ## # The character that begins the 'dotted' indentation. dotchar = '.' ## # The character that quotes lines beginning with dots and itself. quotechar = '\\' ## # Construct a new node. # @return # This variant returns a tuple in s-expression form. # @param tag a string # @param children a sequence of nodes # @param lineindex line index of tag, not used in s-expressions def node_sexpr(self, tag, children, lineindex): return (tag,) + tuple(children) ## # Construct a new node. # @return # This variant returns a Node object. # @param tag a string # @param children a sequence of nodes # @param lineindex line index of beginning tag, first line = 0 def node_node(self, tag, children, lineindex): return Node(tag, tuple(children), lineindex) node = node_node def parse_file(self, file, src=None): return self.parse_string(self.IO.read_file(file), src) ## # Parse a dotted tree text given as a sequence of lines. # @param pos # @param tag list with first line of tag, if any # @param lineindex line index of tag # @param it iterator yielding remaining lines # @return a triple (index, nextvar, node) where # index is the index of line 'nextvar', # nextvar is the first line of next node to parse, and # node is the resulting node of this parse. def parse_iter(self, pos, tag, lineindex, it, src=None): dotchar = self.dotchar quotechar = self.quotechar children = [] firstline = lineindex while 1: try: lineindex, nextvar = next(it) except StopIteration: nextvar = None break if not nextvar.startswith(dotchar): tag.append(nextvar) else: break for (i, t) in enumerate(tag): if (t.startswith(quotechar+dotchar) or t.startswith(quotechar+quotechar+dotchar)): tag[i] = t[len(quotechar):] if tag == ['']: tag = '\n' else: tag = '\n'.join(tag) while 1: if (nextvar is None or len(nextvar) <= pos or nextvar[pos] != dotchar or not nextvar.startswith(dotchar(pos+1))): return lineindex, nextvar, self.node(tag, children, firstline) if len(nextvar) > pos+1 and nextvar[pos+1] == dotchar: if src is None: raise SyntaxError('Level must increase with 1 max') else: src.error('Level must increase with 1 max', lineindex) lineindex, nextvar, child = self.parse_iter(pos+1, [nextvar[pos+1:]], lineindex, it, src) children.append(child) def parse_lines(self, lines, src=None): it = enumerate(lines) lineindex, nextvar, node = self.parse_iter(0, [], 0, it, src) assert nextvar is None return node def parse_string(self, string, src=None): if string: lines = string.split('\n') else: lines = [] return self.parse_lines(lines, src) ## # Unparse a tree given on Node form def unparse_node(self, node): return self.unparse_sexpr(node.as_sexpr()) ## # Unparse a tree given on sexpr form # @return a string in dotted-tree form def unparse_sexpr(self, sexpr): li = [] def unparse(depth, sexpr): li.append(self.unparse_tag(depth, sexpr[0])) for x in sexpr[1:]: unparse(depth+1, x) unparse(0, sexpr) return '\n'.join(li) def unparse_tag(self, depth, tag): dotchar, quotechar = self.dotchar, self.quotechar tag = tag.split('\n') for (i, t) in enumerate(tag): if (t.startswith(dotchar) or t.startswith(quotechar + dotchar)): tag[i] = quotechar + t tag = '\n'.join(tag) tag = dotchardepth+tag return tag def test_1(): # Test parsing to sexpr's and back # for a variety of cases from guppy import Root dt = Root().guppy.gsl.DottedTree dt.node = dt.node_sexpr parse = dt.parse_string unparse = dt.unparse_sexpr for x, y in [ ['', ('',)], ['a', ('a',)], ['.a', ('', ('a',))], ['a\n.b', ('a', ('b',))], ['a\nb\n.c', ('a\nb', ('c',))], ["""\n.a\n..a""", ('\n', ('a', ('a',)))], ["""hello\n.a\n.b\n..ba\nx\n..bb""", ('hello', ('a',), ('b', ('ba\nx',), ('bb',)))], # Quoting dots [r'\.', ('.',)], [r'.\.', ('', ('.',))], # Preserving quote ['\\', ('\\',)], ['.\n\\', ('', ('\n\\',))], # Quoting quote-dots [r'\\.', (r'\.',)], # Preserving whitespace starting a tag # Or should it be stripped? I think better not, it would complicate transparency. [r'. tag', ('', (' tag', ))], # Preserving initial whitespace [' ', (' ',)], # Preserving initial newline ['\n', ('\n',)], ['\na', ('\na',)], # A n intended usage example [''' initial text .aspect for guppy.hsp ..returns ...type A ...latex ~\\ \..~\|begincolorbox\|~raw::~LaTeX~\\ ~\\ ~~~{\textbackslash}{\textbackslash}begin{\{}center{\}}~\\ .aspect for guppy.gsl ..contains DottedTree ''', ('\ninitial\ntext', ('aspect for guppy.hsp', ('returns', ('type A',), ('latex\n~\\\n..~\|begincolorbox\|~raw::~LaTeX~\\\n~\\\n~~~{\textbackslash}{\textbackslash}begin{\\{}center{\\}}~\\',))), ('aspect for guppy.gsl', ('contains DottedTree\n',)))] ]: z = parse(x) if y is not None: assert z == y assert unparse(z).strip() == x.strip() # Unparsing x and then parsing should give back x transparently # for any tree x, involving any combination of dots, quotes and other characters. # List of special chars and one normal chars = [dt.quotechar, dt.dotchar, '\n', ' ', 'a'] import random ## # Generate a random node with random number of children. # Shuffles the chars list to make the tag string. # @param maxchild maximum number of children def randnode(maxchild): numchild = random.randint(0, maxchild) random.shuffle(chars) tag = ''.join(chars) children = [randnode(maxchild-1) for i in range(numchild)] return dt.node(tag, children, 0) for i in range(10): y = randnode(3) x = unparse(y) z = parse(x) assert z == y def test_2(): # Test parsing to Node # that the line lineindex are correct # They start from 0, since enumerate() generates them, # It seemed inconsistent to change them to start from 1. # Which will be made in error prints. from guppy import Root dt = Root().guppy.gsl.DottedTree parse = dt.parse_string unparse = dt.unparse_node node = parse("""\ line 0 .line 1 ..line 2 line 3 .line 4 """) exp = Node('line 0', ( Node('line 1', (Node('line 2\nline 3', (), 2),), 1), Node('line 4\n', (), 4)), 0) assert repr(node) == repr(exp) def test_main(): test_1() test_2()	8.58 KB	2026-01-20 12:58
📄 Exceptions.py class GSL_Error(Exception): pass class TooManyErrors(GSL_Error): pass class HadReportedError(GSL_Error): pass class ReportedError(GSL_Error): pass class UndefinedError(ReportedError): pass class DuplicateError(ReportedError): pass class CompositionError(GSL_Error): pass class CoverageError(ReportedError): pass class ConditionError(GSL_Error): pass	402 B	2026-01-20 12:58
📄 FileIO.py class TestPath: _path_using_io = ( 'abspath', 'curdir', 'exists', 'expanduser', 'expandvars', 'getatime', 'getctime', 'getmtime', 'getsize', 'isfile', 'islink', 'ismount', 'realpath', 'samefile', 'sameopenfile', 'samestat', 'walk', ) def __init__(self, os): for name in dir(os.path): if (not name.startswith('_') and name not in self._path_using_io): setattr(self, name, getattr(os.path, name)) class TestIO: def __init__(self, mod): os = mod._root.os for name in mod.os_common: setattr(self, name, getattr(os, name)) self.path = TestPath(os) self.files = {} self.tempno = 0 def access(self, name, mode): if name in self.files: return True return False def listdir(self, name): li = [] name = self.path.join(name, '') for k in self.files: if k.startswith(name): rest = k[len(name):] if rest: li.append(rest) return li def mkdtemp(self): self.tempno += 1 return '/tmp/xyz%d' % self.tempno def read_file(self, name): return self.files[name] def remove(self, name): try: del self.files[name] except KeyError: raise IOError('No such file: %r' % name) def rename(self, src, tgt): try: data = self.files[src] except KeyError: raise IOError('No such file: %r' % src) del self.files[src] self.files[tgt] = data def rmdir(self, name): pass def write_file(self, name, text): self.files[name] = text class RealIO: def __init__(self, mod): os = mod._root.os for name in mod.os_common: setattr(self, name, getattr(os, name)) self.path = os.path self.listdir = os.listdir self.makedirs = os.makedirs self.mkdtemp = mod._root.tempfile.mkdtemp self.rmdir = os.rmdir self.access = os.access self.chdir = os.chdir self.remove = os.remove self.rename = os.rename def read_file(self, name): with open(name) as f: return f.read() def write_file(self, name, data): with open(name, 'w') as f: f.write(data) class _GLUECLAMP_: _setable_ = 'IO', os_common = ('R_OK', 'W_OK', 'X_OK') def _get_IO(self): return RealIO(self) def set_IO(self, IO): self.IO = IO def set_test_mode(self): self.set_IO(TestIO(self))	2.6 KB	2026-01-20 12:58
📄 Filer.py """ Handles filing of data from low-level gsl filing and data records. """ class Filer: def __init__(self, mod, node): self.mod = mod self.writefile_envs = [] self.writefile_names = {} node.accept(self) def visit_file(self, node): node.children_accept(self) visit_string = visit_file def visit_write_file(self, node): name = node.arg if name in self.writefile_names: raise SyntaxError('Duplicate file name: %r' % name) self.writefile_names[name] = node self.writefile_envs.append(WriteFile(self, node)) def get_info(self): infos = [] for e in self.writefile_envs: infos.append('write file: %s' % e.file_name) return '\n'.join(infos) def write(self): for e in self.writefile_envs: e.write() class WriteFile: node_data = None node_mode = None def __init__(self, filer, node): self.filer = filer self.mod = mod = filer.mod self.node_file = node self.file_name = node.arg node.children_accept(self) if self.node_data is None: data = '' else: data = self.node_data.arg self.data = data if self.node_mode is None: mode = '' else: mode = self.node_mode.arg self.mode = mode def visit_text(self, node): self.set_single('node_data', node) def visit_end(self, node): self.set_single('node_end', node) def visit_mode(self, node): self.set_single('node_mode', node) def set_single(self, name, node): if getattr(self, name, None) is not None: raise SyntaxError('Duplicate %r at index %r' % (name, node.index)) setattr(self, name, node) node.children_accept(self, 'no_node_expected') def write(self): IO = self.mod.IO if self.mod.backup_suffix: backup_name = self.file_name + self.mod.backup_suffix if IO.access(self.file_name, IO.R_OK \| IO.W_OK): IO.rename(self.file_name, backup_name) IO.write_file(self.file_name, self.data) class _GLUECLAMP_: _imports_ = ( '_parent.FileIO:IO', ) _setable_ = 'backup_suffix', # Files that are to be overwritten are renamed by # adding backup_suffix to the name. This is no substitute for a # versioning system but a last precaution, especially while I am # developing the system. # Set this to None to disable backuping. backup_suffix = ',gsl-backuped' syntax_gsl = ''' .tag writefile ''' def filer(self, node): return Filer(self, node) def _test_main_(self): IO = self.IO N = self._parent.SpecNodes tempdir = IO.mkdtemp() tempname = IO.path.join(tempdir, 'x') data = 'hello' try: X = ''' .write file: %s ..text %s ..end ''' % (tempname, data) node = N.node_of_string(X) f = self.filer(node) assert f.get_info() == 'write file: %s' % tempname f.write() d = IO.read_file(tempname) assert d == data # Test multiple files and backup # And that we can do without ..data / ..end data2 = 'hello2\n' data3 = '\nhello3' X = ''' .write file: %s ..text %s .write file: %s ..text %s ..end ''' % (tempname, data2, tempname+'.3', data3) node = N.node_of_string(X) f = self.filer(node) f.write() assert IO.read_file(tempname+self.backup_suffix) == data d = IO.read_file(tempname) assert d == data2 assert IO.read_file(tempname+'.3') == data3 finally: for name in IO.listdir(tempdir): IO.remove(IO.path.join(tempdir, name)) IO.rmdir(tempdir)	3.83 KB	2026-01-20 12:58
📄 Gsml.py class GsmlHandler: # To be mixed in with something like HTMLParser.HTMLParser def handle_starttag(self, tag, attrs): self.stack.append(self.out) self.out = [] if attrs: at = [] for k, v in attrs: at.append(self.mod.node_of_taci(k, v)) self.out.append(self.mod.node_of_taci('with', '', at)) def handle_endtag(self, tag): node = self.mod.node_of_taci(tag, '', self.out) self.out = self.stack.pop() self.out.append(node) def handle_charref(self, name): if name[:1] == "x": char = int(name[1:], 16) name = '0'+name else: char = int(name) if 0 <= char < 128: char = chr(char) self.handle_data(char) else: self.out.append(self.mod.node_of_taci('char', name)) def handle_entityref(self, name): if name not in self.mod.entitydefs: self.unknown_entityref(name) self.out.append(self.mod.node_of_taci('char', name)) def unknown_entityref(self, name): raise SyntaxError('Unknown entity ref: %r' % name) def handle_data(self, data): # data = data.strip() if data.strip(): self.out.extend(self.mod.nodes_of_text(data)) def handle_comment(self, data): self.out.append(self.mod.node_of_taci('comment', data, (), 0)) def handle_decl(self, decl): self.out.append(self.mod.node_of_taci('html_declaration', decl)) def handle_pi(self, data): self.out.append(self.mod.node_of_taci('processing_instruction', data)) class _GLUECLAMP_: _imports_ = ( '_root.html.parser:HTMLParser', '_parent.SpecNodes:node_of_taci', '_parent.SpecNodes:nodes_of_text', '_root.htmlentitydefs:entitydefs', ) encoding = "iso-8859-1" def node_of_gsml(self, text): class Parser(GsmlHandler, self.HTMLParser): def __init__(self, mod): mod.HTMLParser.__init__(self) self.mod = mod self.out = [] self.stack = [] p = Parser(self) p.feed(text) p.close() if p.stack: raise SyntaxError('Missing end tag') node = self.node_of_taci('block', '', p.out, 0) return node def _test_main_(self): x = """ <!DOCTYPE html...> This is an <em> emphasized </em> word. See also <a href="guppy-pe.sf.net"> Guppy. </a> Defined as <use_my_macro/>. Handle char ref: d. Handle char ref: <. <!-- A comment --> <?A processing instruction> <namespace:tag /> """ node = self.node_of_gsml(x) # FIXME: Assert equals to something? print(node)	2.69 KB	2026-01-20 12:58
📄 Help.py class _GLUECLAMP_: _imports_ = ( '_root:os', '_root:webbrowser', ) default_doc_file = 'guppy.html' def doc(self, subject=None, args, *kwds): """\ This doesnt work well or at all There are painful were where-to-find the files issues for the distributed and installed package. for I couldn't have the data among the modules themselves. Get documentation about a subject or generally about the Guppy system. It will show the documentation in the system web browser. If the subject argument is an object that the documentation system recognizes, it will bring up the documentation for that kind of object. Otherwise it will bring up a general documentation page. """ self.doc_default() def doc_default(self): self.open_local_filename(self.default_doc_file) def open_local_filename(self, filename): self.webbrowser.open(self.os.path.join(self.doc_dir, filename))	1018 B	2026-01-20 12:58
📄 Html.py class Node2Html: def __init__(self, mod, node=None, error_report=None, encode_name=None ): self.mod = mod self.valid_html40 = False self.encode = self.mod.encode if encode_name is None: encode_name = self.mod.encode_name self.encode_name = encode_name if error_report is not None: self.error_report = error_report self.document_lang = None self.header_nodes = [] self.indent = 0 self.indentstep = 1 self.set_out([]) # xxx where do this? charset = 'utf-8' self.header_nodes.append(self.mod.node_of_taci( 'meta', '', ( self.mod.node_of_taci('http-equiv=', 'Content-Type'), self.mod.node_of_taci('content=', 'text/html; charset=%s' % charset)))) if node is not None: node.accept(self) def _visit_children(self, node): node, attrs = node.split_attrs() # xxx handle attrs? E = self.mod.ReportedError for ch in node.children: try: ch.accept(self) except E: pass def begin(self, tag, arg=''): if arg: t = '<%s %s>' % (tag, arg) else: t = '<%s>' % tag if tag in self.mod.line_break_allowed: t = '\n'+self.indent * ' ' + t self.append(t) self.indent += self.indentstep def chg_out(self, out): oo = self.out self.set_out(out) return oo def encode_link_name(self, name): # 1. Make the name better looking for a html user's perspective # 2. Encode it by HTML rules if name.startswith(self.mod.tgt_prefix): name = name[len(self.mod.tgt_prefix):] else: # Should not happen often or at all assert 0 name = self.encode_name(name) return name def end(self, tag): self.indent -= self.indentstep self.append('</%s>' % tag) def error(self, msg, args, kwds): msg = 'Doc2Html: ' + msg self.error_report(msg, args, *kwds) def error_report(self, msg, args, kwds): print('HTML ENCODING ERROR: ', msg, 'args=', args, 'kwds=', kwds) raise ValueError def gen_document_header(self, lang, header_nodes): # lang & title are nodes with text or char directives, to be encoded. # metas is a list of nodes, with data to be encoded self.append("""\ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd"> """) self.begin('html', 'lang=%s' % self.get_encoded_text(lang)) self.begin('head') for node in header_nodes: self.gen_stdhtml(node) self.end('head') self.begin('body') # Get around w3c restriction that character data are not allowed # directly in body, makes it easier to write compliant code # Arguably the restriction is there for a reason, but I dont know... self.begin('div') def gen_document_trailer(self): self.end('div') self.end('body') self.end('html') def gen_empty_elmt(self, tag, arg=''): self.begin(tag, arg) self.indent -= self.indentstep def gen_generated_from_gsl(self): self.gen_empty_elmt('hr') self.append('Generated by ') self.begin('a', 'href="https://zhuyifei1999.github.io/guppy3/gsl.html"') #self.begin('a', 'href="gsl.html"') self.append('GSL-HTML 3.0.1') self.end('a') self.append(' on '+self.mod.time.asctime(self.mod.time.localtime())) def gen_meta(self, node, tag=None): mknode = self.mod.node_of_taci if tag is None: tag = node.tag self.header_nodes.append( mknode('meta', '', [mknode('name=', tag), mknode('content=', node.arg, node.children)])) def gen_stdhtml(self, node, tag=None, options): if tag is None: tag = node.tag node, attrs = node.split_attrs(tag) self.begin(tag, ' '.join(['%s=%r' % (key, val) for (key, val) in attrs])) if tag in self.mod._no_end_tag_elements: if node.arg: self.error( 'No enclosed text allowed for Html tag: %r.' % node.tag) self.no_children(node) self.indent -= self.indentstep else: node.arg_accept(self) self.end(tag) def get_encoded_text(self, node): # From a node's arg and children that are text or characters old_out = self.chg_out([]) self.append(self.encode(node.arg)) for ch in node.children: if ch.tag in ('text', 'char'): ch.accept(self) else: self.error('Only text and char allowed here, not %r.' % ch.tag, ch) return ''.join(self.chg_out(old_out)) def get_html(self): return ''.join(self.out) def no_children(self, node): if node.children: self.error('No children allowed for %r. Got children nodes = %r.' % ( node.tag, node.children)) def set_out(self, out): self.out = out self.extend = out.extend self.append = out.append def visit_author(self, node): self.gen_meta(node) def visit_block(self, node): self._visit_children(node) def visit_char(self, node): name = node.get_namearg() if name in self.mod.name2codepoint: name = '&%s;' % name else: if name[:2] == "0x": char = int(name[2:], 16) elif name.isdigit(): char = int(name) else: self.error('No such character: %r.' % name, node) name = self.mod.codepoint2name.get(char) if name is None: name = '&#%d;' % char else: name = '&%s;' % name self.append(name) self._visit_children(node) def visit_col_width(self, node): self.append('<col width="%s" />' % node.arg) def visit_comment(self, node): return #self.append('<!-- %s -->'%node.arg) def visit_default(self, node): if node.tag in self.mod.stdhtml: if node.tag in self.mod._head_elements: self.head_nodes.append(node) else: self.gen_stdhtml(node) else: self.error('I don\'t know what to generate for the tag %r.' % node.tag, node) def visit_define(self, node): name = self.encode_link_name(node.arg) self.begin('a', 'name=%r' % name) self._visit_children(node) self.end('a') def visit_document(self, node): self.indent = 2 # Known indentation of header to be generated later oldout = self.chg_out([]) self._visit_children(node) self.gen_generated_from_gsl() newout = self.chg_out(oldout) mknode = self.mod.node_of_taci lang = self.document_lang if not lang: lang = mknode('document_lang', 'en') self.indent = 0 self.gen_document_header(lang, self.header_nodes) self.out.extend(newout) self.gen_document_trailer() def visit_document_lang(self, node): if self.document_lang is not None: self.error('Duplicate document lang directive.', node) self.document_lang = node def visit_document_title(self, node): self.header_nodes.append(self.mod.node_of_taci('title', node.arg)) def visit_enumerate(self, node): self.begin('ol') for c in node.children: self.begin('li') c.accept(self) self.end('li') self.end('ol') def visit_exdefs(self, node): self.symplace = {} for ch in node.children: syms = [x.strip() for x in ch.arg.split(',')] for sym in syms: self.symplace[sym] = ch.tag def visit_file(self, node): self._visit_children(node) def visit_header(self, node): self.header_nodes.extend(node.children) def visit_itemize(self, node): self.begin('ul') for c in node.children: self.begin('li') c.accept(self) self.end('li') self.end('ul') def visit_link_to_extern(self, node): name = node.arg docname = node.children[0].arg children = node.children[1:] uri = '%s.html#%s' % (docname, self.encode_link_name(name)) self.begin('a', 'href=%r' % uri) if not children: self.append(self.encode(name)) else: for ch in children: ch.accept(self) self.end('a') def visit_link_to_local(self, node): name = node.arg uri = '#%s' % self.encode_link_name(name) self.begin('a', 'href=%r' % uri) if not node.children: self.append(self.encode(name)) else: self._visit_children(node) self.end('a') def visit_link_to_unresolved(self, node): name = node.arg self.begin('em') if not node.children: self.append(self.encode(name)) else: self._visit_children(node) self.end('em') def visit_literal_block(self, node): self.gen_stdhtml(node, 'pre') def visit_man_page_mode(self, node): self._visit_children(node) def visit_meta(self, node): self.document_metas.append(node) def visit_spc_colonkind(self, node): # self.append(' <strong>:</strong> ') # self.append(' <code>:</code> ') self.append('<code>:</code> ') def visit_spc_mapsto(self, node): self.append(' <strong>-></strong> ') def visit_string(self, node): self._visit_children(node) def visit_symbol(self, node): self.visit_text(node) def visit_text(self, node): text = self.encode(node.arg) if len(text) > 80 or '\n' in text: self.append('\n') self.append(text) self._visit_children(node) def visit_to_document_only(self, node): self._visit_children(node) def visit_to_html_only(self, node): self._visit_children(node) def visit_to_tester_only(self, node): pass def visit_valid_html40(self, node): self.valid_html40 = node node, attrs = self.valid_html40.split_attrs(attrdict=True) # XXX check allowed attrs but in a GENERAL way # Code taken from validator.w3.org self.append("""\ <a href="http://validator.w3.org/check?uri=referer"><img src="%s" alt="Valid HTML 4.0 Strict" height="31" width="88"></a> """ % attrs.get('src', 'http://www.w3.org/Icons/valid-html40')) def visit_with(self, node): pass def visit_word(self, node): self._visit_children(node) class _GLUECLAMP_: _imports_ = ( '_parent:SpecNodes', '_parent.SpecNodes:node_of_taci', '_parent.Gsml:is_not_ascii', '_parent.Main:tgt_prefix', '_parent.Main:ReportedError', '_root.html.entities:name2codepoint', '_root.html.entities:codepoint2name', '_root:re', '_root:time', ) _chgable_ = ('tag_uppercase_name_chars',) # Set to make upper-case name characters tagged to make sure # no names in a file differ only in case as stated in HTML spec. # I believe this doesn't matter in practice in contemporary browsers, # since references are also said to be case sensitive! # -- I can't be bothered to solve this better now. See also Notes Aug 12 2005. tag_uppercase_name_chars = 0 _html3_2 = ( 'a', 'address', 'area', 'b', 'base', 'big', 'blockquote', 'body', 'br', 'caption', 'center', 'cite', 'code', 'dfn', 'dt', 'dl', 'dd', 'div', 'em', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'html', 'i', 'img', 'input', 'kbd', 'li', 'ol', 'option', 'p', 'param', 'pre', 'samp', 'select', 'small', 'strong', 'style', 'sub', 'sup', 'table', 'td', 'textarea', 'th', 'thead', 'title', 'tr', 'tt', 'ul', 'var') # Included in Html 3.2 but 'deprecated' in Html 4.0 _html4_0_deprecated = ( 'applet', 'basefont', 'dir', 'font', 'isindex', 'strike', 'u', ) # Included in 3.2, not depreciated in 4.0 but one may want to avoid them _html_avoid = ( 'script', ) _html4_0 = ( 'abbr', 'acronym', 'bdo', 'button', 'col', 'colgroup', 'del', 'fieldset', 'frame', 'frameset', 'iframe', 'ins', 'label', 'legend', 'noframes', 'noscript', 'object', 'optgroup', 'q', 's', 'span', 'tbody', 'tfoot', 'thead') _head_elements = ( 'base', 'isindex', 'link', 'meta', 'script', 'style', 'title' ) # The ones that can have no end tag # xxx are there more -style etc- look it up! _no_end_tag_elements = ( # Header elmts 'meta', 'link', # Other 'img') # The ones that we may generate line-break before # and hope it will not affect the insertion of spaces in rendering. _line_break_allowed = ( 'html', 'head', 'body', 'frameset', # Head Elements ) + _head_elements + ( # Generic Block-level Elements 'address', 'blockquote', 'center', 'del', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'ins', 'isindex', 'noscript', 'p', 'pre', # Lists 'dir', 'dl', 'dt', 'dd', 'li', 'menu', 'ol', 'ul', # Tables 'table', 'caption', 'colgroup', 'col', 'thead', 'tfoot', 'tbody', 'tr', 'td', 'th', # Forms 'form', 'button', 'fieldset', 'legend', 'input', 'label', 'select', 'optgroup', 'option', 'textarea' ) # The attributes allowed in META elements meta_attributes = ('name', 'http-equiv', 'content', 'scheme', 'lang', 'dir') # This returns a function checking if a character is allowed to be used # as the first character in a NAME or ID attribute. # (I don't think this is the same as .isalpha() with unicode.) def _get_is_name_starter_char(self): return self.re.compile(r"[A-Za-z]").match # This returns a function checking if a character is allowed to be used # after the first character in a NAME or ID attribute. def _get_is_name_follower_char(self): return self.re.compile(r"[A-Za-z0-9\-_:\.]").match # A set of the ones we generate directly. # This includes the ones from html 3.2 and # I have also included the deprecated and the 4.0 only def _get_stdhtml(self): sh = {} for x in self._html3_2 + self._html4_0_deprecated + self._html4_0: sh[x] = 1 return sh def _get_line_break_allowed(self): sh = {} for x in self._line_break_allowed: sh[x] = 1 return sh def doc2filer(self, doc, node, name, dir, opts, IO): text = self.doc2text(doc, node) path = IO.path.join(dir, '%s.html' % name) node = self.node_of_taci('write_file', path, [ self.node_of_taci('text', text)]) return node def doc2text(self, doc, node): d2h = Node2Html(self, node, doc.env.error) return d2h.get_html() def node2file(self, node, file): text = self.node2text(node) with open(file, 'w') as f: f.write(text) def node2text(self, node): text = Node2Html(self, node).get_html() return text # Adapted from html4css1.py in docutils def encode(self, text): """Encode special characters in `text` & return.""" # @@@ A codec to do these and all other HTML entities would be nice. text = text.replace("&", "&") text = text.replace("<", "<") text = text.replace('"', """) text = text.replace(">", ">") text = text.replace("@", "@") # may thwart some address harvesters return text # Encode a name according to HTML spec. See also Notes Aug 12 2005. # From wdghtml40/values.html#cdata : # Attribute values of type ID and NAME must begin with a letter in the # range A-Z or a-z and may be followed by letters (A-Za-z), digits # (0-9), hyphens ("-"), underscores ("_"), colons (":"), and periods # ("."). These values are case-sensitive. def encode_name(self, name): is_name_follower_char = self.is_name_follower_char ns = [] append = ns.append upperstate = 0 ch = name[:1] if ch == 'z' or not self.is_name_starter_char(ch): append('z') if ch == 'z': append('z') for ch in name: if ch == '-' or not is_name_follower_char(ch): if upperstate: append('-') upperstate = 0 append('-') if ch != '-': append('%d' % ord(ch)) append('-') elif ch.isupper() and self.tag_uppercase_name_chars: if not upperstate: append('-') upperstate = 1 append(ch) else: if upperstate: append('-') upperstate = 0 append(ch) if upperstate: append('-') return ''.join(ns)	17.46 KB	2026-01-20 12:58
📄 Latex.py class Doc2Latex: sizes = ('tiny', 'scriptsize', 'footnotesize', 'small', 'normalsize', 'large', 'Large', 'LARGE', 'huge', 'Huge') def __init__(self, mod, doc, node): self.mod = mod self.doc = doc self.encoder = Encoder(mod) self.encode = self.encoder.encode self.node = node self.out = [] self.ms = [] self.mode = None self.cur_style = 'rm' self.cur_size = list(self.sizes).index('normalsize') self.document_lang = None self.document_title = None self.document_metas = [] self.latex_list_nesting = 0 self.latex_mode = 0 self.noindent = 0 self.authors = [] node.accept(self) def _visit_children(self, node): E = self.mod.ReportedError for ch in node.children: try: ch.accept(self) except E: pass def abs_size(self, size, node): osize = self.cur_size si = size if si < 0: si = 0 elif si >= len(self.sizes): si = len(self.sizes) - 1 self.append('{\\%s ' % self.sizes[si]) self.cur_size = si if self.cur_style != 'rm': self.style(self.cur_style, node) else: node.arg_accept(self) self.append('}') self.cur_size = osize def append(self, x): self.out.append(x) def changed_size(self, delta, node): self.abs_size(self.cur_size + delta, node) def error(self, msg, args, kwds): msg = 'Doc2Latex: ' + msg self.doc.env.error(msg, args, *kwds) def get_latex(self): return ''.join(self.out) def no_children(self, node): if node.children: self.error('No children allowed for %r.' % node.tag, node.children[0]) def style(self, style, node): self.append('{\\%s ' % style) ostyle = self.cur_style self.cur_style = style node.arg_accept(self) self.cur_style = ostyle if style == 'em': self.append('\\/}') else: self.append('\\/}') def visit_a(self, node): pass def visit_author(self, node): self.authors.append(node.arg) self.no_children(node) def visit_big(self, node): self.changed_size(1, node) def visit_block(self, node): self._visit_children(node) def visit_blockquote(self, node): self.append('\\begin{quote}\n') self.latex_list_nesting += 1 node.arg_accept(self) self.latex_list_nesting -= 1 self.append('\\end{quote}\n') char_table = { 'nbsp': '~', } def visit_char(self, node): char = node.arg.strip() c = self.char_table.get(char) if c is None: self.error('No such character: %r.' % char, node) c = char self.append(c) def visit_code(self, node): self.style('tt', node) def visit_comment(self, node): pass def visit_dd(self, node): self.ms.append('dd') step = 24 ls = (self.ms.count('dd') + self.latex_list_nesting) step self.append('{\\par \\noindent \\leftskip = %d pt ' % ls) for i, v in enumerate(('i', 'ii', 'iii', 'iv', 'v', 'vi')[self.latex_list_nesting:]): self.append(' \\leftmargin%s = %d pt ' % (v, ls + (i + 1) * step)) node.arg_accept(self) self.append('\\par}\n') self.ms.pop() def visit_default(self, node): self.error('I don\'t know what to generate for the tag %r.' % node.tag, node) def visit_define(self, node): # xxx self._visit_children(node) def visit_dl(self, node): if self.ms and self.ms[-1] == 'dt': self.visit_dd(node) else: self.append('{\\par \\noindent\n') self._visit_children(node) self.append('\\par}\n') def visit_dt(self, node): self.ms.append('dt') self.append('{\\par \\pagebreak[%f] \\noindent \\hangindent = 12 pt \\hangafter = 1 \n' % ( 3.4-0.1len(self.ms), )) node.arg_accept(self) self.append('\\par}\n') self.ms.pop() def visit_document(self, node): self._visit_children(node) def visit_document_lang(self, node): if self.document_lang is not None: self.error('Duplicate document lang directive.', node) self.document_lang = node def visit_document_title(self, node): if self.document_title is not None: self.error('Duplicate document title directive.', node) self.document_title = node def visit_exdefs(self, node): self.symplace = {} for ch in node.children: syms = [x.strip() for x in ch.arg.split(',')] for sym in syms: self.symplace[sym] = ch.tag def visit_em(self, node): self.style('em', node) def visit_enumerate(self, node): self.append('\\begin{enumerate}\n') for c in node.children: self.append('\\item ') c.accept(self) self.append('\\end{enumerate}\n') def visit_h0(self, node): # Not a html header, # we may treat this as 'new page' or chapter here # and some larger divisor in html. self.visit_hx(node) def visit_h1(self, node): self.visit_hx(node) def visit_h2(self, node): self.visit_hx(node) def visit_h3(self, node): self.visit_hx(node) def visit_h4(self, node): self.visit_hx(node) def visit_h5(self, node): self.visit_hx(node) def visit_h6(self, node): self.visit_hx(node) def visit_hx(self, node): n = int(node.tag[1:]) if self.mode == 'man_page': self.append('{\\par \\pagebreak[%d] \\vskip %d pt \\noindent\n' % ( [4, 3, 3, 2, 2, 1, 1][n], (12 - 2 n))) self.abs_size(len(self.sizes) - n - 2, self.mod.node_of_taci( '', '', [self.mod.node_of_taci('strong', node.arg, node.children)])) self.append('\\par \\vskip %d pt\n} \\noindent\n' % (12 - 2 * n)) self.noindent = 1 # self.append('\\end{list}\n') else: self.append('\\%s{' % self.mod.section_table[n]) node.arg_accept(self) self.append('}\n') def visit_itemize(self, node): self.append('\\begin{itemize}\n') self.latex_list_nesting += 1 for c in node.children: self.append('\\item ') c.accept(self) self.latex_list_nesting -= 1 self.append('\\end{itemize}\n') def visit_latex(self, node): self.latex_mode += 1 node.arg_accept(self) self.latex_mode -= 1 def visit_li(self, node): self.append('\\item ') node.arg_accept(self) def visit_link_to(self, node): # xxx name = node.arg self.append(' {\\em ') if not node.children: self.append(self.encode(name)) else: self._visit_children(node) self.append('\\/}') def visit_link_to_extern(self, node): # xxx name = node.arg doc = node.children[0].arg children = node.children[1:] self.append(' {\\em ') if not children: self.append(self.encode(name)) else: for ch in children: ch.accept(self) self.append('\\/}') def visit_link_to_local(self, node): # xxx name = node.arg self.append(' {\\em ') if not node.children: self.append(self.encode(name)) else: self._visit_children(node) self.append('\\/}') def visit_link_to_unresolved(self, node): # xxx name = node.arg self.append(' {\\em ') if not node.children: self.append(self.encode(name)) else: self._visit_children(node) self.append('\\/}') def visit_literal_block(self, node): self.append('{\\ttfamily \\raggedright \\noindent') self.encoder.literal_block = 1 self.encoder.insert_none_breaking_blanks = 1 node.arg_accept(self) self.encoder.literal_block = 0 self.encoder.insert_none_breaking_blanks = 0 self.append('}\n') def visit_lp(self, node): self.latex_mode += 1 self.visit_paragraph(node) self.latex_mode -= 1 def visit_man_page_mode(self, node): omode = self.mode self.mode = 'man_page' self._visit_children(node) self.mode = omode def visit_meta(self, node): self.document_metas.append(node) def visit_ol(self, node): self.append('\\begin{enumerate}\n') self._visit_children(node) self.append('\\end{enumerate}\n') def visit_p(self, node): self.visit_paragraph(node) def visit_paragraph(self, node): self.append('{\\par ') if self.noindent: self.append('\\parindent = 0 pt ') self.noindent = 0 self.append('\n') node.arg_accept(self) self.append(' \\par}\n') def visit_pre(self, node): # I couldn't use Latex verbatim environment # since it didn't respected leftskip # so the environment became misplaced (within dd) text = node.arg.strip() if text: text += '\n' text = text + node.get_text() text = text.expandtabs() lines = text.split('\n') if lines and not lines[-1]: lines.pop() if not lines: return self.append('\\par\n') self.encoder.insert_none_breaking_blanks += 1 self.encoder.literal += 1 first = 1 self.append('{\\tt{%s}}\n' % self.encode(lines[0])) for line in lines[1:]: self.append( '{ \\par \\parindent = 0 pt \\parskip = 0 pt \\tt{%s} }\n' % self.encode(line)) self.encoder.insert_none_breaking_blanks -= 1 self.encoder.literal -= 1 self.append('\\par\n') def visit_small(self, node): self.changed_size(-1, node) def visit_spc_colonkind(self, node): self.append('~{\\bf :} ') def visit_spc_mapsto(self, node): self.append(' \\(\mapsto \\) ') def visit_string(self, node): self._visit_children(node) def visit_strong(self, node): self.style('bf', node) def visit_sub(self, node): self.append('\\raisebox{-.6ex}{') self.changed_size(-1, node) self.append('}') def visit_sup(self, node): self.append('\\raisebox{.6ex}{') self.changed_size(-1, node) self.append('}') def visit_symbol(self, node): self.visit_text(node) def visit_table(self, node): Table(self, node) def visit_text(self, node): if self.latex_mode: self.append(node.arg) else: text = node.arg text = self.encoder.encode(text) self.append(text) self._visit_children(node) def visit_to_document_only(self, node): self._visit_children(node) def visit_to_html_only(self, node): pass def visit_to_tester_only(self, node): pass def visit_tt(self, node): self.append('\\texttt{') self.encoder.literal = 1 node.arg_accept(self) self.encoder.literal = 0 self.append('}') def visit_ul(self, node): self.append('\\begin{itemize}\n') self._visit_children(node) self.append('\\end{itemize}\n') def visit_var(self, node): self.style('em', node) class Table(Doc2Latex): many_hlines = 1 # Use extra many hlines.. looks good, a matter of taste. def __init__(self, d2l, node): self.d2l = d2l self.__dict__.update(d2l.__dict__) self.node = node self.out = [] self.rows = [] self.colwidth = None self._visit_children(node) maxcols = 0 for row in self.rows: if len(row.columns) > maxcols: maxcols = len(row.columns) if not maxcols: return # Empty table if self.colwidth is not None: if not len(self.colwidth) == maxcols: self.error("Wrong number of column width specifications (%d) vs\n" " max columns in table (%d)." % ( len(self.colwidth), maxcols), node) else: self.colwidth = [1.0/maxcols]maxcols ap = self.d2l.append ap('\n\\begin{longtable}[c]{\|%s\|}\n' % ('\|'.join(['p{%.2g\\linewidth}' % cw for cw in self.colwidth]))) if self.many_hlines: ap('\\hline\n') for row in self.rows: for col in row.columns: ap(''.join(col.data)) if col is row.columns[-1]: if self.many_hlines: ap('\\\\\n') ap('\\hline\n') else: if row is not self.rows[-1]: ap('\\\\\n') else: ap('&\n') if row.is_head: ap('\\hline\n') ap('\\endhead\n') ap('\n\\end{longtable}\n') def visit_colgroup(self, node): colwidth = [] for c in node.children: if c.tag != "col_width": self.error('Unrecognized colgroup option: %r' % c.tag, c) cg = c.arg if cg.endswith('%'): cg = cg[:-1] cg = float(cg)/100.0 else: cg = float(cg) colwidth.append(cg) self.colwidth = colwidth def visit_options(self, node): pass def visit_thead(self, node): self._visit_children(node) self.rows[-1].is_head = 1 def visit_tr(self, node): self.rows.append(Row(self, node)) class Row(Doc2Latex): is_head = 0 def __init__(self, table, node): self.__dict__.update(table.__dict__) self.columns = [] self._visit_children(node) def visit_td(self, node): self.columns.append(Column(self, node)) def visit_th(self, node): self.columns.append(Column(self, node)) class Column(Doc2Latex): def __init__(self, row, node): self.__dict__.update(row.__dict__) self.data = [] self.append = self.data.append node.arg_accept(self) class Babel: """Language specifics for LaTeX.""" # country code by a.schlock. # partly manually converted from iso and babel stuff, dialects and some _ISO639_TO_BABEL = { 'no': 'norsk', # XXX added by hand ( forget about nynorsk?) 'gd': 'scottish', # XXX added by hand 'hu': 'magyar', # XXX added by hand 'pt': 'portuguese', # XXX added by hand 'sl': 'slovenian', 'af': 'afrikaans', 'bg': 'bulgarian', 'br': 'breton', 'ca': 'catalan', 'cs': 'czech', 'cy': 'welsh', 'da': 'danish', 'fr': 'french', # french, francais, canadien, acadian 'de': 'ngerman', # XXX rather than german # ngerman, naustrian, german, germanb, austrian 'el': 'greek', 'en': 'english', # english, USenglish, american, UKenglish, british, canadian 'eo': 'esperanto', 'es': 'spanish', 'et': 'estonian', 'eu': 'basque', 'fi': 'finnish', 'ga': 'irish', 'gl': 'galician', 'he': 'hebrew', 'hr': 'croatian', 'hu': 'hungarian', 'is': 'icelandic', 'it': 'italian', 'la': 'latin', 'nl': 'dutch', 'pl': 'polish', 'pt': 'portuguese', 'ro': 'romanian', 'ru': 'russian', 'sk': 'slovak', 'sr': 'serbian', 'sv': 'swedish', 'tr': 'turkish', 'uk': 'ukrainian' } def __init__(self, mod): self.language = mod.language_code self.re = mod.re # pdflatex does not produce double quotes for ngerman in tt. self.double_quote_replacment = None if self.re.search('^de', self.language): #self.quotes = ("\"`", "\"'") self.quotes = ('{\\glqq}', '{\\grqq}') self.double_quote_replacment = "{\\dq}" else: self.quotes = ("``", "''") self.quote_index = 0 def next_quote(self): q = self.quotes[self.quote_index] self.quote_index = (self.quote_index+1) % 2 return q def quote_quotes(self, text): t = None for part in text.split('"'): if t == None: t = part else: t += self.next_quote() + part return t def double_quotes_in_tt(self, text): if not self.double_quote_replacment: return text return text.replace('"', self.double_quote_replacment) def get_language(self): if self.language in self._ISO639_TO_BABEL: return self._ISO639_TO_BABEL[self.language] else: # support dialects. l = self.language.split("_")[0] if l in self._ISO639_TO_BABEL: return self._ISO639_TO_BABEL[l] return None class Encoder: literal_block = 0 literal = 0 mathmode = 0 verbatim = 0 insert_newline = 0 mbox_newline = 0 insert_none_breaking_blanks = 0 latex_equivalents = { '\u00A0': '~', '\u2013': '{--}', '\u2014': '{---}', '\u2018': '`', '\u2019': '\'', '\u201A': ',', '\u201C': '``', '\u201D': '\'\'', '\u201E': ',,', '\u2020': '{\\dag}', '\u2021': '{\\ddag}', '\u2026': '{\\dots}', '\u2122': '{\\texttrademark}', '\u21d4': '{$\\Leftrightarrow$}', } def __init__(self, mod): self.mod = mod self.re = mod.re self.babel = Babel(mod) self.font_encoding = mod.font_encoding self.latex_encoding = self.to_latex_encoding(mod.output_encoding) def to_latex_encoding(self, docutils_encoding): """ Translate docutils encoding name into latex's. Default fallback method is remove "-" and "_" chars from docutils_encoding. """ tr = {"iso-8859-1": "latin1", # west european "iso-8859-2": "latin2", # east european "iso-8859-3": "latin3", # esperanto, maltese "iso-8859-4": "latin4", # north european,scandinavian, baltic "iso-8859-5": "iso88595", # cyrillic (ISO) "iso-8859-9": "latin5", # turkish "iso-8859-15": "latin9", # latin9, update to latin1. "mac_cyrillic": "maccyr", # cyrillic (on Mac) "windows-1251": "cp1251", # cyrillic (on Windows) "koi8-r": "koi8-r", # cyrillic (Russian) "koi8-u": "koi8-u", # cyrillic (Ukrainian) "windows-1250": "cp1250", # "windows-1252": "cp1252", # "us-ascii": "ascii", # ASCII (US) # unmatched encodings # "": "applemac", # "": "ansinew", # windows 3.1 ansi # "": "ascii", # ASCII encoding for the range 32--127. # "": "cp437", # dos latine us # "": "cp850", # dos latin 1 # "": "cp852", # dos latin 2 # "": "decmulti", # "": "latin10", # "iso-8859-6": "" # arabic # "iso-8859-7": "" # greek # "iso-8859-8": "" # hebrew # "iso-8859-10": "" # latin6, more complete iso-8859-4 } if docutils_encoding.lower() in tr: return tr[docutils_encoding.lower()] return docutils_encoding.translate(str.maketrans("", "", "_-")).lower() def unicode_to_latex(self, text): # see LaTeX codec # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/252124 # Only some special chracters are translated, for documents with many # utf-8 chars one should use the LaTeX unicode package. for uchar in list(self.latex_equivalents.keys()): text = text.replace(uchar, self.latex_equivalents[uchar]) return text def encode(self, text): """ Encode special characters in `text` & return. # $ % & ~ _ ^ \ { } Escaping with a backslash does not help with backslashes, ~ and ^. < > are only available in math-mode or tt font. (really ?) $ starts math- mode. AND quotes: """ if self.verbatim: return text # compile the regexps once. do it here so one can see them. # # first the braces. if 'encode_re_braces' not in self.__dict__: self.encode_re_braces = self.re.compile(r'([{}])') text = self.encode_re_braces.sub(r'{\\\1}', text) if 'encode_re_bslash' not in self.__dict__: # find backslash: except in the form '{\{}' or '{\}}'. self.encode_re_bslash = self.re.compile(r'(?<!{)(\\)(?![{}]})') # then the backslash: except in the form from line above: # either '{\{}' or '{\}}'. text = self.encode_re_bslash.sub(r'{\\textbackslash}', text) # then dollar text = text.replace("$", '{\\$}') if not (self.literal_block or self.literal or self.mathmode): # the vertical bar: in mathmode \|,\vert or \mid # in textmode \textbar text = text.replace("\|", '{\\textbar}') text = text.replace("<", '{\\textless}') text = text.replace(">", '{\\textgreater}') # then text = text.replace("&", '{\\&}') # the ^: # verb\|^\| does not work in mbox. # * mathmode has wedge. hat{~} would also work. # text = text.replace("^", '{\\ensuremath{^\\wedge}}') text = text.replace("^", '{\\textasciicircum}') text = text.replace("%", '{\\%}') text = text.replace("#", '{\\#}') text = text.replace("~", '{\\textasciitilde}') # Separate compound characters, e.g. "--" to "-{}-". (The # actual separation is done later; see below.) separate_chars = '-' if self.literal_block or self.literal: # In monospace-font, we also separate ",,", "``" and "''" # and some other characters which can't occur in # non-literal text. separate_chars += ',`\'"<>' # pdflatex does not produce doublequotes for ngerman. text = self.babel.double_quotes_in_tt(text) if self.font_encoding == 'OT1': # We're using OT1 font-encoding and have to replace # underscore by underlined blank, because this has # correct width. text = text.replace('_', '{\\underline{ }}') # And the tt-backslash doesn't work in OT1, so we use # a mirrored slash. text = text.replace('\\textbackslash', '\\reflectbox{/}') else: text = text.replace('_', '{\\_}') else: text = self.babel.quote_quotes(text) text = text.replace("_", '{\\_}') for char in separate_chars * 2: # Do it twice ("* 2") becaues otherwise we would replace # "---" by "-{}--". text = text.replace(char + char, char + '{}' + char) if self.insert_newline or self.literal_block: # Insert a blank before the newline, to avoid # ! LaTeX Error: There's no line here to end. text = text.replace("\n", '~\\\\\n') elif self.mbox_newline: if self.literal_block: closings = "}" * len(self.literal_block_stack) openings = "".join(self.literal_block_stack) else: closings = "" openings = "" text = text.replace( "\n", "%s}\\\\\n\\mbox{%s" % (closings, openings)) # lines starting with "[" give errors. text = text.replace('[', '{[}') if self.insert_none_breaking_blanks: text = text.replace(' ', '~') if self.latex_encoding != 'utf8': text = self.unicode_to_latex(text) return text class _GLUECLAMP_: _imports_ = ( '_parent:SpecNodes', '_parent.SpecNodes:node_of_taci', '_parent.Main:ReportedError', '_root:re', ) font_encoding = '' double_quote_replacment = '' language_code = '' output_encoding = '' section_table = { 0: 'part', 1: 'chapter', 2: 'section', 3: 'subsection', 4: 'subsubsection', 5: 'paragraph', 6: 'subparagraph' } def doc2text(self, doc, node): d2l = Doc2Latex(self, doc, node) return d2l.get_latex() def doc2filer(self, doc, node, name, dir, opts, IO): text = self.doc2text(doc, node) path = IO.path.join(dir, '%s.tex' % name) node = self.node_of_taci('write_file', path, [ self.node_of_taci('text', text)]) return node	25.16 KB	2026-01-20 12:58
📄 Main.py from guppy.etc.Descriptor import property_nondata from guppy.gsl.Exceptions import * class SpecEnv: def __init__(self, mod): self.mod = mod self.imported_packages = {} self.importing_packages = {} self.error_reports = [] self.num_errors = 0 self.num_warnings = 0 def errmsg_context(self, context): linetext = '' filename = '<unknown file>' if context is not None: node = context # Assume it's a node - that's all we use for now lineno = node.index + 1 src = node.src if src is not None: filename = src.filename linetext = src.get_line(index=context.index) print('%s:%s:' % (filename, lineno)) if linetext: print(' %r' % linetext) def error(self, message, context=None, exception=ReportedError, more=(), harmless=0): self.error_reports.append( (message, context, exception, more, harmless)) if harmless: self.num_warnings += 1 else: self.num_errors += 1 self.errmsg_context(context) if harmless: print('* %s' % message) else: print('*** %s' % message) print() for msg, ctx in more: self.errmsg_context(ctx) print(' %s' % msg) print() if self.debug: import pdb pdb.set_trace() else: if self.num_errors >= self.max_errors: raise TooManyErrors('Too many errors, giving up') if exception is not None: raise exception def get_filers(self, documents): filers = [] for d in documents: filers.extend(d.get_filers(self.output_dir)) return filers def import_package(self, name, context): pac = self.imported_packages.get(name) if pac is None: if name in self.importing_packages: self.error('Invalid mutual import involving packages %r' % ( list(self.importing_packages.keys()),), context) self.importing_packages[name] = 1 filename = name.replace('.', self.mod.IO.path.sep)+'.gsl' ip = self.package_of_filename(filename, name) pac = self.mkPackage(ip) self.imported_packages[name] = pac del self.importing_packages[name] return pac def link_documents(self, documents): defines = {} links = {} def walk(node): t = node.tag if t == 'link_to': name = node.arg.strip() links.setdefault(name, []).append((d, node)) elif t == 'define': name = node.arg.strip() defines.setdefault(name, []).append((d, node)) elif t == 'to_tester_only': return for ch in node.children: walk(ch) for d in documents: node = d.get_result() walk(node) for name, ds in list(defines.items()): if len(ds) > 1: print('Duplicate definition of name %r, defined in:' % name) for (d, node) in ds: print(' %s line %s' % (d.get_doc_name(), node.index+1)) print('Will use the first one.') nodefs = [] for name, ds in list(links.items()): if name not in defines: used = {} for (d, node) in ds: used[d.get_doc_name()] = 1 node.tag = 'link_to_unresolved' used = list(used.keys()) used.sort() used = ', '.join(used) nodefs.append('%s used in %s' % (name, used)) else: defd, defnode = defines[name][0] for (d, node) in ds: if d is defd: node.tag = 'link_to_local' else: node.tag = 'link_to_extern' node.children = (defd.doc_name_node,)+node.children if nodefs: nodefs.sort() print('Unresolved links:') for nd in nodefs: print(' ', nd) def mkPackage(self, sub): pac = PackageDescription(self, sub, sub) pac.output_dir = self.output_dir pac.resolve_all() return pac def package_of_filename(self, filename, packname=None, nostrip=1, input_string=None): mod = self.mod if packname is None: if filename.endswith('.gsl'): packname = filename[:-4] else: packname = filename packname = packname.replace(mod.IO.path.sep, '.') if self.input_dir: filename = mod.IO.path.join(self.input_dir, filename) else: filename = mod.IO.path.abspath(filename) if input_string is not None: data = input_string else: data = mod.IO.read_file(filename) md5 = mod.md5() md5.update(b'.filename: %s\n' % filename.encode('utf-8')) md5.update(b'.packname: : %s\n' % packname.encode('utf-8')) md5.update(data.encode('utf-8')) digest = md5.digest() if digest in mod.package_cache: return mod.package_cache[digest] node = mod.SpecNodes.node_of_string(data, filename, nostrip=nostrip) numerr = self.num_errors print('Making package subject %r' % packname) package = PackageSubject(mod, self, node, packname, filename) if numerr == self.num_errors: mod.package_cache[digest] = package return package def process_main(self, filename, input_dir=None, output_dir=None, debug=False, max_errors=None, process_despite_errors=False, raise_at_errors=False, input_string=None ): if input_dir is None: input_dir = self.mod.input_dir self.input_dir = input_dir if output_dir is None: output_dir = '/tmp' self.output_dir = output_dir self.debug = debug if max_errors is None: max_errors = self.mod.max_errors self.max_errors = max_errors try: pac = self.mkPackage(self.package_of_filename( filename, input_string=input_string)) documents = pac.get_documents() if not documents: self.error('No documents specified.', exception=None, harmless=1) if not self.num_errors or process_despite_errors: print('Linking') self.link_documents(documents) if not self.num_errors or process_despite_errors: filers = self.get_filers(documents) except TooManyErrors: giving_up = ' giving up --' else: giving_up = '' if not self.num_errors: for filer in filers: f = self.mod.Filer.filer(filer) print('Writing: ', ', '.join(list(f.writefile_names))) f.write() if self.num_warnings: print('* %d warning%s reported.' % ( self.num_warnings, 's'[:self.num_warnings > 1])) if self.num_errors: print('* %d error%s reported --%s no files written.' % ( self.num_errors, 's'[:self.num_errors > 1], giving_up)) if raise_at_errors: raise HadReportedError('Some error has been reported.') class UntypedDescription: def __init__(self, env, tgt, src): self.env = env self.pac = env.pac self.mod = env.mod self.tgt = tgt self.src = src def combine_with_subject(self, subject): self.combined_subjects.append(subject) def resolve_all(self): self.resolve_primary() self.resolve_lookuped() def resolve_primary(self): self.resolve_type() self.resolve_tgt() def resolve_type(self): dc = self.tgt.description_class if not hasattr(dc, 'd_tag'): self.d_tag = self.tgt.tag self.tgtfullname = self.mod.tgt_prefix+self.tgt.fullname self.tgtnode = self.tgt.node self.tgtlastname = self.tgt.lastname self.srcnode = self.tgt.node self.srcfullname = self.src.fullname self.srclastname = self.tgt.lastname self.__class__ = dc class Description: d_max_occur = None # Max occurence as an aspect if a number d_sub = () # Tags of allowed sub-aspects d_type = 'other' d_is_def = 0 is_lookuped = False is_synthetic = False # Set if it was made not to correspond with a user node the_less_specific_descr = None args = () def aspects_extend(self, as_): for asp in as_: try: k = asp.src.definame # k = asp.tgt.definame # Humm if k: w = self.localview.get(k) if w: if w is asp: # May happen eg as in test16, for a product # But it is somewhat mystical. continue self.error('Duplicate aspect %r (may be correct in future).' % (k,), w.src.node, DuplicateError) self.localview[k] = asp bn = self.aspects_by_tag.setdefault(asp.d_tag, []) oc = asp.d_max_occur if oc is not None: if len(bn) + 1 > oc: self.error('More than %d %r aspects.' % ( oc, asp.d_tag), asp.src.node) bn.append(asp) self.aspects.append(asp) except ReportedError: pass def aspects_extend_by_subjects(self, subjects): for v in subjects: try: asp = UntypedDescription(self, v, v) asp.resolve_primary() self.aspects_extend((asp,)) except ReportedError: pass def deftgt(self, forme=None): if forme is None: forme = self try: tgtview = self.tgtview except AttributeError: self.env.deftgt(forme) else: if forme.tgtfullname in tgtview: self.error('Duplicate definition of %r' % forme.tgtfullname, forme.src.node) tgtview[forme.tgtfullname] = forme def error(self, msg, node=None, exception=ReportedError, kwds): return self.pac.env.error(msg, node, exception, *kwds) def resolve_lookuped(self): if not self.is_lookuped: self.is_lookuped = 1 self.resolve_aspects() def resolve_tgt(self): self.deftgt() def find_aspects(self, tag='', tags): al = [] tag = tag.replace(' ', '_') if tag in ('', 'arg'): for a in self.args: a.resolve_lookuped() al.append(a) if tag == '': for a in self.aspects: a.resolve_lookuped() al.append(a) return al tags = (tag,) + tags for a in self.aspects: if a.d_tag in tags: a.resolve_lookuped() al.append(a) return al def find_arg_aspects(self): al = [] for a in self.args: a.resolve_lookuped() al.append(a) for a in self.aspects: if a.d_tag in ('arg', 'seq', 'repeat', 'alt', 'args', 'optionals', 'key_arg', 'draw', 'no_arg'): a.resolve_lookuped() al.append(a) return al def find_kind_aspects(self): kas = [] for asp in self.find_aspects(''): if asp.d_tag in ('attribute', 'mapping', 'kind', 'either', 'kind_of', 'superkind', 'superkind_of'): kas.append(asp) else: pass return kas def merge_policy(self, descrs): return descrs def get_descr_for_aspect(self, aspect): if not self.aspects and self.the_less_specific_descr is not None: return self.the_less_specific_descr.get_descr_for_aspect(aspect) return self def get_atom_beams(self): aspects = self.find_aspects('') aks = [] for asp in aspects: if asp.d_tag in ('attribute', 'mapping', 'either', 'operator', 'inplace_operator', 'reverse_operator', 'function_operator', 'delitem', 'getitem', 'setitem', ): aks.append(beam(self, asp)) elif asp.d_tag in ('kind', 'kind_of', 'subkind_of') and asp is not self: a = beam(self, asp) for b in asp.get_atom_beams(): aks.append(a + b) return aks def get_aspects_kind(self, aspects=None): if aspects is None: aspects = self.find_aspects('') aks = [] for asp in aspects: if asp.d_tag in ('attribute', 'mapping', 'either', 'operator', 'inplace_operator', 'reverse_operator', 'function_operator', 'delitem', 'getitem', 'setitem', ): aks.append(asp) elif asp.d_tag in ('kind', 'kind_of', 'subkind_of') and asp is not self: aks.extend(asp.get_atom_kinds()) return aks def get_atom_kinds(self): return self.get_aspects_kind([self] + self.find_aspects('')) def get_examples(self, get_all=False): examples = [] exs = self.find_aspects('example') for ex in exs: examples.extend(ex.get_examples()) return examples def get_re(self, opt): if opt.get('get_examples'): exres = [self.mod.RE.Single(x) for x in self.get_examples()] if not exres: self.error('Test coverage error: no examples specified.', self.tgt.node, CoverageError) return self.mod.RE.Union(exres) else: return self.mod.RE.Single(self) def get_most_specific_descrs(self, descrs): nds = [] for d in descrs: nds = [x for x in nds if not d.is_more_specific_than(x)] for x in nds: if x is d: break if x.is_more_specific_than(d): break else: nds.append(d) return nds def get_package(self): return self.pac def is_more_specific_than(self, d): r = self.the_less_specific_descr return r is d or (r is not None and r.is_more_specific_than(d)) def get_self_name(self): def find(e): sa = e.find_aspects('self') if sa: # length = 1, has been checked assert len(sa) == 1 return sa[0].src.node.arg.strip() if e.d_tag != 'package': return find(e.env) return None return find(self) def gen_description_doc(self, out): ds = self.find_aspects('description') if not ds: out.gen_text('<NO DESCRIPTION OF %r>' % self.tgtfullname) else: for d in ds: d.gen_doc(out) def get_id_name(self): return self.tgtfullname def get_link_name(self): return self.tgtfullname def get_local_name(self): return self.srclastname def get_test_name(self): return self.tgtfullname def get_name(self): return self.tgtfullname def get_Name(self): # To be used in Name of doc. n = self.find_aspects('name') if not n: name = self.tgtlastname else: name = n.tgt.node.arg.strip() return name def get_descr_by_subject(self, subject): return self.pac.get_descr_by_subject(subject) def init_localview(self, only_vars=0): self.localview = {} self.aspects = [] self.aspects_by_tag = {} if not only_vars: self.aspects_extend_by_subjects(self.tgt.aspects) def resolve_aspects(self): self.init_localview() if self.src.args: self.args = [self.env.get_descr_by_subject( arg) for arg in self.src.args] self.resolve_special() def resolve_special(self): # To be overridden with special checks etc. pass def get_the_one_argument(self): arg = self.src.node.arg.strip() if self.aspects: 'No children expected for %r' % self.node.tag return arg def make_and_test_kind(self, kinds): ks = [] def flatten(k): if k.d_tag == 'kind': for k1 in k.find_kind_aspects(): flatten(k1) else: ks.append(k) if (len(kinds) == 1 and kinds[0].d_tag == 'kind'): return kinds[0] for k in kinds: flatten(k) kinds = ks k = Kind() k.d_tag = 'kind' k.aspects = kinds k.tgtfullname = '(%s)' % ('&'.join([x.tgtfullname for x in kinds])) k.is_lookuped = 1 return k def make_and_kind(self, kinds): if (len(kinds) == 1 and kinds[0].d_tag in('kind', 'kind_of')): return kinds[0] k = Kind() k.d_tag = 'kind' k.aspects = kinds k.tgtfullname = '(%s)' % ('&'.join([x.tgtfullname for x in kinds])) k.is_lookuped = True k.is_synthetic = True return k def make_or_kind(self, kinds): if len(kinds) == 1: return kinds[0] else: k = Superkind() k.d_tag = 'kind' k.aspects = kinds k.tgtfullname = '(%s)' % ('\|'.join([x.tgtfullname for x in kinds])) k.is_lookuped = True k.is_synthetic = True return k class Definition(Description): d_is_def = 1 d_type = 'definition' def export_aspects(self, src): src.__class__ = self.__class__ if src.d_tag == 'import': src.d_tag = self.d_tag else: if src.d_tag != self.d_tag: # Can't think of how this would happen - # so not yet converted to .error() raise ImportError('Different description tag') src.aspects_extend(self.aspects) class DescriptionDescription(Description): d_sub = ('text', ) d_tag = 'description' def gen_doc(self, out): self.srcnode.arg_accept(out) class Default(DescriptionDescription): def gen_doc(self, out): arglines = self.srcnode.arg.strip().split('\n') default = arglines[0] rest = '\n'.join(arglines[1:]) out.open('dl') out.open('dt') out.open('strong') out.gen_text('Default: ') out.close() out.gen_text(default) out.close() out.open('dd') out.gen_text(rest) self.srcnode.children_accept(out) out.close() out.close('dl') class DescriptionWithHeader(DescriptionDescription): def gen_doc(self, out): arglines = self.srcnode.arg.strip().split('\n') header = arglines[0] rest = '\n'.join(arglines[1:]) out.open('dl') out.gen_outer_dt(header) out.open('dd') out.gen_text(rest) self.srcnode.children_accept(out) out.close() out.close() class Comment(DescriptionDescription): d_tag = 'comment' pass class Either(Description): d_type = 'with_args' def get_atom_beams(self): return [beam(self)] def get_atom_kinds(self): return [self] def get_alt_kinds(self): return self.find_kind_aspects() class Import(Definition): d_sub = ('from', 'resolve_by', 'using', 'attribute', 'condition', 'description', 'comment', 'constructor', 'mapping', 'method', 'operator', 'inplace_operator', 'reverse_operator', 'function_operator', 'delitem', 'getitem', 'setitem', 'self', 'subkind_of', ) def resolve_tgt(self): self.is_lookuped = 1 using_name, using_node = self.src.imp_using_map.get( self.src.definame, (self.src.definame, self.src.node)) import_node = self.src.node ds = [self.pac.import_package(from_name, from_node). get_descr_by_name(using_name, using_node) for (from_name, from_node) in self.src.imp_froms] if len(ds) == 1: d = ds[0] else: d = Product(self, ds, ProductSubject([x.src for x in ds]), self.src.imp_resolve_mode) self.tgt = d.tgt self.tgtfullname = self.mod.tgt_prefix+self.tgt.fullname self.the_less_specific_descr = d self.init_localview(only_vars=1) d.export_aspects(self) self.aspects_extend_by_subjects(self.src.aspects) self.deftgt() def resolve_aspects(self): pass class Product(Description): def __init__(self, env, ds, src, mode): self.env = env self.mod = env.mod self.src = src self.mode = mode self.pac = env.pac tgt = ds[0].tgt for d in ds[1:]: if d.tgt is not tgt: self.error('Import error when importing from multiple packages:\n' + ' Can not make a product of %r (tgt = %r) with %r (tgt = %r)\n' % ( d.src.fullname, d.tgt.fullname, ds[0].src.fullname, ds[0].tgt.fullname) + ' because of different targets.', d.src.node) self.tgt = tgt self.ds = ds def export_aspects(self, src): for d in self.ds: d.export_aspects(src) def is_more_specific_than(self, d): for x in self.ds: if x is d or x.is_more_specific_than(d): return True return False class PackageDescription(UntypedDescription): def __init__(self, env, tgt, src): self.env = env self.pac = self self.mod = env.mod self.tgt = tgt self.src = src class ErrorDescription: d_tag = 'error' def __init__(self, env): self.env = env def get_id_name(self): return '<error>.<error>' class Package(Description): d_sub = ('and', 'comment', 'condition', 'document', 'import', 'kind', 'macro', 'superkind', ) def get_tgtdicts(self): seen = {id(self.tgtview): 1} tgtdicts = [self.tgtview] for p in list(self.imported_packages.values()): sds = p.get_tgtdicts() for sd in sds: if id(sd) not in seen: seen[id(sd)] = 1 tgtdicts.append(sd) return tgtdicts def get_descr_by_name(self, name, context=None): if name.startswith(self.mod.tgt_prefix): return self.get_descr_by_tgt_name(name, context) e = self parts = name.split('.') for part in parts: try: e = e.localview[part] except KeyError: assert context self.env.error( 'Undefined: %r in %r.' % (part, e.get_id_name()), context, exception=UndefinedError) e.resolve_lookuped() return e def get_descr_by_subject(self, subject): name = subject.fullname if name.startswith(self.srcfullname+'.'): name = name[len(self.srcfullname)+1:].strip() else: self.error('Undefined: %r' % name, subject.node) return self.get_descr_by_name(name, subject.node) def get_descr_by_tgt_name(self, name, context=None): tgtdicts = self.get_tgtdicts() descrs = [] for tgtdict in tgtdicts: if name in tgtdict: d = tgtdict[name] d.resolve_lookuped() d = d.get_descr_for_aspect('') descrs.append(d) if not descrs: self.error('No definition of tgt %r' % name, context, UndefinedError) descrs = self.get_most_specific_descrs(descrs) if len(descrs) > 1: descrs = self.merge_policy(descrs) if len(descrs) > 1: self.error('Conflicting descriptions of %r:%r' % ( name, [d.src.fullname for d in descrs]), context, DuplicateError) return descrs[0] def get_filename(self): return self.src.filename def get_package(self): return self def resolve_tgt(self): self.tgtview = {} def resolve_aspects(self): self.imported_packages = {} self.init_localview() def import_package(self, name, context): pac = self.imported_packages.get(name) if pac is None: pac = self.env.import_package(name, context) self.imported_packages[name] = pac return pac def get_documents(self): documents = [] for doc in self.src.documents: node = doc.node doc = self.mod.Document.document(node, self) documents.append(doc) return documents class Attribute(Definition): d_sub = ('attribute', 'comment', 'description', 'description_with_header', 'either', 'kind_of', 'mapping', 'method', 'self') def export_aspects(self, src): src.__class__ = self.__class__ src.aspects_extend(self.aspects) def get_attr_name(self): return self.tgtlastname def get_name(self): return self.tgtlastname def get_kind(self): kas = self.find_kind_aspects() return self.make_and_kind(kas) def get_kind_name(self): k = self.get_kind() if k.d_tag == 'kind_of': kas = k.find_kind_aspects() if len(kas) == 1: k = kas[0] else: raise ValueError("Don't know how to name this kind, %r" % self) return k.tgtfullname def get_link_name(self): # xxx needs smoother logic s = '%s.%s' % (self.get_descr_by_subject( self.tgt.parent).get_link_name(), self.tgt.lastname) return s def get_test_kind(self): kas = self.find_kind_aspects() return self.make_and_test_kind(kas) def is_method(self): return (self.find_aspects('mapping') and not self.find_aspects('kind_of')) def get_op_name(self): return self.get_attr_name() class KindOf(Description): d_type = 'with_args' d_sub = () class SubkindOf(Description): d_type = 'with_args' d_sub = ('description',) class Kind(Definition): d_sub = ('attribute', 'condition', 'description', 'comment', 'constructor', 'example', 'mapping', 'method', 'operator', 'inplace_operator', 'reverse_operator', 'function_operator', 'self', 'subkind_of', 'delitem', 'getitem', 'setitem', ) def get_attributes(self): return self.find_aspects('attribute') def get_mappings(self): return self.find_aspects('mapping') class Superkind(Definition): d_sub = ('comment', 'description', 'example', 'superkind_of') def get_local_name(self): return self.srclastname class SuperkindOf(Description): d_type = 'with_args' def get_examples(self, enough=1): examples = Description.get_examples(self, enough) if len(examples) < enough: for ka in self.find_kind_aspects(): if ka is self: continue examples.extend(ka.get_examples(enough-len(examples))) if len(examples) >= enough: break return examples class Example(Description): d_sub = ('comment', 'description', 'in_context') partab = {"'''": "'''", '"""': '"""', '(': ')', '[': ']', '{': '}' } def get_ex_text(self): return self.src.ex_text def get_examples(self, get_all=False): return [self] def get_ctx_text(self): asp = self.find_aspects('in_context') if not asp: return '' # It is of length 1, has been checked. return asp[0].tgt.node.arg.strip() def get_use_text(self, x): return x class InContext(Description): d_max_occur = 1 class Defines(Description): d_type = 'with_args' def get_defined_tgt_names(self): return [x.tgtfullname for x in self.find_aspects('arg')] class Macro(Definition): def export_aspects(self, src): src.__class__ = self.__class__ src.tgtnode = self.tgtnode def use(self, options): return self.mod.SpecNodes.node_of_taci( 'block', '', self.tgtnode.children, self.tgtnode.index) class Self(Description): d_max_occur = 1 class Mapping(Description): d_type = 'other' d_sub = ('alt', 'arg', 'args', 'comment', 'description', 'description_with_header', 'equation', 'draw', 'key_arg', 'optionals', 'precondition', 'postcondition', 'repeat', 'returns', 'self', 'seq', ) def chk_num_args(self, min, max): re = self.get_args_re({}) xs = re.sequni() for x in xs: try: if min is not None and min == max and len(x) != min: self.error( '%s requires %d argument%s specified, got %d.' % ( self.d_tag, min, 's'[min == 1:], len(x)), self.src.node) elif min is not None and len(x) < min: self.error( '%s requires at least %d argument%s specified, got %d.' % ( self.d_tag, min, 's'[min == 1:], len(x)), self.src.node) elif max is not None and len(x) > min: self.error( '%s can take at most %d argument%s specified, got %d.' % ( self.d_tag, max, 's'[max == 1:], len(x)), self.src.node) except ReportedError: pass def get_arg_kinds(self): ak = [] for a in self.find_aspects('args'): ak.extend(list(a.args)) return ak def get_args_examples(self, mapname, top_kind): # Get arguments example, esp. for test purposes try: opt = {'get_examples': True} re = self.get_args_re(opt) coverage = 1 try: xs = re.sequni() except self.mod.RE.InfiniteError: print('Infinitely long args example for %s' % self.srcfullname) print( 'Limiting by expanding each Cleene closure 0 up to %d times.' % coverage) re = re.limited(coverage) xs = re.sequni() examples = [ArgsExample(self, tuple( x), mapname, top_kind) for x in xs] except CoverageError: return [] else: return examples def get_args_for_args(self, args, match): arglist = [] for a in self.find_arg_aspects(): t = a.d_tag if t == 'arg': name = a.get_name() if name in match: v = args.get_arg_value(match[name]) else: ex = a.get_examples() if not ex: # I have been able to cause this to happen in test67. self.error( 'Test coverage error: Can not create precondition for %r\n -- no examples specified for the argument above.' % args.mapping.tgtfullname, a.src.node ) v = ex[0] arglist.append(v) else: assert 0 # raise ConditionError, 'Can not match this precondition' return ArgsExample(self, tuple(arglist), args.mapname, args.top_kind) def get_args_re(self, opt): re = self.mod.RE.Epsilon for a in self.find_arg_aspects(): re += a.get_re(opt) return re def get_arguments(self): # Get the arguments subjects, for doc description purposes return self.find_arg_aspects() def get_return_kind(self): return self.make_and_kind([x.get_kind() for x in self.find_aspects('returns')]) def get_return_test_kind(self): return self.make_and_test_kind([x.get_test_kind() for x in self.find_aspects('returns')]) class ArgsExample: def __init__(self, mapping, egs, mapname, top_kind): self.mapping = mapping self.egs = egs self.mapname = mapname self.top_kind = top_kind self.negs = [mapname(x) for x in egs] def __str__(self): return ', '.join(self.negs) def get_arg_value(self, name): i = 0 for a in self.mapping.find_arg_aspects(): t = a.d_tag if t == 'arg': if a.get_name() == name: return self.egs[i] else: raise ConditionError('No argument matches: %r' % name) i += 1 def get_preconditions(self): return self.mapping.find_aspects('precondition') def get_postconditions(self): return self.mapping.find_aspects('postcondition') def get_setups_for_preconditions(self): pres = self.get_preconditions() if not pres: return [] kind = self.top_kind map = self.mapping pres = map.find_aspects('precondition') if pres: for a in kind.find_aspects('attribute'): for m in a.find_aspects('mapping'): mpre = m.find_aspects('precondition') if mpre: continue match = self.match_to(m.find_aspects('postcondition')) if match is not None: # found one args = m.get_args_for_args(self, match) return [SetUp(a.get_attr_name(), args)] break else: continue break else: # Caller will do error reporting return None return [] def match_to_kind(self, kind): pass def match_to(self, posts): match = {} for pre in self.get_preconditions(): for pos in posts: if pos.cond_id == pre.cond_id: if len(pos.arg_names) != len(pre.arg_names): continue upd = {} for a, b in zip(pos.arg_names, pre.arg_names): if a in match: break upd[a] = b else: match.update(upd) break else: return None assert ',' not in match return match class SetUp: def __init__(self, name, args): self.name = name self.args = args def get_name(self): return self.name def get_args(self): return self.args class Operator(Mapping): d_is_def = 1 d_type = 'operator' d_sub = ('arg', 'comment', 'description', 'description_with_header', 'equation', 'postcondition', 'precondition', 'self', 'returns', ) def get_op_name(self): return self.src.node.arg.strip() def resolve_special(self): self.chk_num_args(1, 1) class ReverseOperator(Operator): pass class FunctionOperator(Operator): def resolve_special(self): self.chk_num_args(0, 0) class InplaceOperator(Operator): pass class SetItem(Mapping): d_type = 'other' d_sub = ('arg', 'comment', 'description', 'description_with_header', 'equation', 'postcondition', 'precondition', 'self') def get_op_name(self): return '[]' def resolve_special(self): self.chk_num_args(2, None) class DelItem(SetItem): def resolve_special(self): self.chk_num_args(1, None) class GetItem(SetItem): d_sub = SetItem.d_sub + ('returns', ) def resolve_special(self): self.chk_num_args(1, None) class Condition(Description): d_is_def = 1 d_sub = ('self', 'arg', 'comment', 'description', 'python_code') def get_arg_names(self): an = [] for a in self.find_aspects(''): if a.d_tag in ('self', 'arg'): an.append(a.src.node.arg.strip()) return an def get_def_name(self): dn = self.src.lastname return dn def_name = property(get_def_name) class PythonCode(Description): d_sub = ('comment', 'description', 'in_context') class ConditionRef(Description): d_sub = ('comment', 'description',) def __repr__(self): try: return self.cond_expr except AttributeError: return Description.__repr__(self) def get_cond_id(self): cond_id = self.cond_definition.tgtfullname if self.is_not: cond_id = 'not ' + cond_id self.cond_id = cond_id return cond_id cond_id = property_nondata(get_cond_id) def get_definition(self): return self.cond_definition def resolve_special(self): cond_def = self.src.cond_definition self.cond_definition = self.env.get_descr_by_subject(cond_def) self.cond_doc_name = cond_def.parent.lastname + '.' + cond_def.lastname self.cond_expr = self.src.node.arg.strip() # Mostly for information self.arg_names = self.src.arg_names self.is_not = self.src.is_not class Precondition(ConditionRef): #doc_name = 'Before' doc_name = 'Precondition' class Postcondition(ConditionRef): #doc_name = 'After' doc_name = 'Postcondition' class PostcondCase: # Postcondition with specific variables def __init__(postcond, variables): self.postcond = postcond self.variables = variables class Constructor(Description): d_type = 'with_args' d_sub = ('comment', 'description',) class Equation(Description): d_sub = ('comment', 'description', 'precondition', 'postcondition') class Args(Description): d_type = 'with_args' d_sub = ('comment', 'description', 'optionals', ) def get_re(self, opt): re = self.mod.RE.Epsilon for a in self.find_arg_aspects(): re += a.get_re(opt) return re class NoArg(Description): def get_re(self, opt): return self.mod.RE.Epsilon class Arg(Description): d_sub = ('comment', 'default', 'description', 'superkind_of', 'name', ) def get_kind(self): return self.make_or_kind(self.find_kind_aspects()) def get_name(self): try: return self.get_arg_name() except AttributeError: return '?' def get_arg_name(self): return self.src.specified_name def get_examples(self, get_all=False): examples = [] exs = self.find_aspects('example') for ex in exs: examples.extend(ex.get_examples()) if not exs or get_all: k = self.get_kind() examples.extend(k.get_examples()) return examples class KeyArgEG: def __init__(self, name, eg): self.name = name self.eg = eg def get_ex_text(self): return self.eg.get_ex_text() def get_ctx_text(self): return self.eg.get_ctx_text() def get_use_text(self, x): return '%s=%s' % (self.name, x) class KeyArg(Arg): # Spec with keyarg means it is: # NOT to be used as positional argument # ONLY as keyword argument def get_examples(self, get_all=False): name = self.get_arg_name() return [KeyArgEG(name, eg) for eg in Arg.get_examples(self, get_all)] class Draw(Description): d_sub = ('comment', 'description', 'key_arg', 'seq', ) def get_re(self, opt): re = self.mod.RE.Epsilon for a in self.find_arg_aspects(): re += a.get_re(opt)('?') return re class Optionals(Description): d_sub = ('arg', 'args', 'key_arg', 'comment', 'seq', ) d_type = 'with_args' def get_re(self, opt): def opt_ra(aspects): if not aspects: return self.mod.RE.Epsilon return (aspects[0].get_re(opt) + opt_ra(aspects[1:]))('?') return opt_ra(self.find_arg_aspects()) class Repeat(Description): d_sub = ('alt', 'arg', 'args', 'comment', 'description') def get_arg(self): return self.src.node.arg.strip() def get_re(self, opt): asp = self.find_arg_aspects() if not asp: self.error('No argument aspects.', self.src.node) re = asp[0].get_re(opt) for a in asp[1:]: re += a.get_re(opt) arg = self.get_arg() sep = '..' if sep in arg: args = arg.split(sep) if len(args) != 2: self.error('More than one %r in argument.' % sep, self.src.node) lo, hi = [x.strip() for x in args] try: lo = int(lo) except ValueError: self.error('Expected int in lower bound.', self.src.node) if hi != '': try: hi = int(hi) except ValueError: self.error('Expected int or in upper bound.', self.src.node) else: try: lo = int(arg) except ValueError: self.error( 'Expected int, int..int or int..* in argument.', self.src.node) hi = lo if lo < 0 or (hi != '' and hi < 0): self.error('Expected non-negative repetition count.', self.src.node) if hi == '': res = re('') for i in range(lo): res = re + res else: if hi < lo: self.error('Expected upper bound >= lower bound.', self.src.node) a = self.mod.RE.Epsilon for i in range(lo): a += re b = self.mod.RE.Epsilon for i in range(lo, hi): b = (re + b)('?') res = a + b return res class Seq(Description): d_sub = ('arg', 'comment', 'description', 'optionals',) d_sub += ('key_arg', ) # May perhaps be optionally disabled d_type = 'with_args' def get_re(self, opt): re = self.mod.RE.Epsilon for a in self.find_arg_aspects(): re += a.get_re(opt) return re class Alt(Description): d_sub = ('arg', 'comment', 'descripton', 'key_arg', 'no_arg', 'seq', ) d_type = 'with_args' def get_re(self, opt): asp = self.find_arg_aspects() if not asp: self.error('No alternatives.', self.src.node) re = asp[0].get_re(opt) for a in asp[1:]: re \|= a.get_re(opt) return re class Returns(Description): d_sub = ('attribute', 'comment', 'description', 'description_with_header', 'either', 'mapping', 'method') d_type = 'with_opt_args' def get_kind(self): return self.make_and_kind(self.find_kind_aspects()) def get_test_kind(self): return self.make_and_test_kind(self.find_kind_aspects()) # help functions def find_aspects_inseq(seq, tag): as_ = [] for o in seq: as_.extend(o.find_aspects(tag)) return as_ # Beam base class class Beam: def __init__(self, k_tag, objects): self.src = objects[0] self.tgt = objects[-1] self.k_tag = k_tag self.objects = objects def __add__(self, other): return compose(self, other) class KindBeam(Beam): pass class AtomKindBeam(Beam): pass class KindMappingBeam(Beam): pass class KindOpBeam(Beam): op_index = 1 op_name_index = 1 def find_equations(self): return find_aspects_inseq(self.get_op_seq(), 'equation') def find_postconditions(self): return find_aspects_inseq(self.get_op_seq(), 'postcondition') def find_preconditions(self): return find_aspects_inseq(self.get_op_seq(), 'precondition') def get_args_examples(self, mapname): top_kind = self.objects[0] return self.get_the_op().get_args_examples(mapname, top_kind) def get_op_id_name(self): return self.objects[self.op_name_index].get_id_name() def get_op_name(self): return self.objects[self.op_name_index].get_op_name() def get_op_seq(self): return self.objects[self.op_index:] def get_self_name(self): return self.get_the_op().get_self_name() def get_the_op(self): return self.objects[self.op_index] def get_return_test_kind(self): return self.get_the_op().get_return_test_kind() class KindAttributeBeam(KindOpBeam): def get_the_op(self): assert 0 class KindAttributeMappingBeam(KindOpBeam): op_index = 2 class KindMappingBeam(KindOpBeam): def get_op_name(self): return '()' class KOKOpBeam(KindOpBeam): op_index = 2 op_name_index = 2 def subkind_of_kind(objects): return beam(objects[2:]) def compose(a, b): if a.tgt is not b.src: raise "Composition error, tgt %r is not src %r" % (a.tgt, b.src) objects = a.objects + b.objects[1:] return beam(objects) def remove_1_2(k_tag, objects): return beam(objects[0], objects[3:]) def remove_0(k_tag, objects): return beam(objects[1:]) beam_table = { ('attribute', 'attribute'): Beam, ('attribute', 'either'): Beam, ('attribute', 'kind_of'): Beam, ('attribute', 'kind_of', 'kind', 'attribute'): Beam, ('attribute', 'kind_of', 'kind', 'function_operator'): Beam, ('attribute', 'kind_of', 'kind', 'inplace_operator'): Beam, ('attribute', 'kind_of', 'kind', 'mapping'): Beam, ('attribute', 'kind_of', 'kind', 'operator'): Beam, ('attribute', 'kind_of', 'kind', 'reverse_operator'): Beam, ('attribute', 'kind_of', 'kind', 'delitem'): Beam, ('attribute', 'kind_of', 'kind', 'getitem'): Beam, ('attribute', 'kind_of', 'kind', 'setitem'): Beam, ('attribute', 'mapping'): Beam, ('either', ): Beam, ('either', 'kind'): Beam, ('either', 'kind', 'attribute'): Beam, ('kind', 'attribute'): Beam, ('kind', 'attribute', 'kind_of', 'kind', 'mapping'): KindAttributeBeam, ('kind', 'attribute', 'mapping'): KindAttributeMappingBeam, ('kind', 'either'): Beam, ('kind', 'function_operator'): KindOpBeam, ('kind', 'delitem'): KindOpBeam, ('kind', 'getitem'): KindOpBeam, ('kind', 'inplace_operator'): KindOpBeam, ('kind', 'kind_of'): Beam, ('kind', 'kind_of', 'kind', 'attribute'): Beam, ('kind', 'mapping'): KindMappingBeam, ('kind', 'operator'): KindOpBeam, ('kind', 'reverse_operator'): KindOpBeam, ('kind', 'setitem'): KindOpBeam, ('kind', 'subkind_of'): Beam, ('kind', 'subkind_of', 'kind', 'attribute'): remove_1_2, ('kind', 'subkind_of', 'kind', 'function_operator'): remove_1_2, ('kind', 'subkind_of', 'kind', 'delitem'): remove_1_2, ('kind', 'subkind_of', 'kind', 'getitem'): remove_1_2, ('kind', 'subkind_of', 'kind', 'inplace_operator'): remove_1_2, ('kind', 'subkind_of', 'kind', 'mapping'): remove_1_2, ('kind', 'subkind_of', 'kind', 'operator'): remove_1_2, ('kind', 'subkind_of', 'kind', 'reverse_operator'): remove_1_2, ('kind', 'subkind_of', 'kind', 'setitem'): remove_1_2, ('kind_of', 'kind'): Beam, ('kind_of', 'kind', 'attribute'): Beam, ('kind_of', 'kind', 'function_operator'): KOKOpBeam, ('kind_of', 'kind', 'delitem'): KOKOpBeam, ('kind_of', 'kind', 'getitem'): KOKOpBeam, ('kind_of', 'kind', 'inplace_operator'): KOKOpBeam, ('kind_of', 'kind', 'operator'): KOKOpBeam, ('kind_of', 'kind', 'reverse_operator'): KOKOpBeam, ('kind_of', 'kind', 'setitem'): KOKOpBeam, ('kind_of', 'kind', 'mapping'): Beam, ('subkind_of', 'kind'): Beam, ('subkind_of', 'kind', 'attribute'): Beam, ('subkind_of', 'kind', 'function_operator'): Beam, ('subkind_of', 'kind', 'delitem'): Beam, ('subkind_of', 'kind', 'getitem'): Beam, ('subkind_of', 'kind', 'inplace_operator'): Beam, ('subkind_of', 'kind', 'mapping'): Beam, ('subkind_of', 'kind', 'operator'): Beam, ('subkind_of', 'kind', 'reverse_operator'): Beam, ('subkind_of', 'kind', 'setitem'): Beam, } def beam(objects): k_tag = tuple([x.d_tag for x in objects]) C = beam_table[k_tag] return C(k_tag, objects) class ProductSubject: def __init__(self, subjects): self.subjects = subjects self.fullname = '(%s)' % ''.join([x.fullname for x in subjects]) class Subject: args = () specified_name = None def __init__(self, parent, node, lastname): self.parent = parent self.pac = parent.pac self.mod = self.pac.mod self.node = node self.filename = self.pac.filename self.lastname = lastname self.aspects = [] self.subjects = {} self.node_index = 0 self.tag = node.tag self.description_class = self.mod.get_description_class(node.tag) self.aspect_mode = None if self.parent is not self: self.fullname = self.parent.make_child_name(self.lastname) else: self.fullname = self.lastname def _visit_type_definition(self, node): names = self.get_arglist(node, min=1) for name in names: self.add_new_subject(node, name) def _visit_type_operator(self, node): shtag = self.mod.SpecNodes.reverse_node_aliases[node.tag] names = self.get_arglist(node, min=1) for name in names: name = '%s:%s' % (shtag, name) self.add_new_subject(node, name) def _visit_type_other(self, node): self.add_new_subject(node) def _visit_type_with_args(self, node): names = self.get_arglist(node) args = [self.find_subject(name, node) for name in names] subject = self.add_new_subject(node) if args: subject.args = args def _visit_type_with_opt_args(self, node): names = self.get_arglist(node, min=0) args = [self.find_subject(name, node) for name in names] subject = self.add_new_subject(node) if args: subject.args = args def add_new_subject(self, node, lastname=None): subject = self.new_subject(node, lastname) self.add_subject(subject) return subject def add_subject(self, subject): self.def_subject(subject) subject.add_top_node() return subject def add_top_node(self): node = self.node self._visit_children(node) def def_new_subject(self, node, lastname=None): subject = self.new_subject(node, lastname) self.def_subject(subject) return subject def def_subject(self, subject): if subject.description_class.d_is_def: name = subject.lastname if name in self.subjects: self.error('Redefinition of %r.' % name, subject.node, more=[( 'Previous definition of %r.' % name, self.subjects[name].node)] ) return # For clarity; there's most certainly an exception subject.definame = name self.subjects[name] = subject else: subject.definame = None self.aspects.append(subject) def error(self, msg, node=None, exception=ReportedError, kwds): return self.pac.error(msg, node, exception, kwds) def find_subject(self, name, node): return self.pac.find_subject(name, node, self) def get_arglist(self, node, min=0): arglist = node.get_arglist() for arg in node.get_arglist(): if not arg: if node.arg.strip().startswith(',') or node.arg.strip().endswith(','): m = 'Arg list to definition can not start or end with a comma.' else: m = 'Missing argument to definition.' self.error(m, node, exception=None) arglist = [x for x in arglist if x] break if len(arglist) < min: self.error( 'Not enough arguments, minimum %d expected to node %s' % ( min, node), node) return arglist def get_arglist_only(self, node, min=0): al = self.get_arglist(node, min) self.no_children(node) return al def get_line(self, index): try: with open(self.filename) as f: text = list(f.readlines())[index].rstrip() except Exception: text = None return text def _visit_aspect(self, node, mode): if self.aspect_mode is None: self.aspect_mode = mode else: if self.aspect_mode != mode: self.error('Inconsistent aspect mode: %r, was: %r' % (mode, self.aspect_mode), node) self._visit_children(node) def _visit_children(self, node): for ch in node.children: try: if ch.tag not in self.description_class.d_sub: self.error('Invalid tag: %r in: %r. Allowed = %s' % ( ch.tag, self.tag, self.description_class.d_sub), node) if self.mod.cover_check is not None: self.mod.cover_check.setdefault(self.tag, {})[ch.tag] = 1 ch.accept(self) except ReportedError: pass self.node_index += 1 def make_child_name(self, child_lastname): return '%s.%s' % (self.fullname, child_lastname) def new_subject(self, node, name=None): is_def = self.mod.get_description_class(node.tag).d_is_def assert is_def == (name is not None) if name is None: name = '<%d>' % self.node_index tag = node.tag if tag == 'macro': return MacroSubject(self, node, name) elif tag == 'document': return DocumentSubject(self, node, name) else: return Subject(self, node, name) def new_tag_node(self, tag, node): return self.mod.SpecNodes.node_of_taci(tag, '', node.children, node.index) def no_children(self, node): if node.children: self.error('No children expected for node with tag %r' % node.tag, node, exception=None) def visit_and(self, node): for name in self.get_arglist(node, min=1): ofsubject = self.find_subject(name, node) ofsubject._visit_aspect(node, 'and') def visit_aspects_of(self, node): for name in self.get_arglist(node, min=1): ofsubject = self.find_subject(name, node) ofsubject._visit_aspect(node, 'aspect') def visit_arg(self, node, must_have_name=False): arg = node.arg.strip() arg_name = None kind = None if arg: if ':' in arg: nk = arg.split(':') if len(nk) > 2: self.error('More than 1 colon in argument.', node) name, kind_name = [x.strip() for x in nk] if kind_name: kind = self.find_subject(kind_name, node) if name: arg_name = name else: # Is there an obvious default ? # For KeyArg, yes, the name is always. # let's say it's the name arg_name = arg subject = self.new_subject(node) if arg_name: subject.specified_name = arg_name self.add_subject(subject) if must_have_name and subject.specified_name is None: self.error('No argument name specified.', node) if kind is not None: subject.args = [kind] def visit_comment(self, node): pass def visit_condition(self, node): names = self.get_arglist(node, min=1) for name in names: self.add_new_subject(node, 'cond:%s' % name) def visit_default(self, node): description_class = self.mod.get_description_class(node.tag) arg = node.arg.strip() colon = arg.startswith(':') if (description_class.d_type == 'definition') != colon: if colon: msg = 'Tag %r is not a definition, should not have ::' % node.tag else: msg = 'Tag %r is a definition, requires ::' % node.tag self.error(msg, node, exception=None) getattr(self, '_visit_type_%s' % description_class.d_type)(node) def visit_description(self, node): self.def_new_subject(node) def visit_description_with_header(self, node): self.visit_description(node) def visit_example(self, node): subject = self.add_new_subject(node) partab = subject.description_class.partab ex = node.arg.strip() if '\n' in ex: if not (partab.get(ex[:1]) == ex[-1:] or partab.get(ex[:3]) == ex[-3:]): self.error('Multi-line expression should be in parentheses (for clarity).', node, exception=None, harmless=1) ex = '(%s)' % ex subject.ex_text = ex def visit_import(self, node): my_names = self.get_arglist(node, min=1) resolve_mode = None usings = None froms = [] for ch in node.children: t = ch.tag if t == 'from': for name in self.get_arglist_only(ch): froms.append((name, ch)) elif t == 'resolve_by': if resolve_mode: self.error("More than 1 'resolve' clause.", ch.node, exception=None) else: resolve_mode = ch.arg.strip() if not resolve_mode in ('and', 'or'): self.error("Resolve by: and / or expected.", ch, exception=None) resolve_mode = 'and' elif t == 'using': if usings is None: usings = [] for name in self.get_arglist_only(ch): usings.append((name, ch)) else: self.error('Unexpected clause in import', ch, exception=None) using_map = {} if usings is not None: if len(usings) != len(my_names): if len(using_names) < len(my_names): manyfew = 'few' else: manyfew = 'many' self.error( "Too %s 'using' names, should match number of names in .import" % manyfew, using_node, exception=None) for m, u in zip(my_names, usings): # zip stops at the shortest list, ok using_map[m] = u if len(froms) == 0: self.error("No 'from' clause", node) if len(froms) > 1: if not resolve_mode: self.error("Importing from multiple packages but no 'resolve by' clause", node, exception=None) resolve_mode = 'and' for name in my_names: subject = self.def_new_subject(node, name) subject.imp_resolve_mode = resolve_mode subject.imp_using_map = using_map subject.imp_froms = froms def visit_key_arg(self, node): self.visit_arg(node, must_have_name=True) def visit_method(self, node): arg = node.arg.strip() if not arg.startswith(':'): self.error("Tag 'method' is a definition, requires ::", node) self.mod.node_of_taci('attribute', arg, (self.mod.node_of_taci('mapping', '', node.children),)).accept(self) def visit_name(self, node): if self.specified_name is not None: self.error('Duplicate name specification.', node) name = node.arg.strip() if not name: self.error('No name specification.', node) self.specified_name = name def visit_or(self, node): for name in self.get_arglist(node, min=1): ofsubject = self.find_subject(name, node) ofsubject._visit_aspect(node, 'or') def visit_postcondition(self, node): arg = node.arg.strip() if not '(' in arg: self.error('No left parenthesis', node) lpar = arg.index('(') rpar = arg.find(')') if rpar < lpar: self.error('None or misplaced right parenthesis', node) n = arg[lpar+1:rpar].strip() if ',' in n: n = [x.strip() for x in n.split(',')] else: n = [n] arg_names = n cond_name = arg[:lpar].strip() if not cond_name: self.error('No condition name', node) is_not = 0 if cond_name.startswith('not '): cond_name = cond_name[4:].strip() is_not = 1 parts = cond_name.split('.') if not parts[-1].startswith('cond:'): parts[-1] = 'cond:'+parts[-1] cond_name = '.'.join(parts) cond_def = self.find_subject(cond_name, node) subject = self.add_new_subject(node) subject.cond_definition = cond_def subject.cond_name = cond_name subject.arg_names = arg_names subject.is_not = is_not def visit_precondition(self, node): self.visit_postcondition(node) class ErrorSubject(Subject): pass class PackageSubject(Subject): def __init__(self, mod, specenv, node, name, filename): self.mod = mod self.specenv = specenv self.pac = self self.filename = filename #name = 'package_%s'%(name,) name = '%s' % (name,) Subject.__init__(self, self, node, name) self.lastname = name.split('.')[-1] self.tag = 'package' self.description_class = Package self.documents = [] for s in mod.predefined_subjects: s = s(self) self.subjects[s.fullname] = s self._visit_children(node) del self.specenv # It was used only for error report def error(self, msg, node=None, exception=ReportedError, kwds): return self.specenv.error(msg, node, exception, kwds) def find_subject(self, name, node, context=None): if not name: self.error('Invalid subject name: %r' % name, node) parts = [x.strip() for x in name.split('.')] if not parts[0]: tag = parts[1] parts = parts[2:] else: tag = 'myfile' if tag == 'myfile': s = self elif tag == 'mykind': s = context if s is not None: kind_tags = ('kind', 'and', 'import') while s.parent != self and s.tag not in kind_tags: s = s.parent if s.tag not in kind_tags: s = None if s is None: self.error('mykind tag without such a context: %r' % name, node) else: self.error('Invalid tag %r in %r' % (tag, name), node) sname = s.lastname for i, n in enumerate(parts): ns = s.subjects.get(n) if ns is None: if s.tag != 'import': self.error('No such subject: %r in %r.' % (n, sname), node) return SubImportSubject(s, node, parts[i:]) sname = sname + '.' + n s = ns return s class SubImportSubject: def __init__(self, parent, node, rnparts): self.parent = parent self.node = node self.rnparts = rnparts self.fullname = '.'.join([parent.fullname]+rnparts) self.lastname = rnparts[-1] class MacroSubject(Subject): def add_top_node(self): pass class DocumentSubject(Subject): def add_top_node(self): self.parent.documents.append(self) class GuppyWorld(Subject): def __init__(self, env): self.pac = env self.fullname = self.lastname = "Guppy_World" self.node = None self.tag = '<GuppyWorld>' self.aspects = [] self.description_class = Description class _GLUECLAMP_: _imports_ = ( '_parent:Document', '_parent:FileIO', '_parent.FileIO:IO', '_parent:Filer', '_parent:Html', '_parent:Latex', '_parent:SpecNodes', '_parent.SpecNodes:node_of_taci', '_parent:Tester', '_root.hashlib:md5', '_root.guppy.etc:iterpermute', '_root.guppy.etc:RE', ) _chgable_ = ('cover_check', 'io_dir', 'max_errors') description_classes = { 'alt': Alt, 'arg': Arg, 'args': Args, 'attribute': Attribute, 'comment': Comment, 'condition': Condition, 'constructor': Constructor, 'default': Default, 'defines': Defines, 'delitem': DelItem, 'description': DescriptionDescription, 'description_with_header': DescriptionWithHeader, 'equation': Equation, 'example': Example, 'either': Either, 'draw': Draw, 'function_operator': FunctionOperator, 'getitem': GetItem, 'import': Import, 'in_context': InContext, 'inplace_operator': InplaceOperator, 'key_arg': KeyArg, 'kind': Kind, 'kind_of': KindOf, 'macro': Macro, 'mapping': Mapping, 'no_arg': NoArg, 'operator': Operator, 'postcondition': Postcondition, 'precondition': Precondition, 'python_code': PythonCode, 'reverse_operator': ReverseOperator, 'optionals': Optionals, 'package': Package, 'repeat': Repeat, 'returns': Returns, 'self': Self, 'seq': Seq, 'setitem': SetItem, 'subkind_of': SubkindOf, 'superkind': Superkind, 'superkind_of': SuperkindOf, } tgt_prefix = '.tgt.' cover_check = None io_dir = None max_errors = 10 def get_description_class(self, tag): return self.description_classes.get(tag, Description) def _get_predefined_subjects(self): return (GuppyWorld,) def _get_package_cache(self): return {} def main(self, filename, kwds): se = SpecEnv(self) se.process_main(filename, kwds) def _test_main_(self): pass def set_input_dir(self, dir): dir = self.IO.path.abspath(dir) self.input_dir = dir	66.91 KB	2026-01-20 12:58
📄 SpecNodes.py ## # Specification entity object # # Collects information about a particular system entity or aspect. # # The entity is of a general kind # It is defined by the particular aspects defined for it # The aspects must be 'compatible', which can be relatively checked. # The specobject is used for: # * generating tests # * generating docs # * generating help # * by creating docstrings # * by providing interactive help # # For test generation, it will delegate to test implementators. # For doc generation, it will delegate to doc implementators. # # The functionality needed here is therefore limited. # # name # aspects # # There is one predefine root # - should we call it Universe? # # The name can be full, a dotted name, or the short, last part. # # The name is treated as an aspect. # # Each aspect definition has a primary kind # Aspect kinds from guppy.gsl.Exceptions import * class SpecObject: def __init__(self, mod): self.mod = mod ## # Specification environment # Collects specifications from several files # Maps names to specification objects class SpecEnv: def __init__(self, mod): self.mod = mod self.unknown_nodes = [] self.files = [] def visit_default(self, node): print('add_unknown', node.tag) self.unknown_nodes.append(node) def visit_file(self, node): print('visit_file') file = FileEnv(self, node) self.files.append(file) def get_predefined_subjects(self, env): return (GuppyWorld(env),) class FileEnv: def __init__(self, env, node): mod = env.mod self.mod = mod self.name = self.filename = node.arg self.subjects = {} for s in env.get_predefined_subjects(self): self.subjects[s.name] = s file = Subject(self, node, self.name) node.children_accept(file) def visit_aspects_of(self, node): name = node.arg subject = self.find_subject(node, name) subject.add_aspects(node) def def_subject(self, node, name, subject): if name in self.subjects: self.error_node(node, 'Redefinition of %r.' % name) self.error_node(self.subjects[name].node, 'Previous definition of %r.' % name) else: self.subjects[name] = subject def error_node(self, node, msg, exception=None): index = node.index lineno = index + 1 print('%s:%s:' % (self.filename, lineno)) print(' %r' % self.get_line(index)) print(' %s' % msg) print() def find_subject(self, node, name): subject = self.subjects.get(name) if subject is None: self.error_node(node, 'No such subject: %r.' % name) return subject def get_line(self, index): try: with open(self.filename) as f: text = list(f.readlines())[index].rstrip() except Exception: text = None return text def get_subject(self, name): subject = self.subjects.get(name) if subject is None: subject = self.subjects[name] = Subject(self, name) return subject def get_aspect_subject(self, env, node): name = env.name+'::'+node.tag return self.get_subject(name) class Subject: def __init__(self, file, node, name): self.file = file self.node = node self.name = name self.aspects = [] def visit_default(self, node): of = node.tag.endswith('_of') name = node.arg define = name.startswith(':') if define: if of: self.file.error_node(node, "Both 'of' and '::'.") name = name[1:].strip() if of: ofsubject = self.file.find_subject(node, name) subject = self.new_subject_of(node, ofsubject) else: subject = Subject(self.file, node, name) if define: self.file.def_subject(node, name, subject) self.aspects.append(subject) node.children_accept(subject) def new_subject_of(self, node, of): tag = node.tag if tag == 'aspects_of': return AspectsOf(self.file, node, of) else: return SubjectOf(self.file, node, of) class AspectsOf(Subject): def __init__(self, file, node, of): self.node = node self.of = of self.aspects = [] def visit_default(self, node): self.of.visit_default(node) class SubjectOf(Subject): def __init__(self, file, node, of): self.node = node self.of = of self.aspects = [] class GuppyWorld(Subject): def __init__(self, env): self.file = env self.name = "Guppy World" self.node = None self.aspects = [] ## # A node represented with argument splitted in components of the form: # .tag: arg # text # ..child # ... # ..child # ... # # @param tag the text of the first line before the colon # @param arg the text of the first line after the colon (stripped) # @param text the text after the the first line before the first children # @param children the child nodes # @param index line index # @param src describes the source class SpecNode(object): __slots__ = 'tag', 'arg', 'children', 'index', 'src' def __init__(self, tag, arg, children=(), index=0, src=None): self.tag = tag self.arg = arg self.children = tuple(children) self.index = index self.src = src def __repr__(self): return '%s(%r,%r,%r)' % ( self.__class__.__name__, self.tag, self.arg, self.children) def __str__(self): return '%s(%r,%r,%s)' % ( self.__class__.__name__, self.tag, self.arg, '(%s)' % (','.join([str(c) for c in self.children]))) def arg_accept(self, visitor, prefix='visit_'): if self.arg: node = SpecNode('text', self.arg, (), self.index) node.accept(visitor, prefix) self.children_accept(visitor, prefix) def copy(self, tag=None, arg=None, children=None, index=None, src=None): if tag is None: tag = self.tag if arg is None: arg = self.arg if children is None: children = self.children if index is None: index = self.index if src is None: src = self.src return self.__class__(tag, arg, children, index, src) def children_accept(self, visitor, prefix='visit_'): for c in self.children: c.accept(visitor, prefix) def accept(self, visitor, prefix='visit_'): m = getattr(visitor, (prefix+self.tag), None) if m is None: m = getattr(visitor, (prefix+'default'), None) if m is None: msg = 'accept: unknown: %r, %r in %r' % ( prefix, self.tag, visitor) print(msg) raise ValueError(msg) return m(self) def error(self, msg, node=None): if node is None: node = self node.src.error(msg, node) def get_text(self): " Get the total text of all text children, joined with and ended with '\n' " text = [] for c in self.children: if c.tag == 'text': text.append(c.arg) if not c.arg.endswith('\n'): text.append('\n') return ''.join(text) def get_arg(self): arg = self.arg.strip() if arg.startswith(':'): arg = arg[1:].strip() return arg def get_arglist(self): arg = self.arg if arg.startswith(':'): arg = arg[1:] names = [x.strip() for x in arg.split(',')] if names == ['']: names = [] return names def get_arg_children(self): if self.arg: children = [SpecNode('text', self.arg, (), self.index, self.src)] children.extend(self.children) else: children = self.children return children def get_arg_rest(self, nostrip=0): arg = self.arg if not nostrip: arg = arg.strip() return arg, self.children def get_arg_norest(self): ''' Get the arg as by self.arg, but make sure there are no more children. ''' if self.children: raise SyntaxError('No children nodes expected in node: %s' % self) return self.arg.strip() def get_namearg(self): ''' Get the argument in the form of a name It is the argument stripped. And not allowed to contain : or , or new line. ''' name = self.arg.strip() if '\n' in name or ':' in name or ',' in name: raise SyntaxError('Invalid name: %r' % name) return name def split_attrs(self, tag=None, attrdict=False): if tag is None: tag = self.tag if attrdict: attrs = {} def addattr(tag, attr, node): if tag in attrs: node.error('Duplicate attribute: %s' % attr) else: attrs[tag] = attr else: attrs = [] def addattr(tag, attr, node): attrs.append((tag, attr)) children = [] for ch in self.children: if ch.tag == "with": for opt in ch.children: if opt.arg: arg = opt.arg else: self.error('Bad attribute, no argument.', opt) if opt.children: self.error( 'Expected no children to attribute.', opt.children[0]) if opt.arg: addattr(opt.tag, arg, opt) elif ch.tag[-1:] == '=': addattr(ch.tag[:-1], ch.arg, ch) else: children.append(ch) if len(children) == len(self.children): node = self else: node = self.__class__( tag, self.arg, children, self.index, self.src) return node, attrs class Source: def __init__(self, name, lines=None, string=None, nostrip=0, debug=0, max_errors=10): self.filename = name self.lines = lines self.string = string self.nostrip = nostrip self.debug = debug self.error_reports = [] self.max_errors = max_errors self.num_warnings = 0 self.num_errors = 0 def errmsg_context(self, context): linetext = '' filename = '<unknown file>' if context is not None: if hasattr(context, 'index'): index = context.index src = context.src else: index = context src = self if src is not None: filename = src.filename linetext = src.get_line(index=index) print('%s:%s:' % (filename, index+1)) if linetext: print(' %s' % linetext) def error(self, message, context=None, exception=None, more=(), harmless=0): self.error_reports.append( (message, context, exception, more, harmless)) if harmless: self.num_warnings += 1 else: self.num_errors += 1 self.errmsg_context(context) if harmless: print('* %s' % message) else: print('*** %s' % message) print() for msg, ctx in more: self.errmsg_context(ctx) print(' %s' % msg) print() if self.debug: import pdb pdb.set_trace() else: if self.num_errors >= self.max_errors: raise TooManyErrors('Too many errors, giving up') if exception is not None: raise exception def get_line(self, index): if self.lines is None: if self.string is None: if self.filename: try: with open(self.filename) as f: self.string = f.read() except Exception: return '' else: return '' self.lines = self.string.split('\n') return self.lines[index] class _GLUECLAMP_: _chgable_ = 'nodemap', 'SpecNode' _imports_ = ( '_parent:DottedTree', '_root:re', '_root:os', ) node_aliases_defs = ( ('attr', 'attribute'), ('c', 'comment'), ('cond', 'condition'), ('d', 'description'), ('dwh', 'description_with_header'), ('eg', 'example'), ('fop', 'function_operator'), ('iop', 'inplace_operator'), ('ka', 'key_arg'), ('op', 'operator'), ('rop', 'reverse_operator'), ('t', 'text'), ) def _get_node_aliases(self): return dict(self.node_aliases_defs) def _get_reverse_node_aliases(self): # Used to make names shorter return dict([(v, k) for k, v in self.node_aliases_defs]) def _get_is_not_ascii(self): return self.re.compile(eval(r'u"[\u0080-\uffff]"')).search ## # @return A tuple of predefined subjects. def get_predefined_subjects(self): return (GuppyWorld(self),) ## # Parses a file and makes a tree of nodes # @param file name of file containing a dotted tree # @return a SpecNode object # @more # First tag is special. # We don't interpret the first line of the file, # but uses a special file tag. def node_of_file(self, file, nostrip=0): src = Source(name=file, nostrip=nostrip) dtree = self.DottedTree.parse_file(file, src) tag = 'file' arg = file text = dtree.tag.strip() children = self.nodes_of_dforest(dtree.children, src) index = dtree.index return self.node_of_tatci(tag, arg, text, children, index, src) def node_of_string(self, string, name='<string>', nostrip=0): dtree = self.DottedTree.parse_string(string) tag = 'string' arg = name src = Source(name=name, string=string, nostrip=nostrip) text = dtree.tag.strip() index = dtree.index children = self.nodes_of_dforest(dtree.children, src) return self.node_of_tatci(tag, arg, text, children, index, src) def node_of_dtree(self, dtree, src): tag = dtree.tag textpos = tag.find('\n') if textpos == -1: textpos = len(tag) equpos = tag.find('=', 0, textpos) colonpos = tag.find(':', 0, textpos) if equpos != -1 and (colonpos == -1 or equpos < colonpos): tag, arg = (tag[:equpos].strip()+'=', tag[equpos+1:].strip()) else: if colonpos == -1: if not ' ' in tag[:textpos] or textpos >= len(tag.rstrip()): colonpos = textpos else: raise SyntaxError( 'No colon in spaced tag in node %s' % dtree) tag, arg = (tag[:colonpos].strip(), tag[colonpos+1:] ) if tag in self.node_aliases: tag = self.node_aliases[tag] tag = tag.replace(' ', '_') if tag != 'text' and not src.nostrip: arg = arg.strip() children = self.nodes_of_dforest(dtree.children, src) return self.node_of_taci(tag, arg, children, dtree.index, src) def nodes_of_dforest(self, dforest, src): onodes = [self.node_of_dtree(c, src) for c in dforest] nodes = [] for node in onodes: if node.tag != 'include': nodes.append(node) continue filename = node.arg.strip() filename = self.os.path.join(self.os.path.dirname(src.filename), filename) node = self.node_of_file(filename, nostrip=src.nostrip) nodes.extend(node.children) return tuple(nodes) def _get_node_of_taci(self): return SpecNode def node_of_tatci(self, tag, arg, text, children=(), index=0, src=None): if text: if tag == 'text': if arg: arg = arg + '\n' + text else: arg = text else: children = (self.node_of_taci( 'text', text, (), index, src),) + children return self.node_of_taci(tag, arg, children, index, src) def node_of_text(self, text): # Returns a node that is either # - a 'text' node, if text was all ascii # - a 'char' node, if text was a single non-ascii # - a 'block' with children being a sequence of char and text nodes, # if text contained ascii and non-ascii characters nodes = self.nodes_of_text(text) if len(nodes) == 1: return nodes[0] else: return self.node_of_taci('block', '', nodes) def nodes_of_text(self, text): # Returns a sequence of nodes, encoding text. nodes = [] if self.is_not_ascii(text): chars = [] for char in text: no = ord(char) if no < 128: chars.append(char) else: if chars: nodes.append(self.node_of_taci('text', ''.join(chars))) chars = [] nodes.append(self.node_of_taci('char', str(no))) if chars: nodes.append(self.node_of_taci('text', ''.join(chars))) else: nodes.append(self.node_of_taci('text', text)) return nodes def main(self): root = self._root specdir = root.os.path.join( root.os.path.dirname(root.os.path.realpath(__file__)), '../../specs') main_dt_name = root.os.path.join(specdir, "docexample.gsl") if not root.os.path.exists(main_dt_name): print('%s does not exist, skipping test' % main_dt_name) return env = self.SpecEnv(self) node = self.node_of_file(main_dt_name) node.accept(env) def print_doc(self, dt): self.print_doc() def unparse_head(self, level, tag, arg, text): head = tag if arg: head = head + ': ' + arg if text: head = head + '\n' + text tag = self.DottedTree.unparse_tag(level, head) return tag def test_main(): from guppy import Root root = Root() root.guppy.gsl.SpecNodes.main()	18.48 KB	2026-01-20 12:58
📄 Tester.py class Doc2Tester: def __init__(self, mod, doc, node): self.mod = mod self.doc = doc self.node = node self.exdefs = [] self.set_out([]) self.test_names = {} self.condition_exprs = {} self.condition_methods = {} self.document_metas = [] self.document_lang = None self.document_title = None self.example_exprs = {} self.ex_id = 1 def _visit_children(self, node): E = self.mod.ReportedError for ch in node.children: try: ch.accept(self) except E: pass def ap(self, args): self.extend(args) def error(self, msg, args, *kwds): msg = 'Doc2Tester: ' + msg self.doc.env.error(msg, args, *kwds) def get_condition_method(self, cond): idn = cond.get_id_name() name = self.condition_methods.get(idn) if name is None: name = 'cond_%d' % len(self.condition_methods) self.condition_methods[idn] = name ap = self.ap myself = '_self' arg_names = cond.get_arg_names() while myself in arg_names: myself = '_' + myself argstring = ', '.join([myself]+arg_names) ap('def %s(%s):' % (name, argstring), '<NL>', '<INDENT>') ap('# Condition: %s' % idn, '<NL>') pcs = cond.find_aspects('python_code') if not pcs: self.error('No python code specified for testing condition: %r.' % idn, cond.src.node, exception=None) for pc in pcs: for ic in pc.find_aspects('in_context'): ctx = ic.src.node.arg.strip() for line in ctx.split('\n'): ap(line, '<NL>') if pc is pcs[-1]: ap('return (%s)' % pc.src.node.arg.strip(), '<NL>') else: ap('if not (%s):' % pc.src.node.arg.strip(), '<NL>', '<INDENT>') ap('return False', '<NL>', '<DEDENT>') ap('<DEDENT>') return name def gen_comment(self, s): for line in s.split('\n'): self.ap('# '+line, '<NL>') def get_children(self, node): if not node.arg.strip(): return node.children return (self.doc.node_of_taci('name', node.arg.strip()),)+tuple(node.children) def get_condition_expr(self, po, args, attr, src, tgt): cond = po.get_definition() if cond is None: return None name = self.get_condition_method(cond) callargs = [] self_name = attr.get_self_name() for an in po.arg_names: v = None if an == self_name: v = src elif an == '<returned value>': v = tgt else: v = args.get_arg_value(an) if v is None: self.error('Invalid condition argument: %r.' % an, po.src.node, exception=None) continue v = args.mapname(v) callargs.append(v) return '%sself.%s(%s)' % ( ('', 'not ')[po.is_not], name, ', '.join(callargs)) def get_example_expr(self, eg): ex = self.example_exprs.get(eg) if ex is not None: return ex ex = eg.get_ex_text() ctx = eg.get_ctx_text() if ctx: ex_name = 'get_ex_%d' % self.ex_id self.ex_id += 1 self.ap('def %s(self):' % ex_name, '<NL>', '<INDENT>') for line in ctx.split('\n'): self.ap(line, '<NL>') self.ap('return %s' % ex, '<NL>', '<DEDENT>') ex = 'self.%s()' % ex_name self.example_exprs[eg] = ex return ex def get_test_name(self, kind): tn = kind.srclastname if tn in self.test_names: i = self.test_names[tn] self.test_names[tn] += 1 tn = '%s_%d' % (tn, i) else: self.test_names[tn] = 1 return tn def get_tester(self): ap = self.ap ap('# Tests generated by: %s' % __name__, '<NL>') # ap('# Main source file: %s' % # self.doc.env.get_package().get_filename(), '<NL>') ap('# Date: %s' % self.mod.time.asctime( self.mod.time.localtime()), '<NL>') ap('class Tester:', '<NL>', '<INDENT>') ap('tests = {}', '<NL>') self._visit_children(self.node) lines = [] indent = 0 line = [] for tok in self.out: if tok == '<INDENT>': indent += 4 elif tok == '<DEDENT>': indent -= 4 elif tok == '<NL>': lines.append(''.join(line)) line = [] else: if not line: line.append(indent ' ') line.append(tok) return '\n'.join(lines)+'\n' def set_out(self, out): self.out = out self.extend = out.extend def visit_arglist(self, node): self.ap('(') comma = 0 for ch in self.get_children(node): if comma: self.ap(', ') else: comma = 1 ch.accept(self) self.ap(')') def visit_assign(self, node): children = self.get_children(node) while children: children[0].accept(self) self.ap(' = ') children[1].accept(self) self.ap('<NL>') children = children[2:] def visit_block(self, node): self.ap('<INDENT>') self._visit_children(node) self.ap('<DEDENT>') def visit_call(self, node): children = self.get_children(node) children[0].accept(self) self.ap('(') comma = 0 for ch in children[1:]: if comma: self.ap(', ') else: comma = 1 ch.accept(self) self.ap(')') def visit_comment(self, node): pass def visit_def(self, node): self.ap('def ') children = self.get_children(node) children[0].accept(self) children[1].accept(self) self.ap(':', '<NL>') for ch in children[2:]: ch.accept(self) def visit_default(self, node): self.error('I don\'t know what to generate for the tag %r.' % node.tag, node) def visit_document(self, node): self._visit_children(node) def visit_document_lang(self, node): if self.document_lang is not None: self.error('Duplicate document lang directive.', node) self.document_lang = node def visit_document_title(self, node): if self.document_title is not None: self.error('Duplicate document title directive.', node) self.document_title = node def visit_exdefs(self, node): self.exdefs.append(node) def visit_fcall(self, node): self.visit_call(node) def visit_index(self, node): children = self.get_children(node) children[0].accept(self) self.ap('[') comma = 0 for ch in children[1:]: if comma: self.ap(', ') else: comma = 1 ch.accept(self) self.ap(']') def visit_meta(self, node): self.document_metas.append(node) def visit_name(self, node): self.ap(node.arg.strip()) def visit_pcall(self, node): self.visit_call(node) self.ap('<NL>') def visit_string(self, node): self.ap('%r' % node.arg.strip()) def visit_subject(self, node): self.ap('SUBJECT') def visit_test_of(self, node): TestOf(self, node) def visit_test_program_segment(self, node): self.gen_comment('Test for: %s' % node.arg.strip()) self._visit_children(node) def visit_to_document_only(self, node): pass def visit_to_tester_only(self, node): self._visit_children(node) class DiffKind: def __init__(self, a, b): self.a = a self.b = b self.d_tag = 'diffkind' def get_atom_kinds(self): return [self] def get_id_name(self): return self.a.get_id_name() + '+' + self.b.get_id_name() + "'" class EitherTest: def __init__(self, ): pass class TestOf(Doc2Tester): def __init__(self, parent, node): self.__dict__.update(parent.__dict__) self.parent = parent self.node = node kind, args = node.arg, node.children mod = self.mod = parent.mod self.Kan = mod.KanExtension self.Cat = mod.Cat self.args = args self.kind = kind self.coverage = None for node in args: t = node.tag if t == 'coverage': if self.coverage is not None: self.error('Duplicate coverage specifications', node, exception=None) else: try: coverage = int(node.arg.strip()) except ValueError: coverage = node.arg.strip() self.coverage = coverage else: self.error('Invalid element in %r.' % self.node.tag, node, exception=None) if self.coverage is None: self.coverage = 1 self.make_cat() def getattr_code(self, obj, attr): if self.mod.is_identifier(attr): return '%s.%s' % (obj, attr) else: return 'getattr(%s, %r)' % (obj, attr) def warn(self, message, node=None): self.error(message, node, exception=None, harmless=1) def make_cat(self): objects = [] arrows = {} relations = [] fa = {} fo = {} arg_counter = 1 ac = [1] eithertests = [] kinds = [] kindofname = {} ex_setup = [] ex_map = {} pc_checks = {} def add_kind(kind): name = kind.get_id_name() if name not in objects: objects.append(name) kinds.append(kind) kindofname[name] = kind return name def get_example_expr(a): if a in ex_map: return ex_map[a] x = self.parent.get_example_expr(a) usage = a.get_use_text(x) ex_map[a] = usage return usage def gen_atom_beam(asp): asptgt = asp.tgt tag = asptgt.d_tag if tag == 'attribute': attr = asptgt otherkinds = [] atkak = attr.get_atom_beams() for ab in atkak: a = ab.tgt if a.d_tag == 'mapping': op = asp + ab ret_kind = a.get_return_test_kind() tgt_name = add_kind(ret_kind) examples = a.get_args_examples(get_example_expr, kind) for args in examples: arrow_name = 'CALLATTR%d' % ac[0] ac[0] += 1 arrows[arrow_name] = (src_name, tgt_name) fa[arrow_name] = ('callattr', op, args) else: otherkinds.append(a) if otherkinds or not atkak: if len(otherkinds) != len(atkak): # make new atk somehow oth = [(x.get_id_name(), x) for x in otherkinds] oth.sort() otherkinds = [y for (x, y) in oth] atk = self.mod.Main.Kind() atk.d_tag = 'kind' atk.aspects = otherkinds atk.tgtfullname = '(%s)' % ( '&'.join([x.tgtfullname for x in otherkinds])) else: atk = attr.get_test_kind() arrow_name = '%s:%d' % (attr.get_id_name(), ac[0]) ac[0] += 1 tgt_name = add_kind(atk) assert arrow_name not in arrows arrows[arrow_name] = (src_name, tgt_name) fa[arrow_name] = ('getattr', attr.get_attr_name()) elif tag in ('operator', 'function_operator', 'inplace_operator', 'reverse_operator', 'mapping', 'setitem', 'delitem', 'getitem'): ret_kind = asp.get_return_test_kind() tgt_name = add_kind(ret_kind) examples = asp.get_args_examples(get_example_expr) for args in examples: arrow_name = 'OPERATOR%d' % ac[0] ac[0] += 1 arrows[arrow_name] = (src_name, tgt_name) fa[arrow_name] = (tag, asp, args) elif tag == 'either': asp_name = add_kind(asptgt) if asptgt is not kind: arrow_name = '(%s:%s:%d)' % (src_name, asp_name, ac[0]) ac[0] += 1 arrows[arrow_name] = (src_name, asp_name) fa[arrow_name] = ('subkind', asp_name) for i, ak in enumerate(asptgt.get_alt_kinds()): tgt_name = add_kind(ak) arrow_name = "(%s'%s)" % (asp_name, tgt_name) arrows[arrow_name] = (asp_name, tgt_name) fa[arrow_name] = ('superkind', i) else: assert 0 add_kind(self.kind) while kinds: kind = kinds.pop() src_name = kind.get_id_name() for asp in kind.get_atom_beams(): try: gen_atom_beam(asp) except self.mod.ReportedError: pass cat = self.Cat.oarcat(objects, arrows, relations) tester = self.Kan.category_tester( self.Cat.Functor(fo, fa, cat), coverage=self.coverage) def get_arrow_name(a): return ','.join(a) tester.get_arrow_name = get_arrow_name object_tester = tester.get_object_tester(self.kind.get_id_name()) icode = object_tester.get_intermediate_test_code() e_names = {} e_name_no = [0] def e_name_of(a): if not a: return 'arg' # return 'e[%r]'%a if a not in e_names: e_names[a] = 't%d' % e_name_no[0] e_name_no[0] += 1 return e_names[a] def call_fo(a, b): return 'fo[%r](%s)' % (a, e_name_of(b)) def assign_fa(append, tgt, func, src): tag = func[0] if tag == 'getattr': name = func[1] append('%s = %s' % (tgt, self.getattr_code(src, name))) elif tag in ('callattr', 'operator', 'inplace_operator', 'function_operator', 'reverse_operator', 'mapping', 'setitem', 'delitem', 'getitem'): op = func[1] opname = op.get_op_name() args = func[2] sus = args.get_setups_for_preconditions() if sus is not None: for su in sus: append('%s.%s(%s)' % (src, su.get_name(), su.get_args())) else: self.error('Could not find postcondition to satisfy precondition for %r.' % ( op.get_op_id_name()), exception=None) eqs = [] for eq in op.find_equations(): pres = eq.find_aspects('precondition') posts = eq.find_aspects('postcondition') # xxx late checking but will do for now I may relax it anyway if len(pres) != 1: if pres: node = pres[0].src.node else: node = eq.src.node self.error('Exactly one precondition currently allowed in equation.', node, exception=None) if len(posts) < 1: self.error('At least one postcondition currently required in equation.', eq.src.node, exception=None) if pres: pre = pres[0] ce = self.parent.get_condition_expr( pre, args, op, src, None) if ce is None: # This 'cant happen' anymore, checked here 'just in case'... raise SyntaxError('Undefined condition: %r' % pre) prename = 'pre_%d' % len(eqs) eqs.append((prename, posts)) append('%s = %s' % (prename, ce)) if tag == 'callattr': append('%s = %s(%s)' % (tgt, self.getattr_code(src, opname), args)) elif tag == 'operator': append('%s = %s %s %s' % (tgt, src, opname, args)) elif tag == 'inplace_operator': append('%s = %s' % (tgt, src)) append('%s %s %s' % (tgt, opname, args)) elif tag == 'reverse_operator': append('%s = %s %s %s' % (tgt, args, opname, src)) elif tag == 'function_operator': argstr = str(args) if argstr: argstr = ', ' + argstr append('%s = %s(%s%s)' % (tgt, opname, src, argstr)) elif tag == 'mapping': append('%s = %s(%s)' % (tgt, src, args)) elif tag == 'getitem': # Number of args >=1, has been checked. append('%s = %s[%s]' % (tgt, src, args)) elif tag == 'delitem': # Number of args >=1, has been checked. append('del %s[%s]' % (src, args)) elif tag == 'setitem': # Number of args >=2, has been checked. append('%s[%s] = %s' % (src, ', '.join(args.negs[:-1]), args.negs[-1])) else: assert 0 posts = args.get_postconditions() for po in posts: ce = self.parent.get_condition_expr(po, args, op, src, tgt) if ce is None: continue append('assert %s, %r' % ( ce, 'Failed postcondition: %r' % po.cond_expr, )) for (prename, posts) in eqs: for post in posts: ce = self.parent.get_condition_expr( post, args, op, src, tgt) if ce is None: # This 'cant happen' anymore, checked here 'just in case'... raise SyntaxError('Undefined condition: %r' % post) message = 'Failed postcondition equality: %r' % post append('assert %s == %s, %r' % ( prename, ce, message)) else: assert 0 pylines = [] class ArrowTree: def __init__(self, pre): self.pre = pre self.children = [] def __str__(self): if self.children: chdrn = ', chdrn = %s' % self.children else: chdrn = '' return 'AT(pre = %s%s)' % (self.pre, chdrn) __repr__ = __str__ ats = {} def at_of_pre(pre): at = ats.get(pre) if at is None: at = ArrowTree(pre) ats[pre] = at if pre: at_of_pre(pre[:-1]).children.append(at) return at def trav(t): subs = [] src = t.pre src_name = e_name_of(src) for ch in t.children: try: ar = ch.pre[-1] func = fa[ar] tgt = ch.pre tag = func[0] if tag == 'subkind': e_names[ch.pre] = src_name trav(ch) elif tag == 'superkind': subs.append((func, ch)) else: assign_fa(pylines.append, e_name_of( tgt), func, src_name) trav(ch) except self.mod.ReportedError: pass if subs: subs.sort() indents = 0 for func, ch in subs: e_names[ch.pre] = src_name pos = len(pylines) pylines.append('try:') pylines.append('<INDENT>') trav(ch) if pos+2 == len(pylines): pylines.pop() pylines.pop() else: indents += 1 pylines.append('<DEDENT>') pylines.append('except:') pylines.append('<INDENT>') if indents: pylines.append('raise') pylines.extend(['<DEDENT>']indents) alla = object_tester.get_all_arrows() init = at_of_pre(()) for a in alla: for i in range(1, len(a)+1): at_of_pre(a[:i]) trav(init) if not pylines: self.warn('No tests generated for %r.' % self.kind.tgtfullname) pylines = ['pass'] ap = self.parent.ap name = self.parent.get_test_name(self.kind) test_name = 'test_%s' % name ap('def %s(self, arg):' % test_name, '<NL>', '<INDENT>') for line in ex_setup + pylines: ap(line) if line not in ('<INDENT>', '<DEDENT>'): ap('<NL>') ap('<DEDENT>') ap('tests[%r] = %s' % (self.kind.tgtfullname, test_name), '<NL>') class _GLUECLAMP_: _imports_ = ( '_parent:SpecNodes', '_parent.SpecNodes:node_of_taci', '_parent:Main', '_parent.Main:ReportedError', '_root.io:StringIO', '_root.sys:stdout', '_root:sys', '_root.traceback:format_exception', '_root.guppy.etc:KanExtension', '_root.guppy.etc:Cat', '_root:re', '_root:time', ) # Reserved words found in Grammar of Python 2.3.3 # Is there a list somewhere in some std lib? reserved_words = ( 'and', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'yield', ) def _get_is_identifier(self): m = self.re.compile('[_a-zA-Z][_a-zA-Z0-9]').match rwd = dict([(rw, 1) for rw in self.reserved_words]) return lambda x: m(x) and x not in rwd def doc2text(self, doc, node): d2h = Doc2Tester(self, doc, node) return d2h.get_tester() def doc2filer(self, doc, node, name, dir, opts, IO): text = self.doc2text(doc, node) path = IO.path.join(dir, '%s.py' % name) node = self.node_of_taci('write_file', path, [ self.node_of_taci('text', text)]) return node	23.99 KB	2026-01-20 12:58
📄 Text.py # Convert a node representation to text # in some different forms # o output to an object with an interface subset of Tk Text # o output to ascii-only - best attempt w.o. different fonts # o output to man-page text # Parameterized on out # I have to define the roles of responsibility. # out is a thin layer above something Tk text-like # it isolates some details but doesn't provide real new functionality # Node2Inter takes care of the general formatting # It needs to know about # o the size of out, i.e. width and height # o the fonts and sizes available # o the special characters available # o the size of the fonts # o we restrict to fixed size fonts # otherwise it would have to ask for size of strings? # # to be able to do # o line wrapping # o paragraphs # o headers # o item and bullet lists # o tables # The out can 'record' its commands # and play them on an actual Tk text window. # with a simple translation # o it can operate stack-free # -- so after eg a font change, there is a font change back # Does the out has a configuration table # such as, # o the fonts to choose # o for different sizes # o whether to make items bold # In any case there may be default here.. class Node2Inter: def __init__(self, mod, node, out, cnf, width=None): self.mod = mod self.out = out self.cnf = cnf self.width = width self.span_stack = [] self.attrs_stack = [{}] self.atparbegin = 1 self.inpre = 0 self.ul_level = 0 self.prev_margin_bottom = 0 self.sizescale = cnf.sizescale if node is not None: self._visit_outer_node(node) def _visit_outer_node(self, node): cnf = self.cnf self.span_begin(font_family=cnf.textfamily, font_size=cnf.sizeindex) node, attrs = node.split_attrs() for k, v in attrs: k = k.strip() v = v.strip() setattr(self.out, '_gsl_%s' % k, v) node.accept(self) self.span_end() def _visit_node(self): node, attrs = node.split_attrs() if attrs: self.attrs_stack def append(self, x): self.out.insert('end', x, self.tags) def div(self, node, margin_bottom=0, kwds): self.div_begin(kwds) node.arg_accept(self) self.div_end(margin_bottom) def div_begin(self, margin_top=0, kwds): if self.span_stack: d = self.span_stack[-1] if 'spacing1' in d: if self.atparbegin: margin_top = max(margin_top, d['spacing1']) self.tag_config(self.tag, d) del d['spacing1'] margin_top = max(margin_top, self.prev_margin_bottom) self.prev_margin_bottom = 0 if not self.atparbegin: self.nl() self.atparbegin = 1 if margin_top: kwds['spacing1'] = margin_top self.span_begin(kwds) def div_end(self, margin_bottom=0): if not self.atparbegin: self.nl() self.span_end() self.atparbegin = 1 self.prev_margin_bottom = margin_bottom def getopt(self, name, default=0): if self.span_stack and name in self.span_stack[-1]: return self.span_stack[-1][name] else: return getattr(self, name, default) def nl(self): self.append('\n') def set_default_tag(self): if self.span_stack: tag = 't%s' % self.mod._root.pickle.dumps(self.span_stack[-1]) else: tag = 'tag' self.tag = tag self.tags = (tag,) def span(self, node, kwds): self.span_begin(kwds) node.arg_accept(self) self.span_end() def span_begin(self, kwds): if self.span_stack: d = self.span_stack[-1].copy() d.update(kwds) else: d = kwds self.span_stack.append(d) self.set_default_tag() def span_end(self): tag = self.tag self.tag_config(tag, self.span_stack[-1]) self.span_stack.pop() self.set_default_tag() def tag_config(self, tag, kwds): okwds = {} fontspecs = [] for k, v in list(kwds.items()): if not k.startswith('font_'): okwds[k] = v continue else: fontspecs.append((k[5:], v)) if fontspecs: font = [None, None, ''] for k, v in fontspecs: if k == 'size': v = max(0, min(len(self.sizescale)-1, v)) font[1] = self.sizescale[v] elif k == 'family': font[0] = v else: if font[2]: font[2] += ' ' font[2] += k if not font[2]: font.pop() okwds['font'] = tuple(font) self.out.tag_config(tag, okwds) def text(self, text): if not self.inpre: if self.atparbegin: text = text.lstrip() if not text: return text = text.replace('\n', ' ') text = text.replace('\t', ' ') while ' ' in text: text = text.replace(' ', ' ') if self.atparbegin and self.prev_margin_bottom: self.tag_config(self.tag, self.span_stack[-1]) self.span_stack[-1]['spacing1'] = self.prev_margin_bottom self.set_default_tag() self.prev_margin_bottom = 0 self.append(text) else: text = text.expandtabs() idx = text.find('\n') if idx != -1 and 'spacing1' in self.span_stack[-1]: self.append(text[:idx+1]) self.tag_config(self.tag, *self.span_stack[-1]) del self.span_stack[-1]['spacing1'] self.set_default_tag() text = text[idx+1:] if text: self.append(text) self.atparbegin = 0 def _visit_children(self, node): E = self.mod.ReportedError for ch in node.children: try: ch.accept(self) except E: pass def _visit_hx(self, node): n = int(node.tag[1:]) font_size = 7 - n margin_top = 12 - 1 n margin_bottom = 12 - 1 * n self.div(node, font_size=font_size, font_bold=1, margin_top=margin_top, margin_bottom=margin_bottom) def visit_big(self, node): self.span(node, font_size=self.getopt('font_size') + 1) def visit_blockquote(self, node): lmargin = self.getopt('lmargin1') + 36 rmargin = self.getopt('rmargin') + 36 self.div(node, lmargin1=lmargin, lmargin2=lmargin, rmargin=rmargin, margin_top=6, margin_bottom=6, ) def visit_char(self, node): code = node.arg.strip() if code == 'nbsp': self.span_begin(invisible=1) self.append('x') self.span_end() else: self.error( 'I do not know how to render this character code: %r.' % code, node) def visit_code(self, node): self.span(node, font_family=self.cnf.codefamily) def visit_comment(self, node): pass def visit_dl(self, node): self.div(node) def visit_dt(self, node): self.div(node) def visit_dd(self, node): lmargin = self.getopt('lmargin1') + 36 self.div(node, lmargin1=lmargin, lmargin2=lmargin) def visit_define(self, node): # xxx self._visit_children(node) def visit_div(self, node): self.div(node) def visit_document(self, node): self._visit_children(node) def visit_document_lang(self, node): if self.document_lang is not None: self.error('Duplicate document lang directive.', node) self.document_lang = node def visit_document_title(self, node): if self.document_title is not None: self.error('Duplicate document title directive.', node) self.document_title = node def visit_em(self, node): self.span(node, font_italic=1) def visit_file(self, node): self._visit_children(node) def visit_gsl_title(self, node): self.out._gsl_title = node.arg def visit_gsl_width(self, node): self.out._gsl_width = int(node.arg) def visit_gsl_height(self, node): self.out._gsl_height = int(node.arg) def visit_h1(self, node): self._visit_hx(node) def visit_h2(self, node): self._visit_hx(node) def visit_h3(self, node): self._visit_hx(node) def visit_h4(self, node): self._visit_hx(node) def visit_h5(self, node): self._visit_hx(node) def visit_h6(self, node): self._visit_hx(node) def visit_li(self, node): indent = self.getopt('lmargin1') + 18 self.div_begin( lmargin1=indent, lmargin2=indent ) mode = ['disc', 'square', 'circle'][self.ul_level % 3] char = {'disc': '', 'circle': 'O', 'square': '[]'}[mode] self.span_begin() self.text('%s ' % char) self.span_end() self.span_begin( lmargin1=indent, lmargin2=indent+12 ) node.arg_accept(self) self.span_end() self.div_end() def visit_p(self, node): self.div(node, margin_top=6, margin_bottom=6) def visit_pre(self, node): self.inpre += 1 self.div(node, font_family=self.cnf.codefamily, margin_top=6, margin_bottom=6) self.inpre -= 1 def visit_small(self, node): self.span(node, font_size=self.getopt('font_size') - 1) def visit_span(self, node): self.span(node) def visit_string(self, node): self._visit_children(node) def visit_strong(self, node): self.span(node, font_bold=1) def visit_sub(self, node): self.span(node, font_size=self.getopt('font_size') - 1, offset=self.getopt('offset') - 2 ) def visit_sup(self, node): self.span(node, font_size=self.getopt('font_size') - 1, offset=self.getopt('offset') + 2 ) def visit_table(self, node): Table(self, node) pass def visit_td(self, node): pass def visit_th(self, node): pass def visit_tr(self, node): pass def visit_text(self, node): self.text(node.arg) self._visit_children(node) def visit_u(self, node): self.span(node, underline=1) def visit_ul(self, node): self.ul_level += 1 self.div(node) self.ul_level -= 1 def visit_var(self, node): self.span(node, font_italic=1) class SimulText: def __init__(self, mod, width=None): self.mod = mod self.width = width self.lines = [[]] self.tags = {} self.textntags = [] self.fonts = {} def insert(self, pos, text, tags): assert pos == 'end' lines = text.split('\n') self.lines[-1].append((lines[0], tags)) for line in lines[1:]: self.lines.append([(line, tags)]) self.textntags.append((text, tags)) def tag_config(self, tag, kwds): if tag in self.tags and kwds == self.tags[tag]: return self.tags[tag] = kwds ## def finalize(self): if len(self.lines[-1]) == 1 and not self.lines[-1][0][0]: self.lines.pop() if self.width is not None: self.wrap_lines() def get_width(self): width = 0 for line in self.lines: w = self.text_width(line) if w > width: width = w return width def replay(self, out, lineidx): if lineidx >= len(self.lines): return line = self.lines[lineidx] for (ch, tags) in line: out.insert('end', ch, tags) for tag in tags: out.tag_config(tag, self.tags[tag]) def split_word(self, line): words = [[]] for text, tags in line: wtext = text.split(' ') for wt in wtext: if wt: words[-1].append((wt, tags)) if words[-1]: words.append([]) return words def text_width(self, textntags): font = None subline = None subfonts = [] for ch, tags in textntags: for tag in tags: if tag in self.tags and 'font' in self.tags[tag]: newfont = self.tags[tag]['font'] break else: assert 0 if newfont != font: if subline: subfonts.append((subline, font)) font = newfont subline = [] subline.append(ch) if subline: subfonts.append((subline, font)) width = 0 for (subline, font) in subfonts: f = self.mod.makefont(font) m = f.measure(''.join(subline)) width += m return width def width_to(self, char): # distance from left margin to first occurence of char # or the width of longest line, if char not found for line in self.lines: w = 0 found = 0 for (text, tags) in line: if char in text: text = text[:text.index(char)] found = 1 w += self.text_width([(text, tags)]) if found: break if found: break if not found: w = self.get_width() return w def wrap_line(self, line): w = self.text_width(line) if w <= self.width: self.lines.append(line) return words = self.split_word(line) i = 0 while i < len(words): pre = list(words[i]) w = self.text_width(pre) while w > self.width: # The word is too long to fit. # I have to cut it off. # xxx this may be somewhat slow # measuring after every character j = 0 # Position j at the chunk that is going to be split while j + 1 < len(pre): w = self.text_width(pre[:j+1]) if w > self.width: break j += 1 # Split this chunk # Allow at least one character k = 2 while k <= len(pre[j][0]): w = self.text_width( pre[:j-1] + [(pre[j][0][:k], pre[j][1])]) if w > self.width: break k += 1 self.lines.append(pre[:j-1] + [(pre[j][0][:k-1], pre[j][1])]) assert self.text_width(self.lines[-1]) <= self.width pre = [(pre[j][0][k-1:], pre[j][1])] w = self.text_width(pre) i += 1 while i < len(words): space = [(' ', pre[-1][1])] word = words[i] w = self.text_width(pre + space + word) if w > self.width: break else: pre.extend(space + word) i += 1 self.lines.append(pre) def wrap_lines(self): lines = self.lines self.lines = [] for line in lines: self.wrap_line(line) class TableCell: def __init__(self, row, node): self.row = row self.table = row.table self.parent = self.table.parent self.cnf = self.parent.cnf self.mod = self.parent.mod self.attrs = {} self.node = self.set_attributes(node) self.gen_out() def align(self, pos, width): align = self.attrs['align'] if align == 'center': self.tabstop = (pos + 0.5width, 'center') elif align == 'left': self.tabstop = (pos, 'left') elif align == 'right': self.tabstop = (pos+width, 'right') elif align == 'char': w = self.out.width_to(self.attrs['char']) co = float(self.attrs['charoff'].rstrip('%'))/100.0 self.tabstop = (pos + cowidth-w, 'left') elif align == 'justify': # XXX I don't know how this works self.tabstop = (pos + 0.5width, 'center') else: raise ValueError('Invalid align: %s' % align) def get_edges(self, width): align = self.attrs['align'] mywidth = self.width if align == 'center': l, r = 0.5 * width - 0.5 * mywidth, 0.5 * width + 0.5 * mywidth elif align == 'left': l, r = 0, mywidth elif align == 'right': l, r = width - mywidth, width elif align == 'char': w = self.out.width_to(self.attrs['char']) co = float(self.attrs['charoff'].rstrip('%'))/100.0 l = co * width - w r = l + mywidth elif align == 'justify': # XXX I don't know how this works l, r = 0, width else: raise ValueError('Invalid align: %s' % align) return l, r def get_width(self): self.width = self.out.get_width() self.numlines = len(self.out.lines) return self.width def set_attributes(self, node): a = self.attrs if node.tag == 'th': align = 'center' else: align = 'left' a['align'] = align a['char'] = self.cnf.decimal_point a['charoff'] = '50%' node, attrs = node.split_attrs() for k, v in attrs: a[k] = v return node def gen_out(self, width=None): self.out = SimulText(self.mod, width=width) n2i = Node2Inter(self.mod, None, self.out, self.cnf, width=width) kwds = self.parent.span_stack[-1].copy() if self.node.tag == 'th': kwds['font_bold'] = 1 n2i.span_begin(*kwds) self.node.arg_accept(n2i) n2i.span_end() self.out.finalize() self.get_width() def wrap_to_width(self, width): if width >= self.width: return self.gen_out(width) class TableRow: def __init__(self, table, node): self.table = table self.node = node self.numlines = 1 self.cells = [] node, attrs = node.split_attrs() self.attrs = attrs node.children_accept(self) def new_cell(self, node): cell = TableCell(self, node) self.cells.append(cell) def visit_td(self, node): self.new_cell(node) def visit_th(self, node): self.new_cell(node) class Table: def __init__(self, parent, node): self.parent = parent self.node = node self.caption = None self.rows = [] parent.div_begin(margin_top=6) self.lmargin = parent.getopt('lmargin1') node.children_accept(self) Width = 400 w = self.columnify() widths = self.widths spacings = self.spacings if w > Width: # Which one to wrap? # The longest? # All? gw = [Width / len(self.widths)]len(self.widths) extra = 0 others = list(range(len(self.widths))) for i, w in enumerate(self.widths): if w < gw[i]: extra += gw[i] - w gw[i] = w others.remove(i) extra = int(extra / len(others)) for i in others: gw[i] += extra widths = self.widths = gw for row in self.rows: col = 0 for cell in row.cells: cell.wrap_to_width(gw[col]) col += 1 for row in self.rows: col = 0 pos = 0 for cell in row.cells: w = widths[col] cell.align(pos+self.lmargin, w) pos += w + spacings[col] col += 1 row.numlines = max(row.numlines, cell.numlines) for row in self.rows: for i in range(row.numlines): tabstops = [] for cell in row.cells: tabstops.extend(cell.tabstop) tabstops = tuple(tabstops) if i == 0 and row is self.rows[0]: tabkwds = row.cells[0].out.tags[row.cells[0].out.lines[0][0][1][0]] else: tabkwds = {} if row is not self.rows[0] and i == 0: tabkwds['spacing1'] = 6 tabtag = str(tabstops)+str(tabkwds) for cell in row.cells: parent.out.insert('end', '\t', (tabtag,)) cell.out.replay(parent.out, i) parent.out.tag_config(tabtag, tabs=tabstops, *tabkwds) parent.nl() parent.div_end() def columnify(self): # Make the cells aligned in columns widths = self.widths = [] for row in self.rows: col = 0 for cell in row.cells: w = cell.get_width() if col >= len(widths): widths.append(w) else: widths[col] = max(w, widths[col]) row.numlines = max(row.numlines, cell.numlines) col += 1 # Extra spacing after column i spacings = self.spacings = [0] len(widths) MINSPACING = 10 for row in self.rows: col = 0 for cell in row.cells[:-1]: rcell = row.cells[col+1] ledge = cell.get_edges(widths[col])[1] redge = rcell.get_edges(widths[col+1])[0]+widths[col] spacing = MINSPACING - (redge - ledge) spacings[col] = max(spacing, spacings[col]) col += 1 width = 0 for row in self.rows: col = 0 pos = 0 for cell in row.cells: w = widths[col] cell.align(pos+self.lmargin, w) pos += w + spacings[col] col += 1 if pos > width: width = pos self.width = width return width def visit_tfoot(self, node): node.children_accept(self) def visit_thead(self, node): node.children_accept(self) def visit_tr(self, node): row = TableRow(self, node) self.rows.append(row) class RecordingInter: FLATTEXT = 1 FLATKWDS = 0 lasttext = () lasttag = None def __init__(self): self.appends = [] self.tag_configs = {} self.lasttext = [] self.clearmemo() def __str__(self): return 'APPENDS: %s TAG_CONFIGS: %s' % (self.appends, self.tag_configs) def clearmemo(self): self.memo = {} # Maps any value to it self self.tagmemo = {} # Maps tag to integer tag number def flush(self): if self.lasttext: tag = self.tagmemo.setdefault(self.lasttag, len(self.tagmemo)) text = ''.join(self.lasttext) text = self.memo.setdefault(text, text) if self.FLATTEXT: self.appends.append(tag) self.appends.append(text) else: tt = tag, text tt = self.memo.setdefault(tt, tt) self.appends.append(tt) self.lasttext = [] def insert(self, pos, text, tags): assert pos == 'end' assert len(tags) == 1 tag = tags[0] if tag != self.lasttag: self.flush() self.lasttag = tag self.lasttext.append(text) def play(self, out): self.flush() if self.FLATTEXT: i = 0 while i < len(self.appends): tag = self.appends[i] text = self.appends[i+1] out.insert('end', text, (tag,)) i += 2 else: for tag, text in self.appends: out.insert('end', text, (tag,)) for (tag, kwdlist) in list(self.tag_configs.items()): if self.FLATKWDS: kwds = {} i = 0 while i < len(kwdlist): kwds[kwdlist[i]] = kwdlist[i+1] i += 2 out.tag_config(tag, kwds) else: out.tag_config(tag, dict(kwdlist)) for k in self.__dict__: if k.startswith('_gsl_'): setattr(out, k, getattr(self, k)) def prepare_for_pickle(self): # Call this before pickling to reduce space usage. self.flush() for k in list(self.__dict__.keys()): if k not in ('appends', 'tag_configs') and not k.startswith('_gsl_'): delattr(self, k) def tag_config(self, tag, kwds): kwdlist = [] for k, v in list(kwds.items()): k = self.memo.setdefault(k, k) v = self.memo.setdefault(v, v) if self.FLATKWDS: kwdlist.append(k) kwdlist.append(v) else: kv = k, v kv = self.memo.setdefault(kv, kv) kwdlist.append(kv) kwdlist = tuple(kwdlist) kwdlist = self.memo.setdefault(kwdlist, kwdlist) tag = self.tagmemo.setdefault(tag, len(self.tagmemo)) if tag in self.tag_configs: assert self.tag_configs[tag] == kwdlist else: self.tag_configs[tag] = kwdlist class TextInter: def __init__(self, mod, wid): self.mod = mod self.wid = wid for name in ( 'config', 'insert', 'tag_delete', ): setattr(self, name, getattr(wid, name)) def tag_config(self, tag, kwds): if 'invisible' in kwds: del kwds['invisible'] kwds['foreground'] = kwds['background'] = kwds.get( 'background', self.wid['background']) self.wid.tag_config(tag, **kwds) class TkConfig: sizeindex = 3 sizescale = (6, 8, 10, 12, 16, 20, 24, 28) textfamily = 'times' codefamily = 'courier' decimal_point = '.' # default CHAR attribute class _GLUECLAMP_: _imports_ = ( '_parent:SpecNodes', '_parent.SpecNodes:node_of_taci', '_parent.SpecNodes:node_of_string', '_parent.Main:ReportedError', '_parent:Html', '_root:pickle', '_root.md5:md5', '_root:os', '_root:re', '_root:string', '_root:tkinter', ) def _get_makefont(self): fonts = {} root = self.tkinter.Tk() root.withdraw() def makefont(font): if font in fonts: return fonts[font] weight = 'normal' slant = 'roman' if len(font) > 2: if 'bold' in font[2]: weight = 'bold' if 'italic' in font[2]: slant = 'italic' f = self.tkinter.font.Font(family=font[0], size=font[1], weight=weight, slant=slant) fonts[font] = f return f return makefont def _get_tkconfig(self): return TkConfig() def node2inter(self, node, inter, tkconfig=None): if tkconfig is None: tkconfig = self.tkconfig Node2Inter(self, node, inter, tkconfig) def gsltextviewer(self, parent=None, filename=None, text=None, node=None, htmloutfile=None, inpickle=0, inrecorder=0, outrecorder=0 ): # It seems they dont want we mix data and py files in the dist sigh # so these are last minute hacks pickle = self.pickle if inpickle: inrecorder = pickle.loads(inpickle) if node is None: if text is None: if filename is not None: with open(filename) as f: text = f.read() node = self.node_of_string(text, nostrip=1) if htmloutfile is not None: self.Html.node2file(node, htmloutfile) if outrecorder: r = RecordingInter() self.node2inter(node, r) r.prepare_for_pickle() return r cache = None if filename is not None: sp = self.os.path.splitext(filename) if sp[1] == '.gsl': cache = sp[0] + '.gsc' m = self._root.guppy.etc.textView.TextViewer( parent, 'Untitled', data='') v = m.textView v['state'] = 'normal' v['font'] = 'Times -12' v.bind('<Destroy>', lambda event: m.quit()) if cache or inrecorder: if inrecorder: r = inrecorder else: r = None textdigest = self.md5(text.encode('utf-8')).digest() try: f = open(cache) except IOError: pass else: td = f.read(len(textdigest)) if td == textdigest: r = pickle.load(f) f.close() if r is None: r = RecordingInter() self.node2inter(node, r) r.prepare_for_pickle() f = open(cache, 'w') try: try: f.write(textdigest) except IOError: pass # maybe write protected just ignore for now XXX else: pickle.dump(r, f, 0) finally: f.close() r.play(v) else: self.node2inter(node, v) title = getattr(v, '_gsl_title', None) if title: m.title(title) m.iconname(title) geometry = getattr(v, '_gsl_tk_geometry', None) if geometry: m.geometry(geometry) v['state'] = 'disabled' return m def test_string(s=None, name=None): from guppy import Root gsl = Root().guppy.gsl me = gsl.Text if s is None: s = getattr(me._parent.test.testdata, name) T = me.tkinter node = me.node_of_string(s, nostrip=1) me._parent.Html.node2file(node, '/tmp/x.html') t = RecordingInter() me.node2inter(node, t) t.prepare_for_pickle() root = T.Tk() root.withdraw() text = me._root.guppy.etc.textView.TextViewer( root, 'test', data='').textView text['state'] = 'normal' text['font'] = 'Times -12' text.bind('<Destroy>', lambda event: root.quit()) ti = TextInter(me, text) t.play(ti) text.mainloop() def test(): name = 'long_wrapping_tables' name = 'html_tables' test_string(name=name)	31.13 KB	2026-01-20 12:58
📄 XHTML.py class Node2XHTML: def __init__(self, mod, node=None, error_report=None, encode_name=None ): self.mod = mod self.valid_html40 = False self.encode = self.mod.encode if encode_name is None: encode_name = self.mod.encode_name self.encode_name = encode_name if error_report is not None: self.error_report = error_report self.document_lang = None self.header_nodes = [] self.indent = 0 self.indentstep = 1 self.set_out([]) # xxx where do this? charset = 'utf-8' self.header_nodes.append(self.mod.node_of_taci( 'meta', '', ( self.mod.node_of_taci('http-equiv=', 'Content-Type'), self.mod.node_of_taci('content=', 'text/html; charset=%s' % charset)))) if node is not None: node.accept(self) def _visit_children(self, node): node, attrs = node.split_attrs() # xxx handle attrs? E = self.mod.ReportedError for ch in node.children: try: ch.accept(self) except E: pass def begin(self, tag, arg=''): t = '<'+tag if arg: t = t + ' ' + arg if tag in self.mod._no_end_tag_elements: # Quote from: http://gutenberg.hwg.org/markupXHTML.html # N.B. The penultimate closing slash on empty elements such as the <img/> # element can cause a problem in older browsers. For this reason it is # recommended that you leave a space before the slash, namely <img /> t += ' /' t += '>' if tag in self.mod.line_break_allowed: t = '\n'+self.indent * ' ' + t self.append(t) self.indent += self.indentstep def chg_out(self, out): oo = self.out self.set_out(out) return oo def encode_link_name(self, name): # 1. Make the name better looking for a html user's perspective # 2. Encode it by HTML rules if name.startswith(self.mod.tgt_prefix): name = name[len(self.mod.tgt_prefix):] else: # Should not happen often or at all assert 0 name = self.encode_name(name) return name def end(self, tag): self.indent -= self.indentstep self.append('</%s>' % tag) def error(self, msg, args, kwds): msg = 'Doc2XHTML: ' + msg self.error_report(msg, args, *kwds) def error_report(self, msg, args, kwds): print('HTML ENCODING ERROR: ', msg, 'args=', args, 'kwds=', kwds) raise ValueError def gen_document_header(self, lang, header_nodes): # lang & title are nodes with text or char directives, to be encoded. # metas is a list of nodes, with data to be encoded strict = 1 # we have alternatives, I just havent yet decided how or if to let the user choose if strict: self.append("""\ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> """) else: self.append("""\ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> """) self.begin('html', 'lang=%r xmlns="http://www.w3.org/1999/xhtml"' % self.get_encoded_text( lang), ) self.begin('head') for node in header_nodes: self.gen_stdhtml(node) self.end('head') self.begin('body') # Get around w3c restriction that character data are not allowed # directly in body, makes it easier to write compliant code # Arguably the restriction is there for a reason, but I dont know... self.begin('div') def gen_document_trailer(self): self.end('div') self.end('body') self.end('html') def gen_empty_elmt(self, tag, arg=''): self.begin(tag, arg) self.indent -= self.indentstep def gen_generated_from_gsl(self): self.gen_empty_elmt('hr') self.append('Generated by ') self.begin('a', 'href="https://zhuyifei1999.github.io/guppy3/gsl.html"') #self.begin('a', 'href="gsl.html"') self.append('GSL-XHTML 0.1.7') self.end('a') self.append(' on '+self.mod.time.asctime(self.mod.time.localtime())) def gen_meta(self, node, tag=None): mknode = self.mod.node_of_taci if tag is None: tag = node.tag self.header_nodes.append( mknode('meta', '', [mknode('name=', tag), mknode('content=', node.arg, node.children)])) def gen_stdhtml(self, node, tag=None, options): if tag is None: tag = node.tag node, attrs = node.split_attrs(tag) self.begin(tag, ' '.join(['%s=%r' % (key, val) for (key, val) in attrs])) if tag in self.mod._no_end_tag_elements: if node.arg: self.error( 'No enclosed text allowed for Html tag: %r.' % node.tag) self.no_children(node) self.indent -= self.indentstep else: node.arg_accept(self) self.end(tag) def get_encoded_text(self, node): # From a node's arg and children that are text or characters old_out = self.chg_out([]) self.append(self.encode(node.arg)) for ch in node.children: if ch.tag in ('text', 'char'): ch.accept(self) else: self.error('Only text and char allowed here, not %r.' % ch.tag, ch) return ''.join(self.chg_out(old_out)) def get_html(self): return ''.join(self.out) def no_children(self, node): if node.children: self.error('No children allowed for %r. Got children nodes = %r.' % ( node.tag, node.children)) def set_out(self, out): self.out = out self.extend = out.extend self.append = out.append def visit_author(self, node): self.gen_meta(node) def visit_block(self, node): self._visit_children(node) def visit_char(self, node): name = node.get_namearg() if name in self.mod.name2codepoint: name = '&%s;' % name else: if name[:2] == "0x": char = int(name[2:], 16) elif name.isdigit(): char = int(name) else: self.error('No such character: %r.' % name, node) name = self.mod.codepoint2name.get(char) if name is None: name = '&#%d;' % char else: name = '&%s;' % name self.append(name) self._visit_children(node) def visit_col_width(self, node): self.append('<col width="%s" />' % node.arg) def visit_comment(self, node): return # self.append('<!-- %s -->'%node.arg) def visit_default(self, node): if node.tag in self.mod.stdhtml: if node.tag in self.mod._head_elements: self.head_nodes.append(node) else: self.gen_stdhtml(node) else: self.error('I don\'t know what to generate for the tag %r.' % node.tag, node) def visit_define(self, node): name = self.encode_link_name(node.arg) self.begin('a', 'name=%r' % name) self._visit_children(node) self.end('a') def visit_document(self, node): self.indent = 2 # Known indentation of header to be generated later oldout = self.chg_out([]) self._visit_children(node) # self.gen_generated_from_gsl() newout = self.chg_out(oldout) mknode = self.mod.node_of_taci lang = self.document_lang if not lang: lang = mknode('document_lang', 'en') self.indent = 0 self.gen_document_header(lang, self.header_nodes) self.out.extend(newout) self.gen_document_trailer() def visit_document_lang(self, node): if self.document_lang is not None: self.error('Duplicate document lang directive.', node) self.document_lang = node def visit_document_title(self, node): self.header_nodes.append(self.mod.node_of_taci('title', node.arg)) def visit_enumerate(self, node): self.begin('ol') for c in node.children: self.begin('li') c.accept(self) self.end('li') self.end('ol') def visit_exdefs(self, node): self.symplace = {} for ch in node.children: syms = [x.strip() for x in ch.arg.split(',')] for sym in syms: self.symplace[sym] = ch.tag def visit_generated_from_gsl(self, node): self.gen_generated_from_gsl() def visit_header(self, node): self.header_nodes.extend(node.children) def visit_itemize(self, node): self.begin('ul') for c in node.children: self.begin('li') c.accept(self) self.end('li') self.end('ul') def visit_link_to_extern(self, node): name = node.arg docname = node.children[0].arg children = node.children[1:] uri = '%s.html#%s' % (docname, self.encode_link_name(name)) self.begin('a', 'href=%r' % uri) if not children: self.append(self.encode(name)) else: for ch in children: ch.accept(self) self.end('a') def visit_link_to_local(self, node): name = node.arg uri = '#%s' % self.encode_link_name(name) self.begin('a', 'href=%r' % uri) if not node.children: self.append(self.encode(name)) else: self._visit_children(node) self.end('a') def visit_link_to_unresolved(self, node): name = node.arg self.begin('em') if not node.children: self.append(self.encode(name)) else: self._visit_children(node) self.end('em') def visit_literal_block(self, node): self.gen_stdhtml(node, 'pre') def visit_man_page_mode(self, node): self._visit_children(node) def visit_meta(self, node): self.document_metas.append(node) def visit_spc_colonkind(self, node): # self.append(' <strong>:</strong> ') # self.append(' <code>:</code> ') self.append('<code>:</code> ') def visit_spc_mapsto(self, node): self.append(' <strong>-></strong> ') def visit_string(self, node): self._visit_children(node) def visit_symbol(self, node): self.visit_text(node) def visit_text(self, node): text = self.encode(node.arg) if len(text) > 80 or '\n' in text: self.append('\n') self.append(text) self._visit_children(node) def visit_to_document_only(self, node): self._visit_children(node) def visit_to_html_only(self, node): self._visit_children(node) def visit_to_tester_only(self, node): pass def visit_valid_html40(self, node): self.valid_html40 = node node, attrs = self.valid_html40.split_attrs(attrdict=True) # XXX check allowed attrs but in a GENERAL way # Code taken from validator.w3.org self.append("""\ <a href="http://validator.w3.org/check?uri=referer"><img src="%s" alt="Valid HTML 4.0 Strict" height="31" width="88" /></a> """ % attrs.get('src', 'http://www.w3.org/Icons/valid-html40')) def visit_with(self, node): pass def visit_word(self, node): self._visit_children(node) class _GLUECLAMP_: _imports_ = ( '_parent:SpecNodes', '_parent.SpecNodes:node_of_taci', '_parent.Gsml:is_not_ascii', '_parent.Main:tgt_prefix', '_parent.Main:ReportedError', '_root.htmlentitydefs:name2codepoint', '_root.htmlentitydefs:codepoint2name', '_root:re', '_root:time', ) _chgable_ = ('tag_uppercase_name_chars',) # Set to make upper-case name characters tagged to make sure # no names in a file differ only in case as stated in HTML spec. # I believe this doesn't matter in practice in contemporary browsers, # since references are also said to be case sensitive! # -- I can't be bothered to solve this better now. See also Notes Aug 12 2005. tag_uppercase_name_chars = 0 _html3_2 = ( 'a', 'address', 'area', 'b', 'base', 'big', 'blockquote', 'body', 'br', 'caption', 'center', 'cite', 'code', 'dfn', 'dt', 'dl', 'dd', 'div', 'em', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'html', 'i', 'img', 'input', 'kbd', 'li', 'ol', 'option', 'p', 'param', 'pre', 'samp', 'select', 'small', 'strong', 'style', 'sub', 'sup', 'table', 'td', 'textarea', 'th', 'thead', 'title', 'tr', 'tt', 'ul', 'var') # Included in Html 3.2 but 'deprecated' in Html 4.0 _html4_0_deprecated = ( 'applet', 'basefont', 'dir', 'font', 'isindex', 'strike', 'u', ) # Included in 3.2, not depreciated in 4.0 but one may want to avoid them _html_avoid = ( 'script', ) _html4_0 = ( 'abbr', 'acronym', 'bdo', 'button', 'col', 'colgroup', 'del', 'fieldset', 'frame', 'frameset', 'iframe', 'ins', 'label', 'legend', 'noframes', 'noscript', 'object', 'optgroup', 'q', 's', 'span', 'tbody', 'tfoot', 'thead') _head_elements = ( 'base', 'isindex', 'link', 'meta', 'script', 'style', 'title' ) # The ones that can have no end tag # xxx are there more -style etc- look it up! _no_end_tag_elements = ( # Header elmts 'meta', 'link', # Other 'img', # CAN have end tag? but never has. This will self-close to generate valid XHTML. 'hr', ) # The ones that we may generate line-break before # and hope it will not affect the insertion of spaces in rendering. _line_break_allowed = ( 'html', 'head', 'body', 'frameset', # Head Elements ) + _head_elements + ( # Generic Block-level Elements 'address', 'blockquote', 'center', 'del', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'ins', 'isindex', 'noscript', 'p', 'pre', # Lists 'dir', 'dl', 'dt', 'dd', 'li', 'menu', 'ol', 'ul', # Tables 'table', 'caption', 'colgroup', 'col', 'thead', 'tfoot', 'tbody', 'tr', 'td', 'th', # Forms 'form', 'button', 'fieldset', 'legend', 'input', 'label', 'select', 'optgroup', 'option', 'textarea' ) # The attributes allowed in META elements meta_attributes = ('name', 'http-equiv', 'content', 'scheme', 'lang', 'dir') # This returns a function checking if a character is allowed to be used # as the first character in a NAME or ID attribute. # (I don't think this is the same as .isalpha() with unicode.) def _get_is_name_starter_char(self): return self.re.compile(r"[A-Za-z]").match # This returns a function checking if a character is allowed to be used # after the first character in a NAME or ID attribute. def _get_is_name_follower_char(self): return self.re.compile(r"[A-Za-z0-9\-_:\.]").match # A set of the ones we generate directly. # This includes the ones from html 3.2 and # I have also included the deprecated and the 4.0 only def _get_stdhtml(self): sh = {} for x in self._html3_2 + self._html4_0_deprecated + self._html4_0: sh[x] = 1 return sh def _get_line_break_allowed(self): sh = {} for x in self._line_break_allowed: sh[x] = 1 return sh def doc2filer(self, doc, node, name, dir, opts, IO): text = self.doc2text(doc, node) path = IO.path.join(dir, '%s.html' % name) node = self.node_of_taci('write_file', path, [ self.node_of_taci('text', text)]) return node def doc2text(self, doc, node): d2h = Node2XHTML(self, node, doc.env.error) return d2h.get_html() def node2file(self, node, file): text = self.node2text(node) with open(file, 'w') as f: f.write(text) def node2text(self, node): text = Node2XHTML(self, node).get_html() return text # Adapted from html4css1.py in docutils def encode(self, text): """Encode special characters in `text` & return.""" # @@@ A codec to do these and all other HTML entities would be nice. text = text.replace("&", "&") text = text.replace("<", "<") text = text.replace('"', """) text = text.replace(">", ">") text = text.replace("@", "@") # may thwart some address harvesters return text # Encode a name according to HTML spec. See also Notes Aug 12 2005. # From wdghtml40/values.html#cdata : # Attribute values of type ID and NAME must begin with a letter in the # range A-Z or a-z and may be followed by letters (A-Za-z), digits # (0-9), hyphens ("-"), underscores ("_"), colons (":"), and periods # ("."). These values are case-sensitive. def encode_name(self, name): is_name_follower_char = self.is_name_follower_char ns = [] append = ns.append upperstate = 0 ch = name[:1] if ch == 'z' or not self.is_name_starter_char(ch): append('z') if ch == 'z': append('z') for ch in name: if ch == '-' or not is_name_follower_char(ch): if upperstate: append('-') upperstate = 0 append('-') if ch != '-': append('%d' % ord(ch)) append('-') elif ch.isupper() and self.tag_uppercase_name_chars: if not upperstate: append('-') upperstate = 1 append(ch) else: if upperstate: append('-') upperstate = 0 append(ch) if upperstate: append('-') return ''.join(ns)	18.38 KB	2026-01-20 12:58
📄 __init__.py ## # Guppy Specification Language # @see {@link ...}	53 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45

Terminal