diff options
Diffstat (limited to 'python/xtools/pnodes.py')
| -rwxr-xr-x | python/xtools/pnodes.py | 643 |
1 files changed, 341 insertions, 302 deletions
diff --git a/python/xtools/pnodes.py b/python/xtools/pnodes.py index bb1ed8bea..4a1955c91 100755 --- a/python/xtools/pnodes.py +++ b/python/xtools/pnodes.py @@ -13,12 +13,11 @@ prefix_name = "Iir_Kind_" prefix_range_name = "Iir_Kinds_" type_name = "Iir_Kind" node_type = "Iir" -conversions = ['uc', 'pos', 'grp'] +conversions = ["uc", "pos", "grp"] class FuncDesc: - def __init__(self, name, fields, conv, acc, - pname, ptype, rname, rtype): + def __init__(self, name, fields, conv, acc, pname, ptype, rname, rtype): self.name = name self.fields = fields # List of physical fields used self.conv = conv @@ -35,8 +34,8 @@ class NodeDesc: self.name = name self.format = format self.fields = fields # {field: FuncDesc} dict, defined for all fields - self.attrs = attrs # A {attr: FuncDesc} dict - self.order = [] # List of fields name, in order of appearance. + self.attrs = attrs # A {attr: FuncDesc} dict + self.order = [] # List of fields name, in order of appearance. class line: @@ -58,7 +57,7 @@ class linereader: self.filename = filename self.f = open(filename) self.lineno = 0 - self.l = '' + self.l = "" def get(self): self.l = self.f.readline() @@ -74,9 +73,10 @@ class ParseError(Exception): self.msg = msg def __str__(self): - return 'Error: ' + self.msg - return 'Parse error at ' + self.lr.filname + ':' + self.lr.lineno + \ - ': ' + self.msg + return "Error: " + self.msg + return ( + "Parse error at " + self.lr.filname + ":" + self.lr.lineno + ": " + self.msg + ) # Return fields description. @@ -89,21 +89,21 @@ def read_fields(file): lr = linereader(file) # Search for 'type Format_Type is' - while lr.get() != ' type Format_Type is\n': + while lr.get() != " type Format_Type is\n": pass # Skip '(' - if lr.get() != ' (\n': - raise 'no open parenthesis after Format_Type' + if lr.get() != " (\n": + raise "no open parenthesis after Format_Type" # Read formats l = lr.get() - pat_field_name = re.compile(' Format_(\w+),?\n') - while l != ' );\n': + pat_field_name = re.compile(" Format_(\w+),?\n") + while l != " );\n": m = pat_field_name.match(l) if m is None: print l - raise 'bad literal within Format_Type' + raise "bad literal within Format_Type" name = m.group(1) formats.append(name) fields[name] = {} @@ -111,15 +111,15 @@ def read_fields(file): # Read fields l = lr.get() - pat_fields = re.compile(' -- Fields of Format_(\w+):\n') - pat_field_desc = re.compile(' -- (\w+) : (\w+).*\n') - format_name = '' + pat_fields = re.compile(" -- Fields of Format_(\w+):\n") + pat_field_desc = re.compile(" -- (\w+) : (\w+).*\n") + format_name = "" common_desc = {} # Read until common fields. - while l != ' -- Common fields are:\n': + while l != " -- Common fields are:\n": l = lr.get() - format_name = 'Common' + format_name = "Common" nbr_formats = 0 while True: @@ -135,13 +135,13 @@ def read_fields(file): # print 'For: ' + format_name + ': ' + m.group(1) # 2) Disp - if format_name == 'Common': + if format_name == "Common": common_desc = desc else: fields[format_name] = desc # 3) Read next format - if l == '\n': + if l == "\n": if nbr_formats == len(fields): break else: @@ -152,11 +152,10 @@ def read_fields(file): if m is not None: format_name = m.group(1) if format_name not in fields: - raise ParseError( - lr, 'Format ' + format_name + ' is unknown') + raise ParseError(lr, "Format " + format_name + " is unknown") nbr_formats = nbr_formats + 1 else: - raise ParseError(lr, 'unhandled format line') + raise ParseError(lr, "unhandled format line") return (formats, fields) @@ -166,19 +165,18 @@ def read_kinds(filename): lr = linereader(filename) kinds = [] # Search for 'type Iir_Kind is' - while lr.get() != ' type ' + type_name + ' is\n': + while lr.get() != " type " + type_name + " is\n": pass # Skip '(' - if lr.get() != ' (\n': - raise ParseError( - lr, 'no open parenthesis after "type ' + type_name + '"') + if lr.get() != " (\n": + raise ParseError(lr, 'no open parenthesis after "type ' + type_name + '"') # Read literals - pat_node = re.compile(' ' + prefix_name + '(\w+),?( +-- .*)?\n') - pat_comment = re.compile('( +-- .*)?\n') + pat_node = re.compile(" " + prefix_name + "(\w+),?( +-- .*)?\n") + pat_comment = re.compile("( +-- .*)?\n") while True: l = lr.get() - if l == ' );\n': + if l == " );\n": break m = pat_node.match(l) if m: @@ -186,19 +184,18 @@ def read_kinds(filename): continue m = pat_comment.match(l) if not m: - raise ParseError(lr, 'Unknown line within kind declaration') + raise ParseError(lr, "Unknown line within kind declaration") # Check subtypes - pat_subtype = re.compile(' subtype ' + r'(\w+) is ' - + type_name + ' range\n') - pat_first = re.compile(' ' + prefix_name + r'(\w+) ..\n') - pat_last = re.compile(' ' + prefix_name + r'(\w+);\n') - pat_middle = re.compile(' --' + prefix_name + r'(\w+)\n') + pat_subtype = re.compile(" subtype " + r"(\w+) is " + type_name + " range\n") + pat_first = re.compile(" " + prefix_name + r"(\w+) ..\n") + pat_last = re.compile(" " + prefix_name + r"(\w+);\n") + pat_middle = re.compile(" --" + prefix_name + r"(\w+)\n") kinds_ranges = {} while True: l = lr.get() # Start of methods is also end of subtypes. - if l == ' -- General methods.\n': + if l == " -- General methods.\n": break # Found a subtype. m = pat_subtype.match(l) @@ -206,12 +203,12 @@ def read_kinds(filename): # Check first bound name = m.group(1) if not name.startswith(prefix_range_name): - raise ParseError(lr, 'incorrect prefix for subtype') - name = name[len(prefix_range_name):] + raise ParseError(lr, "incorrect prefix for subtype") + name = name[len(prefix_range_name) :] l = lr.get() mf = pat_first.match(l) if not mf: - raise ParseError(lr, 'badly formated first bound of subtype') + raise ParseError(lr, "badly formated first bound of subtype") first = kinds.index(mf.group(1)) idx = first has_middle = None @@ -223,11 +220,11 @@ def read_kinds(filename): # Check element in the middle n = ml.group(1) if n not in kinds: - raise ParseError( - lr, "unknown kind " + n + " in subtype") + raise ParseError(lr, "unknown kind " + n + " in subtype") if kinds.index(n) != idx + 1: raise ParseError( - lr, "missing " + kinds[idx + 1] + " in subtype") + lr, "missing " + kinds[idx + 1] + " in subtype" + ) has_middle = True idx = idx + 1 else: @@ -237,27 +234,27 @@ def read_kinds(filename): last = kinds.index(ml.group(1)) if last != idx + 1 and has_middle: raise ParseError( - lr, "missing " + kinds[idx] + " in subtype") + lr, "missing " + kinds[idx] + " in subtype" + ) break raise ParseError(lr, "unhandled line in subtype") - kinds_ranges[name] = kinds[first:last+1] + kinds_ranges[name] = kinds[first : last + 1] return (kinds, kinds_ranges) + # Read functions def read_methods(filename): lr = linereader(filename) funcs = [] - pat_field = re.compile(r' -- Field: ([\w,]+)( \w+)?( \(\w+\))?\n') - pat_conv = re.compile(r'^ \((\w+)\)$') - pat_func = re.compile( - r' function Get_(\w+) \((\w+) : (\w+)\) return (\w+);\n') - pat_proc = re.compile( - r' procedure Set_(\w+) \((\w+) : (\w+); (\w+) : (\w+)\);\n') - pat_end = re.compile('end [A-Za-z.]+;\n') + pat_field = re.compile(r" -- Field: ([\w,]+)( \w+)?( \(\w+\))?\n") + pat_conv = re.compile(r"^ \((\w+)\)$") + pat_func = re.compile(r" function Get_(\w+) \((\w+) : (\w+)\) return (\w+);\n") + pat_proc = re.compile(r" procedure Set_(\w+) \((\w+) : (\w+); (\w+) : (\w+)\);\n") + pat_end = re.compile("end [A-Za-z.]+;\n") while True: l = lr.get() # Start of methods - if l == ' -- General methods.\n': + if l == " -- General methods.\n": break while True: l = lr.get() @@ -265,7 +262,7 @@ def read_methods(filename): break m = pat_field.match(l) if m: - fields = m.group(1).split(',') + fields = m.group(1).split(",") # Extract access modifier acc = m.group(2) if acc: @@ -275,38 +272,45 @@ def read_methods(filename): if conv: mc = pat_conv.match(conv) if not mc: - raise ParseError(lr, 'conversion ill formed') + raise ParseError(lr, "conversion ill formed") conv = mc.group(1) if conv not in conversions: - raise ParseError(lr, 'unknown conversion ' + conv) + raise ParseError(lr, "unknown conversion " + conv) else: conv = None - if len(fields) > 1 and conv != 'grp': - raise ParseError(lr, 'bad conversion for multiple fields') + if len(fields) > 1 and conv != "grp": + raise ParseError(lr, "bad conversion for multiple fields") # Read function l = lr.get() mf = pat_func.match(l) if not mf: - raise ParseError( - lr, 'function declaration expected after Field') + raise ParseError(lr, "function declaration expected after Field") # Read procedure l = lr.get() mp = pat_proc.match(l) if not mp: - raise ParseError( - lr, 'procedure declaration expected after function') + raise ParseError(lr, "procedure declaration expected after function") # Consistency check between function and procedure if mf.group(1) != mp.group(1): - raise ParseError(lr, 'function and procedure name mismatch') + raise ParseError(lr, "function and procedure name mismatch") if mf.group(2) != mp.group(2): - raise ParseError(lr, 'parameter name mismatch with function') + raise ParseError(lr, "parameter name mismatch with function") if mf.group(3) != mp.group(3): - raise ParseError(lr, 'parameter type mismatch with function') + raise ParseError(lr, "parameter type mismatch with function") if mf.group(4) != mp.group(5): - raise ParseError(lr, 'result type mismatch with function') - funcs.append(FuncDesc(mf.group(1), fields, conv, acc, - mp.group(2), mp.group(3), - mp.group(4), mp.group(5))) + raise ParseError(lr, "result type mismatch with function") + funcs.append( + FuncDesc( + mf.group(1), + fields, + conv, + acc, + mp.group(2), + mp.group(3), + mp.group(4), + mp.group(5), + ) + ) return funcs @@ -316,10 +320,10 @@ def read_methods(filename): # (one description may describe several nodes). # A comment start at column 2 or 4 or later. def read_nodes_fields(lr, names, fields, nodes, funcs_dict): - pat_only = re.compile(' -- Only for ' + prefix_name + '(\w+):\n') - pat_only_bad = re.compile (' -- *Only for.*\n') - pat_field = re.compile(' -- Get/Set_(\w+) \((Alias )?([\w,]+)\)\n') - pat_comment = re.compile(' --(| [^ ].*| .*)\n') + pat_only = re.compile(" -- Only for " + prefix_name + "(\w+):\n") + pat_only_bad = re.compile(" -- *Only for.*\n") + pat_field = re.compile(" -- Get/Set_(\w+) \((Alias )?([\w,]+)\)\n") + pat_comment = re.compile(" --(| [^ ].*| .*)\n") # Create nodes cur_nodes = [] @@ -336,7 +340,7 @@ def read_nodes_fields(lr, names, fields, nodes, funcs_dict): l = lr.get() # Look for fields - while l != '\n': + while l != "\n": # Skip comments while pat_comment.match(l): l = lr.get() @@ -349,9 +353,9 @@ def read_nodes_fields(lr, names, fields, nodes, funcs_dict): name = m.group(1) n = nodes.get(name, None) if n is None: - raise ParseError(lr, 'node is unknown') + raise ParseError(lr, "node is unknown") if n not in cur_nodes: - raise ParseError(lr, 'node not currently described') + raise ParseError(lr, "node not currently described") only_nodes.append(n) l = lr.get() m = pat_only.match(l) @@ -371,29 +375,27 @@ def read_nodes_fields(lr, names, fields, nodes, funcs_dict): if pat_only_bad.match(l): raise ParseError(lr, "misleading 'Only for' comment") else: - raise ParseError(lr, 'bad line in node description') + raise ParseError(lr, "bad line in node description") func = m.group(1) alias = m.group(2) - fields = m.group(3).split(',') + fields = m.group(3).split(",") # Check the function exists and if the field is correct. if func not in funcs_dict: - raise ParseError(lr, 'unknown function') + raise ParseError(lr, "unknown function") func = funcs_dict[func] if func.fields != fields: - raise ParseError(lr, 'fields mismatch') + raise ParseError(lr, "fields mismatch") for c in only_nodes: for f in fields: if f not in c.fields: - raise ParseError( - lr, 'field ' + f + ' does not exist in node') + raise ParseError(lr, "field " + f + " does not exist in node") if not alias: for f in fields: if c.fields[f]: - raise ParseError( - lr, 'field ' + f + ' already used') + raise ParseError(lr, "field " + f + " already used") c.fields[f] = func c.order.append(f) c.attrs[func.name] = func @@ -408,18 +410,18 @@ def read_nodes(filename, kinds, kinds_ranges, fields, funcs): nodes = {} # Skip until start - while lr.get() != ' -- Start of ' + type_name + '.\n': + while lr.get() != " -- Start of " + type_name + ".\n": pass - pat_decl = re.compile(' -- ' + prefix_name + '(\w+) \((\w+)\)\n') - pat_decls = re.compile(' -- ' + prefix_range_name + '(\w+) \((\w+)\)\n') - pat_comment_line = re.compile(' --+\n') - pat_comment_box = re.compile(' --( .*)?\n') + pat_decl = re.compile(" -- " + prefix_name + "(\w+) \((\w+)\)\n") + pat_decls = re.compile(" -- " + prefix_range_name + "(\w+) \((\w+)\)\n") + pat_comment_line = re.compile(" --+\n") + pat_comment_box = re.compile(" --( .*)?\n") while True: l = lr.get() - if l == ' -- End of ' + type_name + '.\n': + if l == " -- End of " + type_name + ".\n": break - if l == '\n': + if l == "\n": continue m = pat_decl.match(l) if m: @@ -430,12 +432,11 @@ def read_nodes(filename, kinds, kinds_ranges, fields, funcs): while True: name = m.group(1) if name not in kinds: - raise ParseError(lr, 'unknown node') + raise ParseError(lr, "unknown node") fmt = m.group(2) names.append((name, fmt)) if name in nodes: - raise ParseError( - lr, 'node {} already described'.format(name)); + raise ParseError(lr, "node {} already described".format(name)) # There might be several nodes described at once. l = lr.get() m = pat_decl.match(l) @@ -454,7 +455,7 @@ def read_nodes(filename, kinds, kinds_ranges, fields, funcs): continue if pat_comment_line.match(l) or pat_comment_box.match(l): continue - raise ParseError(lr, 'bad line in node description') + raise ParseError(lr, "bad line in node description") for k in kinds: if k not in nodes: @@ -467,51 +468,50 @@ def gen_choices(choices): is_first = True for c in choices: if is_first: - print ' ', - print 'when', + print " ", + print "when", else: print - print ' ', - print ' |', + print " ", + print " |", print prefix_name + c, is_first = False - print '=>' + print "=>" def gen_get_format(formats, nodes, kinds): """Generate the Get_Format function.""" - print ' function Get_Format (Kind : ' + type_name + ') ' + \ - 'return Format_Type is' - print ' begin' - print ' case Kind is' + print " function Get_Format (Kind : " + type_name + ") " + "return Format_Type is" + print " begin" + print " case Kind is" for f in formats: choices = [k for k in kinds if nodes[k].format == f] gen_choices(choices) - print ' return Format_' + f + ';' - print ' end case;' - print ' end Get_Format;' + print " return Format_" + f + ";" + print " end case;" + print " end Get_Format;" def gen_subprg_header(decl): if len(decl) < 76: - print decl + ' is' + print decl + " is" else: print decl - print ' is' - print ' begin' + print " is" + print " begin" def gen_assert(func): - print ' pragma Assert (' + func.pname + ' /= Null_' + node_type + ');' - cond = '(Has_' + func.name + ' (Get_Kind (' + func.pname + ')),' + print " pragma Assert (" + func.pname + " /= Null_" + node_type + ");" + cond = "(Has_" + func.name + " (Get_Kind (" + func.pname + "))," msg = '"no field ' + func.name + '");' if len(cond) < 60: - print ' pragma Assert ' + cond - print ' ' + msg + print " pragma Assert " + cond + print " " + msg else: - print ' pragma Assert' - print ' ' + cond - print ' ' + msg + print " pragma Assert" + print " " + cond + print " " + msg def get_field_type(fields, f): @@ -525,70 +525,86 @@ def gen_get_set(func, nodes, fields): """Generate Get_XXX/Set_XXX subprograms for FUNC.""" rtype = func.rtype # If the function needs several fields, it must be user defined - if func.conv == 'grp': - print ' type %s_Conv is record' % rtype + if func.conv == "grp": + print " type %s_Conv is record" % rtype for f in func.fields: - print ' %s: %s;' % (f, get_field_type(fields, f)) - print ' end record;' - print ' pragma Pack (%s_Conv);' % rtype + print " %s: %s;" % (f, get_field_type(fields, f)) + print " end record;" + print " pragma Pack (%s_Conv);" % rtype print " pragma Assert (%s_Conv'Size = %s'Size);" % (rtype, rtype) print else: f = func.fields[0] - g = 'Get_' + f + ' (' + func.pname + ')' + g = "Get_" + f + " (" + func.pname + ")" s = func.rname if func.conv: - if func.conv == 'uc': + if func.conv == "uc": field_type = get_field_type(fields, f) - g = field_type + '_To_' + rtype + ' (' + g + ')' - s = rtype + '_To_' + field_type + ' (' + s + ')' - elif func.conv == 'pos': - g = rtype + "'Val (" + g + ')' - s = rtype + "'Pos (" + s + ')' - - subprg = ' function Get_' + func.name + ' (' + func.pname \ - + ' : ' + func.ptype + ') return ' + rtype - if func.conv == 'grp': + g = field_type + "_To_" + rtype + " (" + g + ")" + s = rtype + "_To_" + field_type + " (" + s + ")" + elif func.conv == "pos": + g = rtype + "'Val (" + g + ")" + s = rtype + "'Pos (" + s + ")" + + subprg = ( + " function Get_" + + func.name + + " (" + + func.pname + + " : " + + func.ptype + + ") return " + + rtype + ) + if func.conv == "grp": print subprg - print ' is' - print ' function To_%s is new Ada.Unchecked_Conversion' % \ - func.rtype - print ' (%s_Conv, %s);' % (rtype, rtype) - print ' Conv : %s_Conv;' % rtype - print ' begin' + print " is" + print " function To_%s is new Ada.Unchecked_Conversion" % func.rtype + print " (%s_Conv, %s);" % (rtype, rtype) + print " Conv : %s_Conv;" % rtype + print " begin" else: gen_subprg_header(subprg) gen_assert(func) - if func.conv == 'grp': + if func.conv == "grp": for f in func.fields: - print ' Conv.%s := Get_%s (%s);' % (f, f, func.pname) - g = 'To_%s (Conv)' % rtype - print ' return ' + g + ';' - print ' end Get_' + func.name + ';' + print " Conv.%s := Get_%s (%s);" % (f, f, func.pname) + g = "To_%s (Conv)" % rtype + print " return " + g + ";" + print " end Get_" + func.name + ";" print - subprg = ' procedure Set_' + func.name + ' (' \ - + func.pname + ' : ' + func.ptype + '; ' \ - + func.rname + ' : ' + func.rtype + ')' - if func.conv == 'grp': + subprg = ( + " procedure Set_" + + func.name + + " (" + + func.pname + + " : " + + func.ptype + + "; " + + func.rname + + " : " + + func.rtype + + ")" + ) + if func.conv == "grp": print subprg - print ' is' - print ' function To_%s_Conv is new Ada.Unchecked_Conversion' % \ - func.rtype - print ' (%s, %s_Conv);' % (rtype, rtype) - print ' Conv : %s_Conv;' % rtype - print ' begin' + print " is" + print " function To_%s_Conv is new Ada.Unchecked_Conversion" % func.rtype + print " (%s, %s_Conv);" % (rtype, rtype) + print " Conv : %s_Conv;" % rtype + print " begin" else: gen_subprg_header(subprg) gen_assert(func) - if func.conv == 'grp': - print ' Conv := To_%s_Conv (%s);' % (rtype, func.rname) + if func.conv == "grp": + print " Conv := To_%s_Conv (%s);" % (rtype, func.rname) for f in func.fields: - print ' Set_%s (%s, Conv.%s);' % (f, func.pname, f) + print " Set_%s (%s, Conv.%s);" % (f, func.pname, f) else: - print ' Set_' + f + ' (' + func.pname + ', ' + s + ');' - print ' end Set_' + func.name + ';' + print " Set_" + f + " (" + func.pname + ", " + s + ");" + print " end Set_" + func.name + ";" print @@ -597,38 +613,38 @@ def funcs_of_node(n): def gen_has_func_spec(name, suff): - spec = ' function Has_' + name + ' (K : ' + type_name + ')' - ret = ' return Boolean' + suff + spec = " function Has_" + name + " (K : " + type_name + ")" + ret = " return Boolean" + suff if len(spec) < 60: print spec + ret else: print spec - print ' ' + ret + print " " + ret def do_disp_formats(): for fmt in fields: - print "Fields of Format_"+fmt + print "Fields of Format_" + fmt fld = fields[fmt] for k in fld: - print ' ' + k + ' (' + fld[k] + ')' + print " " + k + " (" + fld[k] + ")" def do_disp_kinds(): print "Kinds are:" for k in kinds: - print ' ' + prefix_name + k + print " " + prefix_name + k def do_disp_funcs(): print "Functions are:" for f in funcs: - s = '{0} ({1}: {2}'.format(f.name, f.field, f.rtype) + s = "{0} ({1}: {2}".format(f.name, f.field, f.rtype) if f.acc: - s += ' acc:' + f.acc + s += " acc:" + f.acc if f.conv: - s += ' conv:' + f.conv - s += ')' + s += " conv:" + f.conv + s += ")" print s @@ -638,16 +654,16 @@ def do_disp_types(): for f in funcs: s |= set([f.rtype]) for t in sorted(s): - print ' ' + t + print " " + t def do_disp_nodes(): for k in kinds: v = nodes[k] - print prefix_name + k + ' (' + v.format + ')' + print prefix_name + k + " (" + v.format + ")" flds = [fk for fk, fv in v.fields.items() if fv] for fk in sorted(flds): - print ' ' + fk + ': ' + v.fields[fk].name + print " " + fk + ": " + v.fields[fk].name def do_get_format(): @@ -659,12 +675,12 @@ def do_body(): while True: l = lr.get().rstrip() print l - if l == ' -- Subprograms': + if l == " -- Subprograms": gen_get_format(formats, nodes, kinds) print for f in funcs: gen_get_set(f, nodes, fields) - if l[0:3] == 'end': + if l[0:3] == "end": break @@ -681,7 +697,7 @@ def get_attributes(): if f.acc: s |= set([f.acc]) res = [t for t in sorted(s)] - res.insert(0, 'None') + res.insert(0, "None") return res @@ -689,34 +705,32 @@ def gen_enum(prefix, vals): last = None for v in vals: if last: - print last + ',' + print last + "," last = prefix + v print last def do_meta_specs(): - lr = linereader(meta_base_file + '.ads.in') + lr = linereader(meta_base_file + ".ads.in") types = get_types() while True: l = lr.get().rstrip() - if l == ' -- TYPES': - gen_enum(' Type_', types) - elif l == ' -- FIELDS': - gen_enum(' Field_', [f.name for f in funcs]) - elif l == ' -- ATTRS': - gen_enum(' Attr_', get_attributes()) - elif l == ' -- FUNCS': + if l == " -- TYPES": + gen_enum(" Type_", types) + elif l == " -- FIELDS": + gen_enum(" Field_", [f.name for f in funcs]) + elif l == " -- ATTRS": + gen_enum(" Attr_", get_attributes()) + elif l == " -- FUNCS": for t in types: - print ' function Get_' + t - print ' (N : ' + node_type + '; F : Fields_Enum) return '\ - + t + ';' - print ' procedure Set_' + t - print ' (N : ' + node_type + '; F : Fields_Enum; V: ' \ - + t + ');' + print " function Get_" + t + print " (N : " + node_type + "; F : Fields_Enum) return " + t + ";" + print " procedure Set_" + t + print " (N : " + node_type + "; F : Fields_Enum; V: " + t + ");" print for f in funcs: - gen_has_func_spec(f.name, ';') - elif l[0:3] == 'end': + gen_has_func_spec(f.name, ";") + elif l[0:3] == "end": print l break else: @@ -724,68 +738,71 @@ def do_meta_specs(): def do_meta_body(): - lr = linereader(meta_base_file + '.adb.in') + lr = linereader(meta_base_file + ".adb.in") while True: l = lr.get().rstrip() - if l == ' -- FIELDS_TYPE': + if l == " -- FIELDS_TYPE": last = None for f in funcs: if last: - print last + ',' - last = ' Field_' + f.name + ' => Type_' + f.rtype + print last + "," + last = " Field_" + f.name + " => Type_" + f.rtype print last - elif l == ' -- FIELD_IMAGE': + elif l == " -- FIELD_IMAGE": for f in funcs: - print ' when Field_' + f.name + ' =>' + print " when Field_" + f.name + " =>" print ' return "' + f.name.lower() + '";' - elif l == ' -- IIR_IMAGE': + elif l == " -- IIR_IMAGE": for k in kinds: - print ' when ' + prefix_name + k + ' =>' + print " when " + prefix_name + k + " =>" print ' return "' + k.lower() + '";' - elif l == ' -- FIELD_ATTRIBUTE': + elif l == " -- FIELD_ATTRIBUTE": for f in funcs: - print ' when Field_' + f.name + ' =>' + print " when Field_" + f.name + " =>" if f.acc: attr = f.acc else: - attr = 'None' - print ' return Attr_' + attr + ';' - elif l == ' -- FIELDS_ARRAY': + attr = "None" + print " return Attr_" + attr + ";" + elif l == " -- FIELDS_ARRAY": last = None - nodes_types = [node_type, - node_type + '_List', node_type + '_Flist'] + nodes_types = [node_type, node_type + "_List", node_type + "_Flist"] for k in kinds: v = nodes[k] if last: - print last + ',' + print last + "," last = None - print ' -- ' + prefix_name + k + print " -- " + prefix_name + k # Get list of physical fields for V, in some order. if flag_keep_order: flds = v.order else: # First non Iir and no Iir_List. - flds = sorted([fk for fk, fv in v.fields.items() - if fv and fv.rtype not in nodes_types]) + flds = sorted( + [ + fk + for fk, fv in v.fields.items() + if fv and fv.rtype not in nodes_types + ] + ) # Then Iir and Iir_List in order of appearance - flds += (fv for fv in v.order - if v.fields[fv].rtype in nodes_types) + flds += (fv for fv in v.order if v.fields[fv].rtype in nodes_types) # Print the corresponding node field, but remove duplicate due # to 'grp'. fldsn = [] for fk in flds: if last: - print last + ',' + print last + "," # Remove duplicate fn = v.fields[fk].name if fn not in fldsn: - last = ' Field_' + fn + last = " Field_" + fn fldsn.append(fn) else: last = None if last: print last - elif l == ' -- FIELDS_ARRAY_POS': + elif l == " -- FIELDS_ARRAY_POS": pos = -1 last = None for k in kinds: @@ -794,117 +811,140 @@ def do_meta_body(): flds = set([fv.name for fk, fv in v.fields.items() if fv]) pos += len(flds) if last: - print last + ',' - last = ' ' + prefix_name + k + ' => {}'.format(pos) + print last + "," + last = " " + prefix_name + k + " => {}".format(pos) print last - elif l == ' -- FUNCS_BODY': + elif l == " -- FUNCS_BODY": # Build list of types s = set([]) for f in funcs: s |= set([f.rtype]) types = [t for t in sorted(s)] for t in types: - print ' function Get_' + t - print ' (N : ' + node_type + '; F : Fields_Enum) return '\ - + t + ' is' - print ' begin' - print ' pragma Assert (Fields_Type (F) = Type_' + t + ');' - print ' case F is' + print " function Get_" + t + print " (N : " + node_type + "; F : Fields_Enum) return " + t + " is" + print " begin" + print " pragma Assert (Fields_Type (F) = Type_" + t + ");" + print " case F is" for f in funcs: if f.rtype == t: - print ' when Field_' + f.name + ' =>' - print ' return Get_' + f.name + ' (N);' - print ' when others =>' - print ' raise Internal_Error;' - print ' end case;' - print ' end Get_' + t + ';' + print " when Field_" + f.name + " =>" + print " return Get_" + f.name + " (N);" + print " when others =>" + print " raise Internal_Error;" + print " end case;" + print " end Get_" + t + ";" print - print ' procedure Set_' + t - print ' (N : ' + node_type + '; F : Fields_Enum; V: ' \ - + t + ') is' - print ' begin' - print ' pragma Assert (Fields_Type (F) = Type_' + t + ');' - print ' case F is' + print " procedure Set_" + t + print " (N : " + node_type + "; F : Fields_Enum; V: " + t + ") is" + print " begin" + print " pragma Assert (Fields_Type (F) = Type_" + t + ");" + print " case F is" for f in funcs: if f.rtype == t: - print ' when Field_' + f.name + ' =>' - print ' Set_' + f.name + ' (N, V);' - print ' when others =>' - print ' raise Internal_Error;' - print ' end case;' - print ' end Set_' + t + ';' + print " when Field_" + f.name + " =>" + print " Set_" + f.name + " (N, V);" + print " when others =>" + print " raise Internal_Error;" + print " end case;" + print " end Set_" + t + ";" print for f in funcs: - gen_has_func_spec(f.name, ' is') + gen_has_func_spec(f.name, " is") choices = [k for k in kinds if f.name in nodes[k].attrs] if len(choices) == 0: - print ' pragma Unreferenced (K);' - print ' begin' + print " pragma Unreferenced (K);" + print " begin" if len(choices) == 0: - print ' return False;' + print " return False;" elif len(choices) == 1: - print ' return K = ' + prefix_name + choices[0] + ';' + print " return K = " + prefix_name + choices[0] + ";" else: - print ' case K is' + print " case K is" gen_choices(choices) - print ' return True;' - print ' when others =>' - print ' return False;' - print ' end case;' - print ' end Has_' + f.name + ';' + print " return True;" + print " when others =>" + print " return False;" + print " end case;" + print " end Has_" + f.name + ";" print - elif l[0:3] == 'end': + elif l[0:3] == "end": print l break else: print l -actions = {'disp-nodes': do_disp_nodes, - 'disp-kinds': do_disp_kinds, - 'disp-formats': do_disp_formats, - 'disp-funcs': do_disp_funcs, - 'disp-types': do_disp_types, - 'get_format': do_get_format, - 'body': do_body, - 'meta_specs': do_meta_specs, - 'meta_body': do_meta_body} +actions = { + "disp-nodes": do_disp_nodes, + "disp-kinds": do_disp_kinds, + "disp-formats": do_disp_formats, + "disp-funcs": do_disp_funcs, + "disp-types": do_disp_types, + "get_format": do_get_format, + "body": do_body, + "meta_specs": do_meta_specs, + "meta_body": do_meta_body, +} def main(): - parser = argparse.ArgumentParser(description='Meta-grammar processor') - parser.add_argument('action', choices=actions.keys(), - default='disp-nodes') - parser.add_argument('--field-file', dest='field_file', - default='nodes.ads', - help='specify file which defines fields') - parser.add_argument('--kind-file', dest='kind_file', - default='iirs.ads', - help='specify file which defines nodes kind') - parser.add_argument('--node-file', dest='node_file', - default='iirs.ads', - help='specify file which defines nodes and methods') - parser.add_argument('--template-file', dest='template_file', - default='iirs.adb.in', - help='specify template body file') - parser.add_argument('--meta-basename', dest='meta_basename', - default='nodes_meta', - help='specify base name of meta files') - parser.add_argument('--kind-type', dest='kind_type', - default='Iir_Kind', - help='name of kind type') - parser.add_argument('--kind-prefix', dest='kind_prefix', - default='Iir_Kind_', - help='prefix for kind literals') - parser.add_argument('--kind-range-prefix', dest='kind_range_prefix', - default='Iir_Kinds_', - help='prefix for kind subtype (range)') - parser.add_argument('--node-type', dest='node_type', - default='Iir', - help='name of the node type') - parser.add_argument('--keep-order', dest='flag_keep_order', - action='store_true', - help='keep field order of nodes') + parser = argparse.ArgumentParser(description="Meta-grammar processor") + parser.add_argument("action", choices=actions.keys(), default="disp-nodes") + parser.add_argument( + "--field-file", + dest="field_file", + default="nodes.ads", + help="specify file which defines fields", + ) + parser.add_argument( + "--kind-file", + dest="kind_file", + default="iirs.ads", + help="specify file which defines nodes kind", + ) + parser.add_argument( + "--node-file", + dest="node_file", + default="iirs.ads", + help="specify file which defines nodes and methods", + ) + parser.add_argument( + "--template-file", + dest="template_file", + default="iirs.adb.in", + help="specify template body file", + ) + parser.add_argument( + "--meta-basename", + dest="meta_basename", + default="nodes_meta", + help="specify base name of meta files", + ) + parser.add_argument( + "--kind-type", dest="kind_type", default="Iir_Kind", help="name of kind type" + ) + parser.add_argument( + "--kind-prefix", + dest="kind_prefix", + default="Iir_Kind_", + help="prefix for kind literals", + ) + parser.add_argument( + "--kind-range-prefix", + dest="kind_range_prefix", + default="Iir_Kinds_", + help="prefix for kind subtype (range)", + ) + parser.add_argument( + "--node-type", dest="node_type", default="Iir", help="name of the node type" + ) + parser.add_argument( + "--keep-order", + dest="flag_keep_order", + action="store_true", + help="keep field order of nodes", + ) parser.set_defaults(flag_keep_order=False) args = parser.parse_args() @@ -934,8 +974,7 @@ def main(): except ParseError as e: print >> sys.stderr, e - print >> sys.stderr, \ - "in {0}:{1}:{2}".format(e.lr.filename, e.lr.lineno, e.lr.l) + print >> sys.stderr, "in {0}:{1}:{2}".format(e.lr.filename, e.lr.lineno, e.lr.l) sys.exit(1) f = actions.get(args.action, None) @@ -945,5 +984,5 @@ def main(): f() -if __name__ == '__main__': +if __name__ == "__main__": main() |