scripts: move 'pyGHDL/xtools' to 'scripts', update Makefiles and docs accordingly

1 files changed, 988 insertions, 0 deletions

diff --git a/scripts/pnodes.py b/scripts/pnodes.py
new file mode 100755
index 000000000..793c1c712
--- /dev/null
+++ b/scripts/pnodes.py
@@ -0,0 +1,988 @@
+#!/usr/bin/env python
+
+import re
+import sys
+import argparse
+
+field_file = "nodes.ads"
+kind_file = "iirs.ads"
+node_file = "iirs.ads"
+template_file = "iirs.adb.in"
+meta_base_file = "nodes_meta"
+prefix_name = "Iir_Kind_"
+prefix_range_name = "Iir_Kinds_"
+type_name = "Iir_Kind"
+node_type = "Iir"
+conversions = ["uc", "pos", "grp"]
+
+
+class FuncDesc:
+    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
+        self.acc = acc  # access: Chain, Chain_Next, Ref, Of_Ref, Maybe_Ref,
+        #                 Forward_Ref, Maybe_Forward_Ref
+        self.pname = pname  # Parameter mame
+        self.ptype = ptype  # Parameter type
+        self.rname = rname  # value name (for procedure)
+        self.rtype = rtype  # value type
+
+
+class NodeDesc:
+    def __init__(self, name, format, fields, attrs):
+        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.
+
+
+class line:
+    def __init__(self, string, no):
+        self.l = string
+        self.n = no
+
+
+class EndOfFile(Exception):
+    def __init__(self, filename):
+        self.filename = filename
+
+    def __str__(self):
+        return "end of file " + self.filename
+
+
+class linereader:
+    def __init__(self, filename):
+        self.filename = filename
+        self.f = open(filename)
+        self.lineno = 0
+        self.l = ""
+
+    def get(self):
+        self.l = self.f.readline()
+        if not self.l:
+            raise EndOfFile(self.filename)
+        self.lineno = self.lineno + 1
+        return self.l
+
+
+class ParseError(Exception):
+    def __init__(self, lr, msg):
+        self.lr = lr
+        self.msg = msg
+
+    def __str__(self):
+        return "Error: " + self.msg
+        return (
+            "Parse error at " + self.lr.filname + ":" + self.lr.lineno + ": " + self.msg
+        )
+
+
+# Return fields description.
+# This is a dictionary.  The keys represent the possible format of a node.
+# The values are dictionnaries representing fields.  Keys are fields name, and
+# values are fields type.
+def read_fields(file):
+    fields = {}
+    formats = []
+    lr = linereader(file)
+
+    #  Search for 'type Format_Type is'
+    while lr.get() != "   type Format_Type is\n":
+        pass
+
+    # Skip '('
+    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":
+        m = pat_field_name.match(l)
+        if m is None:
+            print l
+            raise "bad literal within Format_Type"
+        name = m.group(1)
+        formats.append(name)
+        fields[name] = {}
+        l = lr.get()
+
+    # Read fields
+    l = lr.get()
+    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":
+        l = lr.get()
+    format_name = "Common"
+    nbr_formats = 0
+
+    while True:
+        # 1) Read field description
+        l = lr.get()
+        desc = common_desc.copy()
+        while True:
+            m = pat_field_desc.match(l)
+            if m is None:
+                break
+            desc[m.group(1)] = m.group(2)
+            l = lr.get()
+            # print 'For: ' + format_name + ': ' + m.group(1)
+
+        # 2) Disp
+        if format_name == "Common":
+            common_desc = desc
+        else:
+            fields[format_name] = desc
+
+        # 3) Read next format
+        if l == "\n":
+            if nbr_formats == len(fields):
+                break
+            else:
+                l = lr.get()
+
+        # One for a format
+        m = pat_fields.match(l)
+        if m is not None:
+            format_name = m.group(1)
+            if format_name not in fields:
+                raise ParseError(lr, "Format " + format_name + " is unknown")
+            nbr_formats = nbr_formats + 1
+        else:
+            raise ParseError(lr, "unhandled format line")
+
+    return (formats, fields)
+
+
+# Read kinds and kinds ranges.
+def read_kinds(filename):
+    lr = linereader(filename)
+    kinds = []
+    #  Search for 'type Iir_Kind is'
+    while lr.get() != "   type " + type_name + " is\n":
+        pass
+    # Skip '('
+    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")
+    while True:
+        l = lr.get()
+        if l == "     );\n":
+            break
+        m = pat_node.match(l)
+        if m:
+            kinds.append(m.group(1))
+            continue
+        m = pat_comment.match(l)
+        if not m:
+            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")
+    kinds_ranges = {}
+    while True:
+        l = lr.get()
+        # Start of methods is also end of subtypes.
+        if l == "   -- General methods.\n":
+            break
+        # Found a subtype.
+        m = pat_subtype.match(l)
+        if m:
+            # 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) :]
+            l = lr.get()
+            mf = pat_first.match(l)
+            if not mf:
+                raise ParseError(lr, "badly formated first bound of subtype")
+            first = kinds.index(mf.group(1))
+            idx = first
+            has_middle = None
+            # Read until last bound
+            while True:
+                l = lr.get()
+                ml = pat_middle.match(l)
+                if ml:
+                    # Check element in the middle
+                    n = ml.group(1)
+                    if n not in kinds:
+                        raise ParseError(lr, "unknown kind " + n + " in subtype")
+                    if kinds.index(n) != idx + 1:
+                        raise ParseError(
+                            lr, "missing " + kinds[idx + 1] + " in subtype"
+                        )
+                    has_middle = True
+                    idx = idx + 1
+                else:
+                    # Check last bound
+                    ml = pat_last.match(l)
+                    if ml:
+                        last = kinds.index(ml.group(1))
+                        if last != idx + 1 and has_middle:
+                            raise ParseError(
+                                lr, "missing " + kinds[idx] + " in subtype"
+                            )
+                        break
+                    raise ParseError(lr, "unhandled line in subtype")
+            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")
+    while True:
+        l = lr.get()
+        # Start of methods
+        if l == "   -- General methods.\n":
+            break
+    while True:
+        l = lr.get()
+        if pat_end.match(l):
+            break
+        m = pat_field.match(l)
+        if m:
+            fields = m.group(1).split(",")
+            # Extract access modifier
+            acc = m.group(2)
+            if acc:
+                acc = acc.strip()
+            # Extract conversion
+            conv = m.group(3)
+            if conv:
+                mc = pat_conv.match(conv)
+                if not mc:
+                    raise ParseError(lr, "conversion ill formed")
+                conv = mc.group(1)
+                if conv not in conversions:
+                    raise ParseError(lr, "unknown conversion " + conv)
+            else:
+                conv = None
+            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")
+            # Read procedure
+            l = lr.get()
+            mp = pat_proc.match(l)
+            if not mp:
+                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")
+            if mf.group(2) != mp.group(2):
+                raise ParseError(lr, "parameter name mismatch with function")
+            if mf.group(3) != mp.group(3):
+                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),
+                )
+            )
+
+    return funcs
+
+
+# Read description for one node
+# LR is the line reader.  NAMES is the list of (node name, format)
+#  (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")
+
+    # Create nodes
+    cur_nodes = []
+    for (nm, fmt) in names:
+        if fmt not in fields:
+            raise ParseError(lr, 'unknown format "{}"'.format(fmt))
+        n = NodeDesc(nm, fmt, {x: None for x in fields[fmt]}, {})
+        nodes[nm] = n
+        cur_nodes.append(n)
+
+    # Skip comments
+    l = lr.l
+    while pat_comment.match(l):
+        l = lr.get()
+
+    # Look for fields
+    while l != "\n":
+        # Skip comments
+        while pat_comment.match(l):
+            l = lr.get()
+
+        # Handle 'Only ...'
+        m = pat_only.match(l)
+        if m:
+            only_nodes = []
+            while True:
+                name = m.group(1)
+                n = nodes.get(name, None)
+                if n is None:
+                    raise ParseError(lr, "node is unknown")
+                if n not in cur_nodes:
+                    raise ParseError(lr, "node not currently described")
+                only_nodes.append(n)
+                l = lr.get()
+                m = pat_only.match(l)
+                if not m:
+                    break
+        else:
+            # By default a field applies to all nodes.
+            only_nodes = cur_nodes
+
+        # Skip comments
+        while pat_comment.match(l):
+            l = lr.get()
+
+        # Handle field: '--  Get/Set_FUNC (Alias? FIELD)'
+        m = pat_field.match(l)
+        if not m:
+            if pat_only_bad.match(l):
+                raise ParseError(lr, "misleading 'Only for' comment")
+            else:
+                raise ParseError(lr, "bad line in node description")
+
+        func = m.group(1)
+        alias = m.group(2)
+        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")
+        func = funcs_dict[func]
+        if func.fields != fields:
+            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")
+            if not alias:
+                for f in fields:
+                    if c.fields[f]:
+                        raise ParseError(lr, "field " + f + " already used")
+                    c.fields[f] = func
+                    c.order.append(f)
+            c.attrs[func.name] = func
+
+        l = lr.get()
+
+
+def read_nodes(filename, kinds, kinds_ranges, fields, funcs):
+    """Read description for all nodes."""
+    lr = linereader(filename)
+    funcs_dict = {x.name: x for x in funcs}
+    nodes = {}
+
+    # Skip until start
+    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")
+    while True:
+        l = lr.get()
+        if l == "   -- End of " + type_name + ".\n":
+            break
+        if l == "\n":
+            continue
+        m = pat_decl.match(l)
+        if m:
+            # List of nodes being described by the current description.
+            names = []
+
+            # Declaration of the first node
+            while True:
+                name = m.group(1)
+                if name not in kinds:
+                    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))
+                # There might be several nodes described at once.
+                l = lr.get()
+                m = pat_decl.match(l)
+                if not m:
+                    break
+            read_nodes_fields(lr, names, fields, nodes, funcs_dict)
+            continue
+        m = pat_decls.match(l)
+        if m:
+            # List of nodes being described by the current description.
+            name = m.group(1)
+            fmt = m.group(2)
+            names = [(k, fmt) for k in kinds_ranges[name]]
+            l = lr.get()
+            read_nodes_fields(lr, names, fields, nodes, funcs_dict)
+            continue
+        if pat_comment_line.match(l) or pat_comment_box.match(l):
+            continue
+        raise ParseError(lr, "bad line in node description")
+
+    for k in kinds:
+        if k not in nodes:
+            raise ParseError(lr, 'no description for "{}"'.format(k))
+    return nodes
+
+
+def gen_choices(choices):
+    """Generate a choice 'when A | B ... Z =>' using elements of CHOICES."""
+    is_first = True
+    for c in choices:
+        if is_first:
+            print "        ",
+            print "when",
+        else:
+            print
+            print "        ",
+            print "  |",
+        print prefix_name + c,
+        is_first = False
+    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"
+    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;"
+
+
+def gen_subprg_header(decl):
+    if len(decl) < 76:
+        print decl + " is"
+    else:
+        print decl
+        print "   is"
+    print "   begin"
+
+
+def gen_assert(func):
+    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
+    else:
+        print "      pragma Assert"
+        print "         " + cond
+        print "          " + msg
+
+
+def get_field_type(fields, f):
+    for fld in fields.values():
+        if f in fld:
+            return fld[f]
+    return None
+
+
+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
+        for f in func.fields:
+            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 + ")"
+
+    s = func.rname
+    if func.conv:
+        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":
+        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"
+    else:
+        gen_subprg_header(subprg)
+    gen_assert(func)
+    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
+
+    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"
+    else:
+        gen_subprg_header(subprg)
+    gen_assert(func)
+    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)
+    else:
+        print "      Set_" + f + " (" + func.pname + ", " + s + ");"
+    print "   end Set_" + func.name + ";"
+    print
+
+
+def funcs_of_node(n):
+    return sorted([fv.name for fv in n.fields.values() if fv])
+
+
+def gen_has_func_spec(name, suff):
+    spec = "   function Has_" + name + " (K : " + type_name + ")"
+    ret = " return Boolean" + suff
+    if len(spec) < 60:
+        print spec + ret
+    else:
+        print spec
+        print "     " + ret
+
+
+def do_disp_formats():
+    for fmt in fields:
+        print "Fields of Format_" + fmt
+        fld = fields[fmt]
+        for k in fld:
+            print "  " + k + " (" + fld[k] + ")"
+
+
+def do_disp_kinds():
+    print "Kinds are:"
+    for k in kinds:
+        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)
+        if f.acc:
+            s += " acc:" + f.acc
+        if f.conv:
+            s += " conv:" + f.conv
+        s += ")"
+        print s
+
+
+def do_disp_types():
+    print "Types are:"
+    s = set([])
+    for f in funcs:
+        s |= set([f.rtype])
+    for t in sorted(s):
+        print "  " + t
+
+
+def do_disp_nodes():
+    for k in kinds:
+        v = nodes[k]
+        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
+
+
+def do_get_format():
+    gen_get_format(formats, nodes)
+
+
+def do_body():
+    lr = linereader(template_file)
+    while True:
+        l = lr.get().rstrip()
+        print l
+        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":
+            break
+
+
+def get_types():
+    s = set([])
+    for f in funcs:
+        s |= set([f.rtype])
+    return [t for t in sorted(s)]
+
+
+def get_attributes():
+    s = set([])
+    for f in funcs:
+        if f.acc:
+            s |= set([f.acc])
+    res = [t for t in sorted(s)]
+    res.insert(0, "None")
+    return res
+
+
+def gen_enum(prefix, vals):
+    last = None
+    for v in vals:
+        if last:
+            print last + ","
+        last = prefix + v
+    print last
+
+
+def do_meta_specs():
+    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":
+            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
+            for f in funcs:
+                gen_has_func_spec(f.name, ";")
+        elif l[0:3] == "end":
+            print l
+            break
+        else:
+            print l
+
+
+def do_meta_body():
+    lr = linereader(meta_base_file + ".adb.in")
+    while True:
+        l = lr.get().rstrip()
+        if l == "      --  FIELDS_TYPE":
+            last = None
+            for f in funcs:
+                if last:
+                    print last + ","
+                last = "      Field_" + f.name + " => Type_" + f.rtype
+            print last
+        elif l == "         --  FIELD_IMAGE":
+            for f in funcs:
+                print "         when Field_" + f.name + " =>"
+                print '            return "' + f.name.lower() + '";'
+        elif l == "         --  IIR_IMAGE":
+            for k in kinds:
+                print "         when " + prefix_name + k + " =>"
+                print '            return "' + k.lower() + '";'
+        elif l == "         --  FIELD_ATTRIBUTE":
+            for f in funcs:
+                print "         when Field_" + f.name + " =>"
+                if f.acc:
+                    attr = f.acc
+                else:
+                    attr = "None"
+                print "            return Attr_" + attr + ";"
+        elif l == "      --  FIELDS_ARRAY":
+            last = None
+            nodes_types = [node_type, node_type + "_List", node_type + "_Flist"]
+            for k in kinds:
+                v = nodes[k]
+                if last:
+                    print last + ","
+                last = None
+                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
+                        ]
+                    )
+                    # Then Iir and Iir_List in order of appearance
+                    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 + ","
+                    # Remove duplicate
+                    fn = v.fields[fk].name
+                    if fn not in fldsn:
+                        last = "      Field_" + fn
+                        fldsn.append(fn)
+                    else:
+                        last = None
+            if last:
+                print last
+        elif l == "      --  FIELDS_ARRAY_POS":
+            pos = -1
+            last = None
+            for k in kinds:
+                v = nodes[k]
+                # Create a set to remove duplicate for 'grp'.
+                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
+        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"
+                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
+                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
+            for f in funcs:
+                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"
+                if len(choices) == 0:
+                    print "      return False;"
+                elif len(choices) == 1:
+                    print "      return K = " + prefix_name + choices[0] + ";"
+                else:
+                    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
+        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,
+}
+
+
+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.set_defaults(flag_keep_order=False)
+    args = parser.parse_args()
+
+    # At some point, it would be simpler to create a class...
+    global formats, fields, nodes, kinds, kinds_ranges, funcs
+
+    global type_name, prefix_name, template_file, node_type, meta_base_file
+    global prefix_range_name, flag_keep_order, kind_file
+
+    type_name = args.kind_type
+    prefix_name = args.kind_prefix
+    prefix_range_name = args.kind_range_prefix
+    template_file = args.template_file
+    node_type = args.node_type
+    meta_base_file = args.meta_basename
+    flag_keep_order = args.flag_keep_order
+
+    field_file = args.field_file
+    kind_file = args.kind_file
+    node_file = args.node_file
+
+    try:
+        (formats, fields) = read_fields(field_file)
+        (kinds, kinds_ranges) = read_kinds(kind_file)
+        funcs = read_methods(node_file)
+        nodes = read_nodes(node_file, kinds, kinds_ranges, fields, funcs)
+
+    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)
+        sys.exit(1)
+
+    f = actions.get(args.action, None)
+    if not f:
+        print >> sys.stderr, "Action {0} is unknown".format(args.action)
+        sys.exit(1)
+    f()
+
+
+if __name__ == "__main__":
+    main()