Jython

Revision: 6925
          http://jython.svn.sourceforge.net/jython/?rev=6925&view=rev
Author:   fwierzbicki
Date:     2009-10-28 16:01:21 +0000 (Wed, 28 Oct 2009)

Log Message:
-----------
Bringing in pypy's ast.py generator to see if I can munge it to work for
Jython.

Added Paths:
-----------
    trunk/jython/ast/asdl_py.py

Added: trunk/jython/ast/asdl_py.py
===================================================================
--- trunk/jython/ast/asdl_py.py	                        (rev 0)
+++ trunk/jython/ast/asdl_py.py	2009-10-28 16:01:21 UTC (rev 6925)
@@ -0,0 +1,642 @@
+"""
+Generate AST node definitions from an ASDL description.
+"""
+
+import sys
+import os
+import asdl
+
+
+class ASDLVisitor(asdl.VisitorBase):
+
+    def __init__(self, stream, data):
+        super(ASDLVisitor, self).__init__()
+        self.stream = stream
+        self.data = data
+
+    def visitModule(self, mod, *args):
+        for df in mod.dfns:
+            self.visit(df, *args)
+
+    def visitSum(self, sum, *args):
+        for tp in sum.types:
+            self.visit(tp, *args)
+
+    def visitType(self, tp, *args):
+        self.visit(tp.value, *args)
+
+    def visitProduct(self, prod, *args):
+        for field in prod.fields:
+            self.visit(field, *args)
+
+    def visitConstructor(self, cons, *args):
+        for field in cons.fields:
+            self.visit(field, *args)
+
+    def visitField(self, field):
+        pass
+
+    def emit(self, line, level=0):
+        indent = "    "*level
+        self.stream.write(indent + line + "\n")
+
+
+def is_simple_sum(sum):
+    assert isinstance(sum, asdl.Sum)
+    for constructor in sum.types:
+        if constructor.fields:
+            return False
+    return True
+
+
+class ASTNodeVisitor(ASDLVisitor):
+
+    def visitType(self, tp):
+        self.visit(tp.value, tp.name)
+
+    def visitSum(self, sum, base):
+        if is_simple_sum(sum):
+            self.emit("class %s(AST):" % (base,))
+            self.emit("")
+            self.emit("def to_simple_int(self, space):", 1)
+            self.emit("w_msg = space.wrap(\"not a valid %s\")" % (base,), 2)
+            self.emit("raise OperationError(space.w_TypeError, w_msg)", 2)
+            self.emit("")
+            for i, cons in enumerate(sum.types):
+                self.emit("class _%s(%s):" % (cons.name, base))
+                self.emit("")
+                self.emit("def to_simple_int(self, space):", 1)
+                self.emit("return %i" % (i + 1,), 2)
+                self.emit("")
+            for i, cons in enumerate(sum.types):
+                self.emit("%s = %i" % (cons.name, i + 1))
+            self.emit("")
+            self.emit("%s_to_class = [" % (base,))
+            for cons in sum.types:
+                self.emit("_%s," % (cons.name,), 1)
+            self.emit("]")
+            self.emit("")
+        else:
+            self.emit("class %s(AST):" % (base,))
+            self.emit("")
+            slots = ", ".join(repr(attr.name.value) for attr in sum.attributes)
+            self.emit("__slots__ = (%s)" % (slots,), 1)
+            self.emit("")
+            if sum.attributes:
+                args = ", ".join(attr.name.value for attr in sum.attributes)
+                self.emit("def __init__(self, %s):" % (args,), 1)
+                for attr in sum.attributes:
+                    self.visit(attr)
+                self.emit("")
+            for cons in sum.types:
+                self.visit(cons, base, sum.attributes)
+                self.emit("")
+
+    def visitProduct(self, product, name):
+        self.emit("class %s(AST):" % (name,))
+        self.emit("")
+        slots = self.make_slots(product.fields)
+        self.emit("__slots__ = (%s)" % (slots,), 1)
+        self.emit("")
+        self.make_constructor(product.fields, product)
+        self.emit("")
+        self.emit("def walkabout(self, visitor):", 1)
+        self.emit("visitor.visit_%s(self)" % (name,), 2)
+        self.emit("")
+        self.make_var_syncer(product.fields, product, name)
+
+    def make_slots(self, fields):
+        slots = []
+        for field in fields:
+            name = repr(field.name.value)
+            slots.append(name)
+            if field.seq:
+                slots.append("'w_%s'" % (field.name,))
+        return ", ".join(slots)
+
+    def make_var_syncer(self, fields, node, name):
+        self.emit("def sync_app_attrs(self, space):", 1)
+        config = (self.data.optional_masks[node],
+                  self.data.required_masks[node])
+        self.emit("if (self.initialization_state & ~%i) ^ %i:" % config, 2)
+        names = []
+        for field in fields:
+            if field.opt:
+                names.append("None")
+            else:
+                names.append(repr(field.name.value))
+        sub = (", ".join(names), name.value)
+        self.emit("missing_field(space, self.initialization_state, [%s], %r)"
+                  % sub, 3)
+        self.emit("else:", 2)
+        # Fill in all the default fields.
+        doing_something = False
+        for field in fields:
+            if field.opt:
+                doing_something = True
+                flag = self.data.field_masks[field]
+                self.emit("if not self.initialization_state & %i:" % (flag,), 3)
+                default = "0" if field.type.value == "int" else "None"
+                self.emit("self.%s = %s" % (field.name, default), 4)
+        if not doing_something:
+            self.emit("pass", 3)
+        for attr in fields:
+            if attr.seq:
+                self.emit("w_list = self.w_%s" % (attr.name,), 2)
+                self.emit("if w_list is not None:", 2)
+                self.emit("list_w = space.viewiterable(w_list)", 3)
+                self.emit("if list_w:", 3)
+                unwrapper = get_unwrapper(attr.type.value, "w_obj",
+                                          self.data.simple_types)
+                config = (attr.name, unwrapper)
+                self.emit("self.%s = [%s for w_obj in list_w]" % config,
+                          4),
+                self.emit("else:", 3)
+                self.emit("self.%s = None" % (attr.name,), 4)
+                if attr.type.value not in asdl.builtin_types and \
+                        attr.type.value not in self.data.simple_types:
+                    self.emit("if self.%s is not None:" % (attr.name,), 2)
+                    self.emit("for node in self.%s:" % (attr.name,), 3)
+                    self.emit("node.sync_app_attrs(space)", 4)
+            elif attr.type.value not in asdl.builtin_types and \
+                    attr.type.value not in self.data.simple_types:
+                doing_something = True
+                level = 2
+                if attr.opt:
+                    self.emit("if self.%s:" % (attr.name,), 2)
+                    level += 1
+                self.emit("self.%s.sync_app_attrs(space)" % (attr.name,), level)
+        self.emit("")
+
+    def make_constructor(self, fields, node, extras=None, base=None):
+        if fields or extras:
+            arg_fields = fields + extras if extras else fields
+            args = ", ".join(str(field.name) for field in arg_fields)
+            self.emit("def __init__(self, %s):" % args, 1)
+            for field in fields:
+                self.visit(field)
+            if extras:
+                base_args = ", ".join(str(field.name) for field in extras)
+                self.emit("%s.__init__(self, %s)" % (base, base_args), 2)
+        else:
+            self.emit("def __init__(self):", 1)
+        have_everything = self.data.required_masks[node] | \
+            self.data.optional_masks[node]
+        self.emit("self.initialization_state = %i" % (have_everything,), 2)
+
+    def visitConstructor(self, cons, base, extra_attributes):
+        self.emit("class %s(%s):" % (cons.name, base))
+        self.emit("")
+        slots = self.make_slots(cons.fields)
+        self.emit("__slots__ = (%s)" % (slots,), 1)
+        self.emit("")
+        for field in self.data.cons_attributes[cons]:
+            subst = (field.name, self.data.field_masks[field])
+            self.emit("_%s_mask = %i" % subst, 1)
+        self.emit("")
+        self.make_constructor(cons.fields, cons, extra_attributes, base)
+        self.emit("")
+        self.emit("def walkabout(self, visitor):", 1)
+        self.emit("visitor.visit_%s(self)" % (cons.name,), 2)
+        self.emit("")
+        self.emit("def mutate_over(self, visitor):", 1)
+        for field in cons.fields:
+            if field.type.value not in asdl.builtin_types and \
+                    field.type.value not in self.data.prod_simple:
+                if field.opt or field.seq:
+                    level = 3
+                    self.emit("if self.%s:" % (field.name,), 2)
+                else:
+                    level = 2
+                if field.seq:
+                    sub = (field.name,)
+                    self.emit("visitor._mutate_sequence(self.%s)" % sub, level)
+                else:
+                    sub = (field.name, field.name)
+                    self.emit("self.%s = self.%s.mutate_over(visitor)" % sub,
+                              level)
+        self.emit("return visitor.visit_%s(self)" % (cons.name,), 2)
+        self.emit("")
+        self.make_var_syncer(cons.fields + self.data.cons_attributes[cons],
+                             cons, cons.name)
+
+    def visitField(self, field):
+        self.emit("self.%s = %s" % (field.name, field.name), 2)
+        if field.seq:
+            self.emit("self.w_%s = None" % (field.name,), 2)
+
+
+class ASTVisitorVisitor(ASDLVisitor):
+    """A meta visitor! :)"""
+
+    def visitModule(self, mod):
+        self.emit("class ASTVisitor(object):")
+        self.emit("")
+        self.emit("def visit_sequence(self, seq):", 1)
+        self.emit("for node in seq:", 2)
+        self.emit("node.walkabout(self)", 3)
+        self.emit("")
+        self.emit("def default_visitor(self, node):", 1)
+        self.emit("raise NodeVisitorNotImplemented", 2)
+        self.emit("")
+        self.emit("def _mutate_sequence(self, seq):", 1)
+        self.emit("for i in range(len(seq)):", 2)
+        self.emit("seq[i] = seq[i].mutate_over(self)", 3)
+        self.emit("")
+        super(ASTVisitorVisitor, self).visitModule(mod)
+        self.emit("")
+
+    def visitType(self, tp):
+        if not (isinstance(tp.value, asdl.Sum) and
+                is_simple_sum(tp.value)):
+            super(ASTVisitorVisitor, self).visitType(tp, tp.name)
+
+    def visitProduct(self, prod, name):
+        self.emit("def visit_%s(self, node):" % (name,), 1)
+        self.emit("return self.default_visitor(node)", 2)
+
+    def visitConstructor(self, cons, _):
+        self.emit("def visit_%s(self, node):" % (cons.name,), 1)
+        self.emit("return self.default_visitor(node)", 2)
+
+
+class GenericASTVisitorVisitor(ASDLVisitor):
+
+    def visitModule(self, mod):
+        self.emit("class GenericASTVisitor(ASTVisitor):")
+        self.emit("")
+        super(GenericASTVisitorVisitor, self).visitModule(mod)
+        self.emit("")
+
+    def visitType(self, tp):
+        if not (isinstance(tp.value, asdl.Sum) and
+                is_simple_sum(tp.value)):
+            super(GenericASTVisitorVisitor, self).visitType(tp, tp.name)
+
+    def visitProduct(self, prod, name):
+        self.make_visitor(name, prod.fields)
+
+    def visitConstructor(self, cons, _):
+        self.make_visitor(cons.name, cons.fields)
+
+    def make_visitor(self, name, fields):
+        self.emit("def visit_%s(self, node):" % (name,), 1)
+        have_body = False
+        for field in fields:
+            if self.visitField(field):
+                have_body = True
+        if not have_body:
+            self.emit("pass", 2)
+        self.emit("")
+
+    def visitField(self, field):
+        if field.type.value not in asdl.builtin_types and \
+                field.type.value not in self.data.simple_types:
+            if field.seq or field.opt:
+                self.emit("if node.%s:" % (field.name,), 2)
+                level = 3
+            else:
+                level = 2
+            if field.seq:
+                template = "self.visit_sequence(node.%s)"
+            else:
+                template = "node.%s.walkabout(self)"
+            self.emit(template % (field.name,), level)
+            return True
+        return False
+
+
+asdl_type_map = {
+    "int" : "int_w",
+    "identifier" : "str_w",
+    "bool" : "bool_w"
+}
+
+def get_unwrapper(tp, name, simple_types):
+    if tp in asdl.builtin_types:
+        return "space.%s(%s)" % (asdl_type_map[tp], name)
+    elif tp in simple_types:
+        return "space.interp_w(%s, %s).to_simple_int(space)" % (tp, name)
+    else:
+        return "space.interp_w(%s, %s)" % (tp, name)
+
+
+# CPython lets blank AST nodes (no constructor arguments) be created
+# and the attributes added later.  In CPython, it is implemented by
+# implementing applevel and c level AST as different structures and
+# copying between them.  This is hideous, so we use a slightly less
+# ugly hack in PyPy.  Each field has a bitmask which is set on the
+# initialization_state attribute when the field type is set.  When
+# sync_app_attrs() is called, it's a simple matter of removing the
+# optional field flags from initialization_state, and using XOR to
+# test if all the required fields have been set.
+class AppExposeVisitor(ASDLVisitor):
+
+    def visitType(self, tp):
+        super(AppExposeVisitor, self).visitType(tp, tp.name)
+
+    def visitSum(self, sum, name):
+        for field in sum.attributes:
+            self.make_property(field, name, True)
+        self.make_typedef(name, "AST", sum.attributes,
+                          fields_name="_attributes")
+        if not is_simple_sum(sum):
+            super(AppExposeVisitor, self).visitSum(sum, name)
+        else:
+            for cons in sum.types:
+                self.make_typedef("_" + cons.name.value, name, (), cons.name,
+                                  concrete=True)
+
+    def make_typedef(self, name, base, fields, display_name=None,
+                     fields_name="_fields", concrete=False, needs_init=False):
+        if display_name is None:
+            display_name = name
+        self.emit("%s.typedef = typedef.TypeDef(\"%s\"," % (name, display_name))
+        self.emit("%s.typedef," % (base,), 1)
+        comma_fields = ", ".join(repr(field.name.value) for field in fields)
+        self.emit("%s=_FieldsWrapper([%s])," % (fields_name, comma_fields), 1)
+        for field in fields:
+            getter = "%s_get_%s" % (name, field.name)
+            setter = "%s_set_%s" % (name, field.name)
+            config = (field.name, getter, setter, name)
+            self.emit("%s=typedef.GetSetProperty(%s, %s, cls=%s)," % config, 1)
+        # CPython lets you create instances of "abstract" AST nodes
+        # like ast.expr or even ast.AST.  This doesn't seem to useful
+        # and would be a pain to implement safely, so we don't allow
+        # it.
+        if concrete:
+            self.emit("__new__=interp2app(get_AST_new(%s))," % (name,), 1)
+            if needs_init:
+                self.emit("__init__=interp2app(%s_init)," % (name,), 1)
+        self.emit(")")
+        self.emit("%s.typedef.acceptable_as_base_class = False" % (name,))
+        self.emit("")
+
+    def make_init(self, name, fields):
+        comma_fields = ", ".join(repr(field.name.value) for field in fields)
+        config = (name, comma_fields)
+        self.emit("_%s_field_unroller = unrolling_iterable([%s])" % config)
+        self.emit("def %s_init(space, w_self, args):" % (name,))
+        self.emit("w_self = space.descr_self_interp_w(%s, w_self)" % (name,), 1)
+        for field in fields:
+            if field.seq:
+                self.emit("w_self.w_%s = None" % (field.name,), 1)
+        self.emit("args_w, kwargs_w = args.unpack()", 1)
+        self.emit("if args_w:", 1)
+        arity = len(fields)
+        if arity:
+            self.emit("if len(args_w) != %i:" % (arity,), 2)
+            self.emit("w_err = space.wrap(\"%s constructor takes 0 or %i " \
+                          "positional arguments\")" % (name, arity), 3)
+            self.emit("raise OperationError(space.w_TypeError, w_err)", 3)
+            self.emit("i = 0", 2)
+            self.emit("for field in _%s_field_unroller:" % (name,), 2)
+            self.emit("space.setattr(w_self, space.wrap(field), args_w[i])", 3)
+            self.emit("i += 1", 3)
+        else:
+            self.emit("w_err = space.wrap(\"%s constructor takes no " \
+                          " arguments\")" % (name,), 2)
+            self.emit("raise OperationError(space.w_TypeError, w_err)", 2)
+        self.emit("for field, w_value in kwargs_w.iteritems():", 1)
+        self.emit("space.setattr(w_self, space.wrap(field), w_value)", 2)
+        self.emit("%s_init.unwrap_spec = [ObjSpace, W_Root, Arguments]"
+                  % (name,))
+        self.emit("")
+
+    def visitConstructor(self, cons, base):
+        super(AppExposeVisitor, self).visitConstructor(cons, cons.name)
+        self.make_init(cons.name, cons.fields + self.data.cons_attributes[cons])
+        self.make_typedef(cons.name, base, cons.fields, concrete=True,
+                          needs_init=True)
+
+    def visitProduct(self, product, name):
+        super(AppExposeVisitor, self).visitProduct(product, name)
+        self.make_init(name, product.fields)
+        self.make_typedef(name, "AST", product.fields, concrete=True,
+                          needs_init=True)
+
+    def visitField(self, field, name):
+        self.make_property(field, name)
+
+    def make_property(self, field, name, different_masks=False):
+        func = "def %s_get_%s(space, w_self):" % (name, field.name)
+        self.emit(func)
+        if different_masks:
+            flag = "w_self._%s_mask" % (field.name,)
+        else:
+            flag = self.data.field_masks[field]
+        self.emit("if not w_self.initialization_state & %s:" % (flag,), 1)
+        self.emit("w_err = space.wrap(\"attribute '%s' has not been set\")" %
+                  (field.name,), 2)
+        self.emit("raise OperationError(space.w_AttributeError, w_err)", 2)
+        if field.seq:
+            self.emit("if w_self.w_%s is None:" % (field.name,), 1)
+            self.emit("if w_self.%s is None:" % (field.name,), 2)
+            self.emit("w_list = space.newlist([])", 3)
+            self.emit("else:", 2)
+            if field.type.value in self.data.simple_types:
+                wrapper = "%s_to_class[node - 1]()" % (field.type,)
+            else:
+                wrapper = "space.wrap(node)"
+            self.emit("list_w = [%s for node in w_self.%s]" %
+                      (wrapper, field.name), 3)
+            self.emit("w_list = space.newlist(list_w)", 3)
+            self.emit("w_self.w_%s = w_list" % (field.name,), 2)
+            self.emit("return w_self.w_%s" % (field.name,), 1)
+        elif field.type.value in self.data.simple_types:
+            config = (field.type, field.name)
+            self.emit("return %s_to_class[w_self.%s - 1]()" % config, 1)
+        elif field.type.value in ("object", "string"):
+            self.emit("return w_self.%s" % (field.name,), 1)
+        else:
+            self.emit("return space.wrap(w_self.%s)" % (field.name,), 1)
+        self.emit("")
+
+        func = "def %s_set_%s(space, w_self, w_new_value):" % (name, field.name)
+        self.emit(func)
+        if field.seq:
+            self.emit("w_self.w_%s = w_new_value" % (field.name,), 1)
+        elif field.type.value not in asdl.builtin_types:
+            # These are always other AST nodes.
+            if field.type.value in self.data.simple_types:
+                self.emit("obj = space.interp_w(%s, w_new_value)" % \
+                              (field.type,), 1)
+                self.emit("w_self.%s = obj.to_simple_int(space)" %
+                          (field.name,), 1)
+            else:
+                config = (field.name, field.type, repr(field.opt))
+                self.emit("w_self.%s = space.interp_w(%s, w_new_value, %s)" %
+                          config, 1)
+        else:
+            level = 1
+            if field.opt and field.type.value != "int":
+                self.emit("if space.is_w(w_new_value, space.w_None):", 1)
+                self.emit("w_self.%s = None" % (field.name,), 2)
+                level += 1
+                self.emit("else:", 1)
+            if field.type.value == "object":
+                self.emit("w_self.%s = w_new_value" % (field.name,), level)
+            elif field.type.value == "string":
+                self.emit("if not space.is_true(space.isinstance(" \
+                              "w_new_value, space.w_basestring)):", level)
+                line = "w_err = space.wrap(\"some kind of string required\")"
+                self.emit(line, level + 1)
+                self.emit("raise OperationError(space.w_TypeError, w_err)",
+                          level + 1)
+                self.emit("w_self.%s = w_new_value" % (field.name,), level)
+            else:
+                space_method = asdl_type_map[field.type.value]
+                config = (field.name, space_method)
+                self.emit("w_self.%s = space.%s(w_new_value)" % config, level)
+        self.emit("w_self.initialization_state |= %s" % (flag,), 1)
+        self.emit("")
+
+
+def copy_field(field):
+    return asdl.Field(field.type, field.name, field.seq, field.opt)
+
+
+class ASDLData(object):
+
+    def __init__(self, tree):
+        simple_types = set()
+        prod_simple = set()
+        field_masks = {}
+        required_masks = {}
+        optional_masks = {}
+        cons_attributes = {}
+        def add_masks(fields, node):
+            required_mask = 0
+            optional_mask = 0
+            for i, field in enumerate(fields):
+                flag = 1 << i
+                field_masks[field] = flag
+                if field.opt:
+                    optional_mask |= flag
+                else:
+                    required_mask |= flag
+            required_masks[node] = required_mask
+            optional_masks[node] = optional_mask
+        for tp in tree.dfns:
+            if isinstance(tp.value, asdl.Sum):
+                sum = tp.value
+                if is_simple_sum(sum):
+                    simple_types.add(tp.name.value)
+                else:
+                    for cons in sum.types:
+                        attrs = [copy_field(field) for field in sum.attributes]
+                        add_masks(cons.fields + attrs, cons)
+                        cons_attributes[cons] = attrs
+            else:
+                prod = tp.value
+                prod_simple.add(tp.name.value)
+                add_masks(prod.fields, prod)
+        prod_simple.update(simple_types)
+        self.cons_attributes = cons_attributes
+        self.simple_types = simple_types
+        self.prod_simple = prod_simple
+        self.field_masks = field_masks
+        self.required_masks = required_masks
+        self.optional_masks = optional_masks
+
+
+HEAD = """# Generated by tools/asdl_py.py
+from pypy.interpreter.baseobjspace import Wrappable, ObjSpace, W_Root
+from pypy.interpreter import typedef
+from pypy.interpreter.gateway import interp2app
+from pypy.interpreter.argument import Arguments
+from pypy.interpreter.error import OperationError
+from pypy.rlib.unroll import unrolling_iterable
+from pypy.tool.pairtype import extendabletype
+from pypy.tool.sourcetools import func_with_new_name
+
+
+class AST(Wrappable):
+
+    __slots__ = ("initialization_state",)
+
+    __metaclass__ = extendabletype
+
+    def walkabout(self, visitor):
+        raise AssertionError("walkabout() implementation not provided")
+
+    def mutate_over(self, visitor):
+        raise AssertionError("mutate_over() implementation not provided")
+
+    def sync_app_attrs(self, space):
+        raise NotImplementedError
+
+
+class NodeVisitorNotImplemented(Exception):
+    pass
+
+
+class _FieldsWrapper(Wrappable):
+    "Hack around the fact we can't store tuples on a TypeDef."
+
+    def __init__(self, fields):
+        self.fields = fields
+
+    def __spacebind__(self, space):
+        return space.newtuple([space.wrap(field) for field in self.fields])
+
+
+def get_AST_new(node_class):
+    def generic_AST_new(space, w_type, __args__):
+        node = space.allocate_instance(node_class, w_type)
+        node.initialization_state = 0
+        return space.wrap(node)
+    generic_AST_new.unwrap_spec = [ObjSpace, W_Root, Arguments]
+    return func_with_new_name(generic_AST_new, "new_%s" % node_class.__name__)
+
+
+AST.typedef = typedef.TypeDef("AST",
+    _fields=_FieldsWrapper([]),
+    _attributes=_FieldsWrapper([]),
+)
+AST.typedef.acceptable_as_base_class = False
+
+
+def missing_field(space, state, required, host):
+    "Find which required field is missing."
+    for i in range(len(required)):
+        if not (state >> i) & 1:
+            missing = required[i]
+            if missing is not None:
+                 err = "required attribute '%s' missing from %s"
+                 err = err % (missing, host)
+                 w_err = space.wrap(err)
+                 raise OperationError(space.w_TypeError, w_err)
+    raise AssertionError("should not reach here")
+
+
+"""
+
+visitors = [ASTNodeVisitor, ASTVisitorVisitor, GenericASTVisitorVisitor,
+            AppExposeVisitor]
+
+
+def main(argv):
+    if len(argv) == 3:
+        def_file, out_file = argv[1:]
+    elif len(argv) == 1:
+        print "Assuming default values of Python.asdl and ast.py"
+        here = os.path.dirname(__file__)
+        def_file = os.path.join(here, "Python.asdl")
+        out_file = os.path.join(here, "..", "ast.py")
+    else:
+        print >> sys.stderr, "invalid arguments"
+        return 2
+    mod = asdl.parse(def_file)
+    data = ASDLData(mod)
+    fp = open(out_file, "w")
+    try:
+        fp.write(HEAD)
+        for visitor in visitors:
+            visitor(fp, data).visit(mod)
+    finally:
+        fp.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))


Property changes on: trunk/jython/ast/asdl_py.py
___________________________________________________________________
Added: svn:keywords
   + Id
Added: svn:eol-style
   + native


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.