D7net
Home
Console
Upload
information
Create File
Create Folder
About
Tools
:
/
proc
/
self
/
root
/
opt
/
cloudlinux
/
venv
/
lib64
/
python3.11
/
site-packages
/
guppy
/
gsl
/
Filename :
Main.py
back
Copy
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