用python重写Language Implementation Patterns(2)

1354阅读　0评论2011-05-11　liu090
分类：Python/Ruby

promote 样例代码的python code:
VariableSymbol.py
  1. from Symbol import Symbol
  2. class VariableSymbol( Symbol ):
  3.     def __init__( self,name, type) :
  4.         super(VariableSymbol,self).__init__(name, type)

 

Type.py

 

  1. from Scope import abstract

  3. class Type(object) :
  4.     
  5.     #def __init__(self):
  6.     #    if self.__class__ is Scope:
  7.     # abstract()
  8.                 
  9.     #public String getName();
  10.     def getName(self):
  11.         abstract()
  12.     
  13.     #public int getTypeIndex();
  14.     def getTypeIndex(self):
  15.         abstract()

SymbolTable.py

 

  1. from CymbolListener import CymbolListener

  3. from BuiltInTypeSymbol import BuiltInTypeSymbol

  5. from GlobalScope import GlobalScope

  7. class SymbolTable(object):
  8.     # arithmetic types defined in order from narrowest to widest
  9.     #public static final int tUSER = 0; // user-defined type (struct)
  10.     tUSER = 0
  11.     #public static final int tBOOLEAN = 1;
  12.     tBOOLEAN = 1
  13.     tCHAR = 2
  14.     tINT = 3
  15.     tFLOAT = 4
  16.     tVOID = 5

  18.     #public static final BuiltInTypeSymbol _boolean =
  19.     # new BuiltInTypeSymbol("boolean", tBOOLEAN);
  20.     print 'liu: now init buildin type'
  21.     _boolean = BuiltInTypeSymbol("boolean", tBOOLEAN)
  22.     _char = BuiltInTypeSymbol("char", tCHAR)
  23.     _int = BuiltInTypeSymbol("int", tINT)
  24.     _float = BuiltInTypeSymbol("float", tFLOAT)
  25.     _void = BuiltInTypeSymbol("void", tVOID)

  27.     #public CymbolListener listener =
  28.     # new CymbolListener() {
  29.     # public void info(String msg) { System.out.println(msg); }
  30.     # public void error(String msg) { System.err.println(msg); }
  31.     # };
  32.     
  33.     #listener = CymbolListener() # liunote move to __init__

  35.     #/** arithmetic types defined in order from narrowest to widest */
  36.     #public static final Type[] indexToType = {
  37.     # // 0, 1, 2, 3, 4, 5
  38.     indexToType = [ None, _boolean, _char, _int, _float, _void ]
  39.     

  41.     #/** Map t1 op t2 to result type (_void implies illegal) */
  42.     #public static final Type[][] arithmeticResultType = new Type[][] {
  43.     # /* struct boolean char int float, void */
  44.     # /*struct*/ {_void, _void, _void, _void, _void, _void},
  45.     # /*boolean*/ {_void, _void, _void, _void, _void, _void},
  46.     # /*char*/ {_void, _void, _char, _int, _float, _void},
  47.     # /*int*/ {_void, _void, _int, _int, _float, _void},
  48.     # /*float*/ {_void, _void, _float, _float, _float, _void},
  49.     # /*void*/ {_void, _void, _void, _void, _void, _void}
  50.     #};
  51.     
  52.     # liunote math calc type change !!!
  53.     arithmeticResultType = [
  54.               [_void, _void, _void, _void, _void, _void ],
  55.               [_void, _void, _void, _void, _void, _void ],
  56.               [_void, _void, _char, _int, _float, _void ],
  57.               [_void, _void, _int, _int, _float, _void ],
  58.               [_void, _void, _float, _float, _float, _void ],
  59.               [_void, _void, _void, _void, _void, _void ]
  60.                            ]


  63.     #public static final Type[][] relationalResultType = new Type[][] {
  64.     # /* struct boolean char int float, void */
  65.     # /*struct*/ {_void, _void, _void, _void, _void, _void},
  66.     # /*boolean*/ {_void, _void, _void, _void, _void, _void},
  67.     # /*char*/ {_void, _void, _boolean, _boolean, _boolean, _void},
  68.     # /*int*/ {_void, _void, _boolean, _boolean, _boolean, _void},
  69.     # /*float*/ {_void, _void, _boolean, _boolean, _boolean, _void},
  70.     # /*void*/ {_void, _void, _void, _void, _void, _void}
  71.     #};
  72.     
  73.     # liunote relation calc type change !!!
  74.     relationalResultType = [
  75.          [ _void, _void, _void, _void, _void, _void ],
  76.          [ _void, _void, _void, _void, _void, _void ],
  77.          [ _void, _void, _boolean, _boolean, _boolean, _void ],
  78.          [ _void, _void, _boolean, _boolean, _boolean, _void ],
  79.          [ _void, _void, _boolean, _boolean, _boolean, _void ],
  80.          [ _void, _void, _void, _void, _void, _void ]
  81.                            ]

  83.     #public static final Type[][] equalityResultType = new Type[][] {
  84.     # /* struct boolean char int float, void */
  85.     # /*struct*/ {_void, _void, _void, _void, _void, _void},
  86.     # /*boolean*/ {_void, _boolean, _void, _void, _void, _void},
  87.     # /*char*/ {_void, _void, _boolean, _boolean, _boolean, _void},
  88.     # /*int*/ {_void, _void, _boolean, _boolean, _boolean, _void},
  89.     # /*float*/ {_void, _void, _boolean, _boolean, _boolean, _void},
  90.     # /*void*/ {_void, _void, _void, _void, _void, _void}
  91.     #};

  93.     equalityResultType = [
  94.         [ _void, _void, _void, _void, _void, _void ],
  95.         [ _void, _boolean, _void, _void, _void, _void ],
  96.         [ _void, _void, _boolean, _boolean, _boolean, _void ],
  97.         [ _void, _void, _boolean, _boolean, _boolean, _void ],
  98.         [ _void, _void, _boolean, _boolean, _boolean, _void ],
  99.         [ _void, _void, _void, _void, _void, _void ]
  100.                          ]
  101.     
  102.     #/** Indicate whether a type needs a promotion to a wider type.
  103.     # * If not null, implies promotion required. Null does NOT imply
  104.     # * error--it implies no promotion. This works for
  105.     # * arithmetic, equality, and relational operators in Cymbol.
  106.     # */
  107.     #public static final Type[][] promoteFromTo = new Type[][] {
  108.     # /* struct boolean char int float, void (liunote formal is colum)*/
  109.     # /*struct*/ {null, null, null, null, null, null},
  110.     # /*boolean*/ {null, null, null, null, null, null},
  111.     # /*char*/ {null, null, null, _int, _float, null},
  112.     # /*int*/ {null, null, null, null, _float, null},
  113.     # /*float*/ {null, null, null, null, null, null},
  114.     # /*void*/ {null, null, null, null, null, null}
  115.     #};
  116.     
  117.     promoteFromTo = [
  118.         [ None, None, None, None, None, None ],
  119.         [ None, None, None, None, None, None ],
  120.         [ None, None, None, _int, _float, None ],
  121.         [ None, None, None, None, _float, None ],
  122.         [ None, None, None, None, None, None ],
  123.         [ None, None, None, None, None, None ]
  124.                    ]

  126.     #GlobalScope globals = new GlobalScope();
  127.     #public SymbolTable() { initTypeSystem(); }
  128.     
  129.     #protected void initTypeSystem() {
  130.     # for (Type t : indexToType) {
  131.     # if ( t!=null ) globals.define((BuiltInTypeSymbol)t);
  132.     # }
  133.     #}
  134.     def initTypeSystem(self):
  135.         for t in SymbolTable.indexToType:
  136.             if t != None : self.globals.define(t)

  138.     def __init__(self):
  139.         self.listener = CymbolListener()
  140.         self.globals = GlobalScope()
  141.         self.initTypeSystem()

  143.     #public Type getResultType(Type[][] typeTable, CymbolAST a, CymbolAST b) {
  144.     # int ta = a.evalType.getTypeIndex(); // type index of left operand
  145.     # int tb = b.evalType.getTypeIndex(); // type index of right operand
  146.     # Type result = typeTable[ta][tb]; // operation result type
  147.     # // promote left to right or right to left?
  148.     # a.promoteToType = promoteFromTo[ta][result.getTypeIndex()];
  149.     # b.promoteToType = promoteFromTo[tb][result.getTypeIndex()];
  150.     # return result;
  151.     #}
  152.     
  153.     def getResultType(self,typeTable, a, b) :
  154.         ta = a.evalType.getTypeIndex() # type index of left operand liunote evalType => int a (a+1.1)'evalType is float!!!
  155.         tb = b.evalType.getTypeIndex() # type index of right operand
  156.         result = typeTable[ta][tb] # operation result type
  157.         
  158.         # promote left to right or right to left?
  159.         a.promoteToType = SymbolTable.promoteFromTo[ta][result.getTypeIndex()]
  160.         b.promoteToType = SymbolTable.promoteFromTo[tb][result.getTypeIndex()]
  161.         return result


  164.     #public Type bop(CymbolAST a, CymbolAST b) {
  165.     # return getResultType(arithmeticResultType, a, b);
  166.     #}
  167.     def bop( self,a, b) :
  168.         return self.getResultType(SymbolTable.arithmeticResultType, a, b) # liunote call myslef method ,param need't self
  169.     
  170.     #public Type relop(CymbolAST a, CymbolAST b) {
  171.     # return getResultType(relationalResultType, a, b);
  172.     #}
  173.     def relop(self, a, b) :
  174.         return self.getResultType(SymbolTable.relationalResultType, a, b)
  175.     
  176.     #public Type eqop(CymbolAST a, CymbolAST b) {
  177.     # return getResultType(equalityResultType, a, b);
  178.     #}
  179.     def eqop(self, a, b) :
  180.         return getResultType(SymbolTable.equalityResultType, a, b)
  181.     

  183.     #public Type uminus(CymbolAST a) { return a.evalType; }
  184.     def uminus(self,a): return a.evalType
  185.     #public Type unot(CymbolAST a) { return _boolean; }
  186.     def unot(self, a): return _boolean

  188.     #public Type arrayIndex(CymbolAST id, CymbolAST index) {
  189.     # Symbol s = id.scope.resolve(id.getText()); // resolve variable
  190.     # VariableSymbol vs = (VariableSymbol)s;
  191.     # id.symbol = vs; // annotate AST
  192.     # Type t = ((ArrayType)vs.type).elementType; // get element type
  193.     # int texpr = index.evalType.getTypeIndex();
  194.     # index.promoteToType = promoteFromTo[texpr][tINT]; // promote index?
  195.     # return t;
  196.     #}
  197.     #arrayRef returns [type] //[Type type]
  198.     #: ^(INDEX ID expr)
  199.     # {
  200.     # $type = self.symtab.arrayIndex($ID, $expr.start);
  201.     # $start.evalType = $type;
  202.     # }
  203.     #;
  204.     def arrayIndex(self,id, index) :
  205.         s = id.scope.resolve(id.getText()) # resolve variable # liunote return self.token.text
  206.         vs = s; # liunote VariableSymbol ???
  207.         id.symbol = vs; # annotate AST
  208.         #t = ((ArrayType)vs.type).elementType # get element type
  209.         #type ID '[]' ('=' expression)? ';' -> ^(VAR_DECL ^('[]' type) ID expression?)
  210.         t = (vs.type).elementType # liunote vs.type dont cast to (ArrayType) ???
  211.         
  212.         texpr = index.evalType.getTypeIndex() # liunote index node get it's evalType [2-1] => _int type
  213.         index.promoteToType = SymbolTable.promoteFromTo[texpr][SymbolTable.tINT]; # promote index?
  214.         return t;

  216.     #/** For g('q',10), promote 'q' to int, 10 to float
  217.     # * Given int g(int x, float y) {...} */
  218.     #public Type call(CymbolAST id, List args) {
  219.     # Symbol s = id.scope.resolve(id.getText());
  220.     # MethodSymbol ms = (MethodSymbol)s;
  221.     # id.symbol = ms;
  222.     # int i=0;
  223.     # for (Symbol a : ms.orderedArgs.values() ) { // for each arg
  224.     # CymbolAST argAST = (CymbolAST)args.get(i++);
  225.     # // get argument expression type and expected type
  226.     # Type actualArgType = argAST.evalType;
  227.     # Type formalArgType = ((VariableSymbol)a).type;
  228.     # int targ = actualArgType.getTypeIndex();
  229.     # int tformal = formalArgType.getTypeIndex();
  230.     # // do we need to promote argument type to defined type?
  231.     # argAST.promoteToType = promoteFromTo[targ][tformal];
  232.     # }
  233.     # return ms.type;
  234.     #}
  235.     #call returns [type] //[Type type]
  236.     #@init {List args = new ArrayList();}
  237.     #: ^(CALL ID ^(ELIST (expr {args.add($expr.start);})*))
  238.     # {
  239.     # $type = symtab.call($ID, args);
  240.     # $start.evalType = $type;
  241.     # }
  242.     #;
  243.     def call( self,id,args):
  244.         s = id.scope.resolve(id.getText())
  245.         ms = s #(MethodSymbol)
  246.         id.symbol = ms
  247.         i = 0
  248.         #for (Symbol a : ms.orderedArgs.values() ) { // for each arg
  249.         for a in [item[1] for item in ms.orderedArgs]:
  250.             #CymbolAST argAST = (CymbolAST)args.get(i++);
  251.             argAST = args[i]
  252.             
  253.             # get argument expression type and expected type
  254.             #Type actualArgType = argAST.evalType;
  255.             actualArgType = argAST.evalType # liunote only CymbolAST has evalType ???
  256.             
  257.             #Type formalArgType = ((VariableSymbol)a).type; # liunote formaltype => int func (int j) ,but call is func (5+1.2)!!!
  258.             formalArgType = a.type # formal is int index 3, actualArg is float index 4
  259.                                                               # promote[4][3]= None , int func(float) ,func(5) =>promote[3][4]= _float
  260.             #int targ = actualArgType.getTypeIndex();
  261.             #int tformal = formalArgType.getTypeIndex();
  262.             targ = actualArgType.getTypeIndex()
  263.             tformal = formalArgType.getTypeIndex()
  264.             
  265.             #// do we need to promote argument type to defined type?
  266.             argAST.promoteToType = SymbolTable.promoteFromTo[targ][tformal]
  267.             
  268.             i += 1
  269.         
  270.         return ms.type
  271.     

  273.     #public Type member(CymbolAST expr, CymbolAST field) {
  274.     # StructSymbol scope=(StructSymbol)expr.evalType;// get scope of left
  275.     # Symbol s = scope.resolveMember(field.getText());// resolve ID in scope
  276.     # field.symbol = s;
  277.     # return s.type; // return ID's type
  278.     #}
  279.     #member returns [type] //[Type type]
  280.     #: ^('.' expr ID)
  281.     # {
  282.     # $type = self.symtab.member($expr.start, $ID); // liunote struct a{ int b,...}[] => a[i].b ??? $expr.start what is ???
  283.     # $start.evalType = $type; // liunote $expr => class expr_return (see below ), it derive TreeRuleReturnScope
  284.     # } // $expr'start TreeRuleReturnScope 's start ()
  285.     # // This is identical to the ParserRuleReturnScope except that
  286.     # // the start property is a tree nodes not Token object
  287.     # // when you are parsing trees. To be generic the tree node types
  288.     # // have to be Object.

  290.     #public static class expr_return extends TreeRuleReturnScope {
  291.     # public Type type;
  292.     #};

  294.     #// $ANTLR start "expr"
  295.     #// /Users/parrt/research/book/TPDSL/Book/code/semantics/promote/Types.g:39:1: expr returns [Type type] : ( 'true' | 'false' | CHAR | INT | FLOAT | ID | ^( UNARY_MINUS a= expr ) | ^( UNARY_NOT a= expr ) | member | arrayRef | call | binaryOps );
  296.     #public final Types.expr_return expr() throws RecognitionException {
  297.     # Types.expr_return retval = new Types.expr_return();
  298.     
  299.     def member(self, expr, field) :
  300.         scope = expr.evalType # (StructSymbol) get scope of left
  301.         s = scope.resolveMember(field.getText()) # resolve ID in scope
  302.         field.symbol = s
  303.         return s.type # return ID's type
  304.     

  306.     # assignnment stuff (arg assignment in call())

  308.     #public void declinit(CymbolAST id, CymbolAST init) {
  309.     # int te = init.evalType.getTypeIndex(); //promote expr to decl type?
  310.     # int tdecl = id.symbol.type.getTypeIndex();
  311.     # init.promoteToType = promoteFromTo[te][tdecl];
  312.     #}
  313.     #// START: datatransfer
  314.     #decl: ^(VAR_DECL . ID (init=.)?) // call declinit if we have init expr
  315.     # /*{if ( $init!=null && $init.evalType!=null )
  316.     # symtab.declinit($ID, $init);}
  317.     # *//* liunote $init=>CymbolAST */
  318.     # {if $init!=None and $init.evalType!=None:
  319.     # self.symtab.declinit($ID, $init);}
  320.     #;
  321.     def declinit(self, id, init) :
  322.         te = init.evalType.getTypeIndex() # promote expr to decl type?
  323.         tdecl = id.symbol.type.getTypeIndex()
  324.         init.promoteToType = SymbolTable.promoteFromTo[te][tdecl]

  326.     #ret : ^('return' v=.) {self.symtab.ret($start.symbol, $v);} //{symtab.ret((MethodSymbol)$start.symbol, $v);}
  327.     #;
  328.     def ret( self,ms, expr) :
  329.         retType = ms.type; # promote return expr to function decl type? int m1(...) {return a;} a:expr, ms:int 's switch
  330.         exprType = expr.evalType
  331.         texpr = exprType.getTypeIndex()
  332.         tret = retType.getTypeIndex()
  333.         expr.promoteToType = SymbolTable.promoteFromTo[texpr][tret] # liunote at return get promote type

  335.     #assignment // don't walk exprs, just examine types; '.' is wildcard
  336.     #: ^('=

 

