"""An implementation of the Zephyr Abstract Syntax Definition Language.

See http://asdl.sourceforge.net/ and
http://www.cs.princeton.edu/~danwang/Papers/dsl97/dsl97-abstract.html.

Only supports top level module decl, not view.  I'm guessing that view
is intended to support the browser and I'm not interested in the
browser.

Changes for Python: Add support for module versions
"""

#__metaclass__ = type

import os
import traceback

import spark

class Token:
   # spark seems to dispatch in the parser based on a token's
   # type attribute
   def __init__(self, type, lineno):
       self.type = type
       self.lineno = lineno

   def __str__(self):
       return self.type

   def __repr__(self):
       return str(self)

class Id(Token):
   def __init__(self, value, lineno):
       self.type = 'Id'
       self.value = value
       self.lineno = lineno

   def __str__(self):
       return self.value

class String(Token):
   def __init__(self, value, lineno):
       self.type = 'String'
       self.value = value
       self.lineno = lineno

class ASDLSyntaxError:

   def __init__(self, lineno, token=None, msg=None):
       self.lineno = lineno
       self.token = token
       self.msg = msg

   def __str__(self):
       if self.msg is None:
           return "Error at '%s', line %d" % (self.token, self.lineno)
       else:
           return "%s, line %d" % (self.msg, self.lineno)

class ASDLScanner(spark.GenericScanner, object):

   def tokenize(self, input):
       self.rv = []
       self.lineno = 1
       super(ASDLScanner, self).tokenize(input)
       return self.rv

   def t_id(self, s):
       r"[\w\.]+"
       # XXX doesn't distinguish upper vs. lower, which is
       # significant for ASDL.
       self.rv.append(Id(s, self.lineno))

   def t_string(self, s):
       r'"[^"]*"'
       self.rv.append(String(s, self.lineno))

   def t_xxx(self, s): # not sure what this production means
       r"<="
       self.rv.append(Token(s, self.lineno))

   def t_punctuation(self, s):
       r"[\{\}\*\=\|\(\)\,\?\:]"
       self.rv.append(Token(s, self.lineno))

   def t_comment(self, s):
       r"\-\-[^\n]*"
       pass

   def t_newline(self, s):
       r"\n"
       self.lineno += 1

   def t_whitespace(self, s):
       r"[ \t]+"
       pass

   def t_default(self, s):
       r" . +"
       raise ValueError, "unmatched input: %s" % `s`

class ASDLParser(spark.GenericParser, object):
   def __init__(self):
       super(ASDLParser, self).__init__("module")

   def typestring(self, tok):
       return tok.type

   def error(self, tok):
       raise ASDLSyntaxError(tok.lineno, tok)

   def p_module_0(self, (module, name, version, _0, _1)):
       " module ::= Id Id version { } "
       if module.value != "module":
           raise ASDLSyntaxError(module.lineno,
                                 msg="expected 'module', found %s" % module)
       return Module(name, None, version)

   def p_module(self, (module, name, version, _0, definitions, _1)):
       " module ::= Id Id version { definitions } "
       if module.value != "module":
           raise ASDLSyntaxError(module.lineno,
                                 msg="expected 'module', found %s" % module)
       return Module(name, definitions, version)

   def p_version(self, (version, V)):
       "version ::= Id String"
       if version.value != "version":
           raise ASDLSyntaxError(version.lineno,
                               msg="expected 'version', found %" % version)
       return V

   def p_definition_0(self, (definition,)):
       " definitions ::= definition "
       return definition

   def p_definition_1(self, (definitions, definition)):
       " definitions ::= definition definitions "
       return definitions + definition

   def p_definition(self, (id, _, type)):
       " definition ::= Id = type "
       return [Type(id, type)]

   def p_type_0(self, (product,)):
       " type ::= product "
       return product

   def p_type_1(self, (sum,)):
       " type ::= sum "
       return Sum(sum)

   def p_type_2(self, (sum, id, _0, attributes, _1)):
       " type ::= sum Id ( fields ) "
       if id.value != "attributes":
           raise ASDLSyntaxError(id.lineno,
                                 msg="expected attributes, found %s" % id)
       if attributes:
           attributes.reverse()
       return Sum(sum, attributes)

   def p_product(self, (_0, fields, _1)):
       " product ::= ( fields ) "
       # XXX can't I just construct things in the right order?
       fields.reverse()
       return Product(fields)

   def p_sum_0(self, (constructor,)):
       " sum ::= constructor """
       return [constructor]

   def p_sum_1(self, (constructor, _, sum)):
       " sum ::= constructor | sum "
       return [constructor] + sum

   def p_sum_2(self, (constructor, _, sum)):
       " sum ::= constructor | sum "
       return [constructor] + sum

   def p_constructor_0(self, (id,)):
       " constructor ::= Id "
       return Constructor(id)

   def p_constructor_1(self, (id, _0, fields, _1)):
       " constructor ::= Id ( fields ) "
       # XXX can't I just construct things in the right order?
       fields.reverse()
       return Constructor(id, fields)

   def p_fields_0(self, (field,)):
       " fields ::= field "
       return [field]

   def p_fields_1(self, (field, _, fields)):
       " fields ::= field , fields "
       return fields + [field]

   def p_field_0(self, (type,)):
       " field ::= Id "
       return Field(type)

   def p_field_1(self, (type, name)):
       " field ::= Id Id "
       return Field(type, name)

   def p_field_2(self, (type, _, name)):
       " field ::= Id * Id "
       return Field(type, name, seq=1)

   def p_field_3(self, (type, _, name)):
       " field ::= Id ? Id "
       return Field(type, name, opt=1)

   def p_field_4(self, (type, _)):
       " field ::= Id * "
       return Field(type, seq=1)

   def p_field_5(self, (type, _)):
       " field ::= Id ? "
       return Field(type, opt=1)

