用python重写Language Implementation Patterns(3)

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

promote,python 代码，最后test.py 是测试代码
 
MyTreeFilter.py (3.12 对python不直接支持tree filter ,参考了antlr 论坛上的一个帖子)
  1. from antlr3.tree import *
  2. from antlr3 import TokenStream
  3. from antlr3 import RecognizerSharedState, RecognitionException
  4. from antlr3 import NoViableAltException, BacktrackingFailed



  8. class MyTreeFilter(TreeParser):
  9.     '''
  10.     public TreeFilter(TreeNodeStream input) {
  11.         super(input);
  12.     }
  13.     '''
  14.     def __init__(self,input, state=None):
  15.         if state == None:
  16.             super(MyTreeFilter,self).__init__(input)
  17.         else:
  18.                 super(MyTreeFilter,self).__init__(input, state)
  19.             
  20.         self.originalAdaptor = input.getTreeAdaptor();
  21.         #print 'liutest original adaptor'
  22.         #print self.originalAdaptor
  23.         self.originalTokenStream = input.getTokenStream();

  25.     def applyOnce(self, t, rule):
  26.         if t == None: return None
  27.         
  28.         try:
  29.             self._state = RecognizerSharedState()
  30.             self.input = CommonTreeNodeStream(self.originalAdaptor, t)
  31.             self.input.setTokenStream(self.originalTokenStream)
  32.             self.setBacktrackingLevel(1)
  33.             r = rule()
  34.             self.setBacktrackingLevel(0)
  35.             
  36.             # there is no failed state so skipping this check; failure should cause an exception to be thrown?
  37.             #if (self.failed() ): return t
  38.             
  39.             #if ( self.showTransformations and r != None and t != r.tree and r.tree != None):
  40.             # self.reportTransformation(t, r.tree)
  41.             
  42.             if ( r != None and r.tree != None ):
  43.                 return r.tree
  44.             else:
  45.                 return t
  46.         #except RecognitionException,re:
  47.         except RecognitionException:
  48.             pass
  49.             #print 'liutest applyOnce RecognitionException'
  50.             #self.reportError(re)
  51.             #self.recover(self.input, re)
  52.         #except BacktrackingFailed:
  53.         # pass


  56.         return t

  58.     #def applyRepeatedly(self, t, rule):
  59.     # treeChanged = True
  60.     # while treeChanged:
  61.     # u = self.applyOnce(t, rule)
  62.     # treeChanged = (t != u)
  63.     # t = u
  64.     # return t
  65.         
  66.     #def downup(self, t, showTransformations=False):
  67.     def downup(self, t):
  68.         #self.showTransformations = showTransformations
  69.         v = TreeVisitor(self.originalAdaptor) #TreeVisitor(CommonTreeAdaptor())
  70.         #t = v.visit(t, lambda t: self.applyOnce(t, self.topdown), lambda t: self.applyRepeatedly(t, self.bottomup))
  71.         t = v.visit(t, lambda t: self.applyOnce(t, self.topdown), lambda t: self.applyOnce(t, self.bottomup))
  72.         return t

  74.     
  75.     #def reportTransformation(self, oldTree, newTree):
  76.     # print oldTree.toStringTree() + " -> " + newTree.toStringTree()
  77.     
  78.     # methods the downup strategy uses to do the up and down rules.
  79.     # to override, just define tree grammar rule topdown and turn on
  80.     # filter=true.
  81.         
  82.     def topdown(self):
  83.         return None
  84.         #raise NotImplementedError("topdown abstract")
  85.     
  86.     def bottomup(self):
  87.         return None
  88.         #raise NotImplementedError("bottomup abstract")
 