Symbol.py

 

  1. class Symbol(object): # A generic programming language symbol

  3.     #public Symbol(String name) { this.name = name; }
  4.     #public Symbol(String name, Type type) { this(name); this.type = type; }
  5.     def __init__(self,name,type=None):
  6.         self.name = '' # liunote use None ???
  7.         self.scope = None
  8.         self.type = None
  9.         self.cymbolast_def = None # Location in AST of ID node liunote where use???
  10.         
  11.         self.name = name
  12.         
  13.         if type != None:
  14.             self.type = type

  16.     #public String getName() { return name; } # liunote getName must define ,for derive Type interface
  17.     def getName(self):
  18.         return self.name
  19.     #name = property(getName) # liunote for sub get parent's member var !

  21.     #def getType(self):
  22.     #    return self.type
  23.     #type = property(getType) # liunote for sub class instance get parent's member var !

  25.     #public String toString() {
  26.     def toString(self):
  27.         s = "";
  28.         if self.scope != None : s = self.scope.getScopeName()+".";
  29.         if self.type != None : return '<' + s + self.getName() + ":" + type + '>'
  30.         return s + self.getName();


  33.     #public static String stripBrackets(String s) {
  34.     def stripBrackets(s):
  35.         return s[1:len(s)-1] #s.substring(1,s.length()-1)
  36.     
  37.     stripBrackets = staticmethod(stripBrackets)