builtin_types = ("identifier", "string", "int", "bool", "object")

# below is a collection of classes to capture the AST of an AST :-)
# not sure if any of the methods are useful yet, but I'm adding them
# piecemeal as they seem helpful

class AST:
   pass # a marker class

class Module(AST):
   def __init__(self, name, dfns, version):
       self.name = name
       self.dfns = dfns
       self.version = version
       self.types = {} # maps type name to value (from dfns)
       for type in dfns:
           self.types[type.name.value] = type.value

   def __repr__(self):
       return "Module(%s, %s)" % (self.name, self.dfns)

class Type(AST):
   def __init__(self, name, value):
       self.name = name
       self.value = value

   def __repr__(self):
       return "Type(%s, %s)" % (self.name, self.value)

class Constructor(AST):
   def __init__(self, name, fields=None):
       self.name = name
       self.fields = fields or []

   def __repr__(self):
       return "Constructor(%s, %s)" % (self.name, self.fields)

class Field(AST):
   def __init__(self, type, name=None, seq=0, opt=0):
       self.type = type
       self.name = name
       self.seq = seq
       self.opt = opt

   def __repr__(self):
       if self.seq:
           extra = ", seq=1"
       elif self.opt:
           extra = ", opt=1"
       else:
           extra = ""
       if self.name is None:
           return "Field(%s%s)" % (self.type, extra)
       else:
           return "Field(%s, %s%s)" % (self.type, self.name, extra)

class Sum(AST):
   def __init__(self, types, attributes=None):
       self.types = types
       self.attributes = attributes or []

   def __repr__(self):
       if self.attributes is None:
           return "Sum(%s)" % self.types
       else:
           return "Sum(%s, %s)" % (self.types, self.attributes)

class Product(AST):
   def __init__(self, fields):
       self.fields = fields

   def __repr__(self):
       return "Product(%s)" % self.fields

class VisitorBase(object):

   def __init__(self, skip=0):
       self.cache = {}
       self.skip = skip

   def visit(self, object, *args):
       meth = self._dispatch(object)
       if meth is None:
           return
       try:
           meth(object, *args)
       except Exception, err:
           print "Error visiting", repr(object)
           print err
           traceback.print_exc()
           # XXX hack
           if hasattr(self, 'file'):
               self.file.flush()
           os._exit(1)

   def _dispatch(self, object):
       assert isinstance(object, AST), repr(object)
       klass = object.__class__
       meth = self.cache.get(klass)
       if meth is None:
           methname = "visit" + klass.__name__
           if self.skip:
               meth = getattr(self, methname, None)
           else:
               meth = getattr(self, methname)
           self.cache[klass] = meth
       return meth

class Check(VisitorBase):

   def __init__(self):
       super(Check, self).__init__(skip=1)
       self.cons = {}
       self.errors = 0
       self.types = {}

   def visitModule(self, mod):
       for dfn in mod.dfns:
           self.visit(dfn)

   def visitType(self, type):
       self.visit(type.value, str(type.name))

   def visitSum(self, sum, name):
       for t in sum.types:
           self.visit(t, name)

   def visitConstructor(self, cons, name):
       key = str(cons.name)
       conflict = self.cons.get(key)
       if conflict is None:
           self.cons[key] = name
       else:
           print "Redefinition of constructor %s" % key
           print "Defined in %s and %s" % (conflict, name)
           self.errors += 1
       for f in cons.fields:
           self.visit(f, key)

   def visitField(self, field, name):
       key = str(field.type)
       l = self.types.setdefault(key, [])
       l.append(name)

   def visitProduct(self, prod, name):
       for f in prod.fields:
           self.visit(f, name)

def check(mod):
   v = Check()
   v.visit(mod)

   for t in v.types:
       if not mod.types.has_key(t) and not t in builtin_types:
           v.errors += 1
           uses = ", ".join(v.types[t])
           print "Undefined type %s, used in %s" % (t, uses)

   return not v.errors

def parse(file):
   scanner = ASDLScanner()
   parser = ASDLParser()

   buf = open(file).read()
   tokens = scanner.tokenize(buf)
   try:
       return parser.parse(tokens)
   except ASDLSyntaxError, err:
       print err
       lines = buf.split("\n")
       print lines[err.lineno - 1] # lines starts at 0, files at 1

if __name__ == "__main__":
   import glob
   import sys

   if len(sys.argv) > 1:
       files = sys.argv[1:]
   else:
       testdir = "tests"
       files = glob.glob(testdir + "/*.asdl")

   for file in files:
       print file
       mod = parse(file)
       print "module", mod.name
       print len(mod.dfns), "definitions"
       if not check(mod):
           print "Check failed"
       else:
           for dfn in mod.dfns:
               print dfn.type

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.