MethodSymbol.py
  1. from ScopedSymbol import ScopedSymbol

  3. class MethodSymbol(ScopedSymbol):

  5.     #Map<String, Symbol> orderedArgs = new LinkedHashMap<String, Symbol>();

  7.     def __init__(self,name,retType,parent):
  8.         #self.orderedArgs = {} # liunote dict is not ordered
  9.         self.orderedArgs = []
  10.         #super(MethodSymbol,self).__init__(name, retType, parent) # liunote error see MethodSymbol init func param
  11.         super(MethodSymbol,self).__init__(name, parent,retType)

  13.     def getMembers(self):
  14.         return self.orderedArgs
  15.         
  16.     def get(self,name):
  17.         for item in self.orderedArgs:
  18.             if type(item) != tuple:
  19.                 raise RuntimeError('orderedArgs item is not tuple')
  20.             else:
  21.              if item[0] == name:
  22.                  return item[1]
  23.             
  24.         return None

  26.     def getName(self):
  27.         #return name+"("+ stripBrackets(orderedArgs.keySet().toString())+")";
  28.         #return name+"("+ stripBrackets(str(self.symbols.items())+")"
  29.         #return self.name + "("+ stripBrackets(str(self.orderedArgs.keys())+")"
  30.         return self.name + "(" + ScopedSymbol.stripBrackets(str([item[0] for item in self.orderedArgs])) + ")"
 
LocalScope.py
  1. from BaseScope import BaseScope

  3. class LocalScope(BaseScope):
  4.     
  5.     #public LocalScope(Scope parent) { super(parent); }
  6.     def __init__(self, parent):
  7.         super(LocalScope,self).__init__(parent)
  8.     
  9.     #public String getScopeName() { return "local"; }
  10.     def getScopeName(self):
  11.         return "local"

GlobalScope.py

  1. from BaseScope import *

  3. class GlobalScope( BaseScope ):
  4.     #public GlobalScope() { super(null); }
  5.     def __init__(self):
  6.         super(GlobalScope,self).__init__(None)
  7.     
  8.     #public String getScopeName() { return "global"; }
  9.     def getScopeName(self):
  10.          return "global"

 

CymbolListener.py

 

  1. from Scope import abstract

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

  9.     def info(self,msg):
  10.         #abstract()
  11.         print msg
  12.         
  13.     def error(self, msg):
  14.         #abstract()
  15.         print msg

CymbolErrorNode.py

 

  1. from antlr3 import RecognitionException
  2. from antlr3 import Token
  3. from antlr3 import TokenStream
  4. from antlr3.tree import CommonErrorNode


  7. class CymbolErrorNode (CymbolAST) :
  8.     
  9.     #CommonErrorNode delegate

  11.     def __init__(self,input, start, stop, e):
  12.         self.delegate = CommonErrorNode(input,start,stop,e)
  13.     

  15.     def isNil(self) :
  16.         return self.delegate.isNil() # Indicates the node is a nil node but may still have children, meaning the tree is a flat list

  18.     def getType(self) :
  19.         return self.delegate.getType()

  21.     def getText(self) :
  22.         return self.delegate.getText()
  23.         
  24.     def toString(self) :
  25.         return self.delegate.toString()

 

CymbolAST.py

 

  1. from antlr3 import RecognitionException
  2. from antlr3 import Token
  3. from antlr3 import TokenStream
  4. from antlr3.tree import CommonErrorNode


  7. class CymbolErrorNode (CymbolAST) :
  8.     
  9.     #CommonErrorNode delegate

  11.     def __init__(self,input, start, stop, e):
  12.         self.delegate = CommonErrorNode(input,start,stop,e)
  13.     

  15.     def isNil(self) :
  16.         return self.delegate.isNil() # Indicates the node is a nil node but may still have children, meaning the tree is a flat list

  18.     def getType(self) :
  19.         return self.delegate.getType()

  21.     def getText(self) :
  22.         return self.delegate.getText()
  23.         
  24.     def toString(self) :
  25.         return self.delegate.toString()

 