StructSymbol.py

 

  1. from Type import Type
  2. from Scope import Scope
  3. from ScopedSymbol import ScopedSymbol
  4. from SymbolTable import SymbolTable



  8. class StructSymbol (ScopedSymbol, Type, Scope):
  9.     
  10.     #Map<String, Symbol> fields = new LinkedHashMap<String, Symbol>();
  11.     #public StructSymbol(String name,Scope parent) {super(name, parent);}
  12.     def __init__(self,name,parent) :
  13.         self.fields = []
  14.         super(MethodSymbol,self).__init__(name, sparent)
  15.     
  16.     #/** For a.b, only look in a only to resolve b, not up scope tree */
  17.     #public Symbol resolveMember(String name) { return fields.get(name); }
  18.     def resolveMember(self,name):
  19.         #return fields.get(name)
  20.         for item in self.fields:
  21.             if type(item) != tuple:
  22.                 raise RuntimeError('fields item is not tuple error')
  23.             else:
  24.              if item[0] == name:
  25.                  return item[1]
  26.         
  27.     
  28.     #public Map<String, Symbol> getMembers() { return fields; }
  29.     def getMembers(self):
  30.         return fields
  31.         
  32.     def get(self,name):
  33.         for item in self.fields:
  34.             if type(item) != tuple:
  35.                 raise RuntimeError('fields item is not tuple')
  36.             else:
  37.              if item[0] == name:
  38.                  return item[1]

  40.     #public String toString() {
  41.     def toString(self):
  42.         #return "struct "+name+":{"+ stripBrackets(fields.keySet().toString())+"}";
  43.         return "struct " + self.name + "(" + ScopedSymbol.stripBrackets(str([item[0] for item in self.fields])) + ")"

  45.     
  46.     #public int getTypeIndex() { return SymbolTable.tUSER; }
  47.     def getTypeIndex(self): # liunote other is buildin type ,this is user type
  48.         return SymbolTable.tUSER

ScopedSymbol.py

 

  1. from Symbol import Symbol
  2. from Scope import Scope


  5. #public abstract class ScopedSymbol extends Symbol implements Scope {
  6. class ScopedSymbol (Symbol, Scope):

  8.     #Scope enclosingScope;

  10.     #public ScopedSymbol(String name, Type type, Scope enclosingScope) {
  11.     # super(name, type);
  12.     # this.enclosingScope = enclosingScope;
  13.     #}
  14.     #public ScopedSymbol(String name, Scope enclosingScope) {
  15.     # super(name);
  16.     # this.enclosingScope = enclosingScope;
  17.     #}
  18.     
  19.     def __init__( self,name, enclosingScope,type):
  20.         
  21.         if type != None:
  22.             super(ScopedSymbol,self).__init__(name, type)
  23.         else:
  24.             super(ScopedSymbol,self).__init__(name)
  25.         
  26.         #if isinstance(enclosingScope,Scope):
  27.         # self.enclosingScope = enclosingScope # liunote use issubclass ???
  28.         #else:
  29.         # raise RuntimeError('enclosingScope is not instance of xScope')
  30.         
  31.         # liunote nouse above , when buidin type(derive smbol type) not derive from Scope !!!
  32.         #print 'liutest enclosingScope'
  33.         #print enclosingScope
  34.         self.enclosingScope = enclosingScope
  35.         
  36.     #public Symbol resolve(String name) {
  37.     def resolve(self,name):
  38.     #s = self.getMembers().get(name) # this getMembers is abstract, subclass must implement this method !
  39.     s = self.get(name)
  40.         if s != None: return s
  41.     
  42.     #if not here, check any enclosing scope
  43.     if self.getEnclosingScope() != None :
  44.         return self.getEnclosingScope().resolve(name)
  45.         
  46.     return None # not found
  47.     
  48.     #public Symbol resolveType(String name) { return resolve(name); }
  49.     def resolveType(self,name):
  50.         return self.resolve(name)
  51.     
  52.     def define(self,sym):
  53.         #self.getMembers().put(sym.name, sym)
  54.         self.getMembers().append((sym.name, sym))
  55.     sym.scope = self # track the scope in each symbol
  56.     # liutest
  57.     print self.getMembers()


  60.     def getEnclosingScope(self):
  61.         return self.enclosingScope
  62.     
  63.     def getScopeName(self):
  64.         return self.name # liunote self.name at Symbol class => property(getName)

  66.     #/** Indicate how subclasses store scope members. Allows us to
  67.     # * factor out common code in this class.
  68.     # */
  69.     #public abstract Map<String, Symbol> getMembers();
  70.     def getMembers(self): # ??? liunote if use below get,getMember can discard !
  71.         abstract()

  73.     # liunote for list get name     
  74.     def get(self,name):
  75.         abstract()

Scope.py

 

  1. def abstract():
  2.     raise NotImplementedError("abstract")

  4. class Scope(object):
  5.     
  6.     #def __init__(self):
  7.         # if self.__class__ is Scope:
  8.         # abstract()

  10.     def getScopeName(self):
  11.             abstract()
  12.                
  13.         # Where to look next for symbols
  14.         def getEnclosingScope(self):
  15.             abstract()

  17.         # Define a symbol in the current scope
  18.         def define(self,sym):
  19.             abstract()
  20.             
  21.         # Look up name in this scope or in enclosing scope if not here
  22.         def resolve(self,name):
  23.             abstract()

 

 

上一篇：用python重写Language Implementation Patterns(1)
下一篇：用python重写Language Implementation Patterns(3)