ClassSymbol.py
  1. from ScopedSymbol import ScopedSymbol
  2. from Scope import Scope
  3. from Type import Type


  6. class ClassSymbol ( ScopedSymbol, Scope, Type ):
  7.     #/** This is the superclass not enclosingScope field. We still record
  8.     # * the enclosing scope so we can push in and pop out of class defs.
  9.     # */
  10.     
  11.     #ClassSymbol superClass;
  12.     
  13.     # /** List of all fields and methods */
  14.     # public Map<String,Symbol> members =new LinkedHashMap<String,Symbol>();
  15.     
  16.     
  17.     #public ClassSymbol(String name, Scope enclosingScope, ClassSymbol superClass) {
  18.     # super(name, enclosingScope);
  19.     # this.superClass = superClass;
  20.     #}
  21.     def __init__(self, name, enclosingScope, superClass) {
  22.         self.members = []
  23.         super(ClassSymbol,self).__init__(name, enclosingScope)
  24.         self.superClass = superClass;
  25.     
  26.     
  27.     def getParentScope(self) :
  28.         if self.name == "Object" : return enclosingScope # globals ,liunote self.name at Symbol.py
  29.         return superClass # if not Object, return super
  30.     }

  32.     # /** For a.b, only look in a's class hierarchy to resolve b, not globals */
  33.     #public Symbol resolveMember(String name) {
  34.     # Symbol s = members.get(name);
  35.     # if ( s!=null ) return s;
  36.     # // if not here, check any enclosing scope
  37.     # if ( superClass != null ) {
  38.     # return superClass.resolveMember(name);
  39.     # }
  40.     # return null; // not found
  41.     #}
  42.     def resolveMember(self, name) :
  43.         s = get(name)
  44.         if s != None : return s
  45.         # if not here, check any enclosing scope
  46.         if self.superClass != None :
  47.             return self.superClass.resolveMember(name)
  48.         
  49.         return None # not found
  50.     
  51.     
  52.     def get(self,name):
  53.         for item in self.members:
  54.             if type(item) != tuple:
  55.                 raise RuntimeError('orderedArgs item is not tuple

 

BuiltInTypeSymbol.py

 

  1. from Symbol import Symbol
  2. from Type import Type


  5. #public class BuiltInTypeSymbol extends Symbol implements Type {
  6. class BuiltInTypeSymbol (Symbol,Type): # liunote if def Interface type , but not implement it method ,then raise no implement error
  7.     
  8.     #int typeIndex;
  9.     
  10.     def __init__(self,name,typeIndex):
  11.         print 'liutest super class Symbol init'
  12.         Symbol.__init__(self,name)
  13.         self.typeIndex = typeIndex
  14.     
  15.     def getTypeIndex(self):
  16.         return self.typeIndex
  17.         
  18.     def toString(self):
  19.         return self.getName() # liunote will call Symbol

BaseScope.py

 

  1. from Scope import Scope

  3. class BaseScope(Scope): # BaseScope is abstract class

  5.     def __init__(self,parent):
  6.         #self.symbols = {} # liunote dict dnot use as linked hash map
  7.         self.symbols = [] # [(sym.name),(sym)] => ([x][0],[x],[1])
  8.         self.enclosingScope = parent # Scope enclosingScope; null if global (outermost) scope
  9.         

  11.     def resolve(self,name):
  12.         # s = self.symbols.get(name) # liunote
  13.         s = self.get(name) # liunote :get(self,name) call instance method,not use self param
  14.         if s != None: return s

  16.     # if not here, check any enclosing scope
  17.     if self.enclosingScope != None: return self.enclosingScope.resolve(name)
  18.     return None # not found


  21.     #public void define(Symbol sym) {
  22.     def define(self,sym):
  23.         #self.symbols.put(sym.name, sym) # liunote use tuple list
  24.         self.symbols.append((sym.name, sym)) # no !!! liunote ??? name at Symbol.py , is parent class ,only derive method !!!
  25.                                               # liunote java sym.name diff getName ,sym.name only is parent Symbol class menber
  26.     sym.scope = self # track the scope in each symbol # liunote self will subclass instance's self !!!


  29.     #public Scope getEnclosingScope() { return enclosingScope; }
  30.     def getEnclosingScope(self):
  31.         return self.enclosingScope
  32.     
  33.     #public String toString() { return symbols.keySet().toString(); }
  34.     def toString(self):
  35.          #return self.symbols.keySet().toString() # liunote keySet
  36.          #str(self.symbols.items())
  37.          #return str(self.symbols.keys()) # liunote
  38.          return str([item[0] for item in self.symbols])
  39.         
  40.     def get(self,name):
  41.         for item in self.symbols:
  42.             if type(item) != tuple:
  43.                 raise RuntimeError('symbols item is not tuple

 

 

  1. from Symbol import Symbol
  2. from Type import Type

  4. class ArrayType(Symbol,Type) :
  5.     
  6.     def __init__(self,    elementType):
  7.         super(ArrayType,self).__init__("[]",elementType) #(elementType+"[]") liunote use (name,type) ,or (name) param ???
  8.         self.elementType = elementType

  10.     def getTypeIndex(self):
  11.         return 0
  12.         
  13.     #def getElementType(self):
  14.     #    return self.elementType
  15.         
  16.     #elementType = property(getElementType)

 

test.py

 

  1. from antlr3 import *
  2. from antlr3.tree import *

  4. from CymbolLexer import CymbolLexer
  5. from CymbolParser import CymbolParser

  7. from Def import Def
  8. from Types import Types

  10. from SymbolTable import SymbolTable

  12. from CymbolAST import CymbolAST


  15. #class MyNode(CommonTree):
  16. # def __init__(self):
  17. # self.Symbol={}
  18.         
  19. #class MyNodeAdaptor(CommonTreeAdaptor):
  20. # def create(payload):
  21. #     return MyNode(payload)

  23. class CymbolAdaptor(CommonTreeAdaptor):
  24.     
  25.         #def create(self,token):
  26.         # print ' liutest CymbolAdaptor creat CymbolAST!!!'
  27.         # return CymbolAST(token)
  28.         
  29.         def createWithPayload(self, payload):
  30.             #print ' liutest CymbolAdaptor creat CymbolAST!!!'
  31.             return CymbolAST(payload)

  33.         
  34.         def dupNode(self,t) :
  35.             if t == None :
  36.                 return None
  37.             return self.create(t.token) # (CymbolAST)t

  39.         def errorNode( self,input, start, stop, e):
  40.             print 'liu:CymbolAdaptor errorNode'
  41.             return CymbolErrorNode(input,start,stop,e)

  43. #ANTLRFileStream
  44. #CharStream input = null;
  45. filename = '/home/liu/promote/t.cymbol'

  47. input = ANTLRFileStream(filename);
  48. #input = antlr3.ANTLRInputStream(sys.stdin)

  50. lexer = CymbolLexer(input)

  52. #tokens = antlr3.CommonTokenStream(lexer)
  53. tokens = TokenRewriteStream(lexer)

  55. #parser = ExprParser(tokens)
  56. parser = CymbolParser(tokens)

  58. cymbolAdaptor = CymbolAdaptor()
  59. parser.setTreeAdaptor(cymbolAdaptor) # call to BaseTreeAdaptor

 

测试输入

t.symbol:

 

  1. int n;
  2. float a[];
  3. int d[];
  4. void f() {
  5.     a[0] = 4*'i'; // promote char to int to float
  6.     a[1] = d[0]; // promote int element to float
  7.     a['x'] = 1; // check array index promotion
  8.     g('q',10); // arg promotion
  9. }
  10. int g(int x, float y) { return 'k'; } // promote 'k' to int

u.cymbol:

 

  1. float a[];
  2. int d[];
  3. int c = 'z';
  4. void f() {
  5.     a[3] = a[0]+4*'i'+d[0];
  6.     boolean b = a[3+'a'] < 3.4;
  7.     float f = a['x']+g('q',10);
  8.     f = 3;
  9.     int i;
  10.     struct A { int x; };
  11.     struct A s;
  12.     int j = h(1)+4*a[i]+s.x;
  13. }
  14. int g(int x, float y) { return 'k'; }
  15. int h(int x) { return x; }

  17. float ff = g(3,3.4);
  18. float gg = d[0];

 

 

上一篇：用python重写Language Implementation Patterns(2)
下一篇：再读syscall loop