| #!/usr/bin/env python |
| """ ir.py - parse c declarations |
| |
| (c) 2002, 2003, 2004, 2005 Simon Burton <simon@arrowtheory.com> |
| Released under GNU LGPL license. |
| |
| version 0.xx |
| |
| """ |
| |
| import sys |
| #import cPickle as pickle |
| import pickle |
| |
| #from lexer import Lexer |
| from parse_core import Symbols #, Parser |
| import node as node_module |
| import cparse |
| import genpyx |
| |
| class Node(genpyx.Node, node_module.Node): |
| """ |
| tree structure |
| """ |
| def __init__( self, *args, **kw ): |
| node_module.Node.__init__( self, *args, **kw ) |
| self._marked = False |
| def get_marked( self ): |
| return self._marked |
| def set_marked( self, marked ): |
| # if marked: |
| # print "MARK", self |
| self._marked = marked |
| marked = property( get_marked, set_marked ) |
| |
| # def __getstate__( self ): |
| # return self.__class__, tuple( [ item.__getstate__() for item in self ] ) |
| # def __setstate__( self, state ): |
| # cls, states = state |
| # states = list(states) |
| # for idx, state in enumerate(states): |
| # items[idx] = items[idx].__setstate__( |
| def __getstate__(self): |
| return str(self) |
| def __setstate__(self, state): |
| Node.__init__(self) |
| self[:] = eval(state) |
| |
| # _unique_id = 0 |
| # def get_unique_id(cls): |
| # Node._unique_id += 1 |
| # return Node._unique_id |
| # get_unique_id = classmethod(get_unique_id) |
| |
| def __hash__( self ): |
| return hash( tuple([hash(type(self))]+[hash(item) for item in self]) ) |
| |
| def clone(self): |
| l = [] |
| for item in self: |
| if isinstance(item,Node): |
| item = item.clone() |
| l.append(item) |
| return self.__class__(*l, **self.__dict__) |
| |
| def init_from( self, other ): # class method ? |
| # Warning: shallow init |
| self[:] = other |
| self.__dict__.update( other.__dict__ ) |
| return self |
| |
| # def is_struct(self): |
| # for x in self: |
| # if isinstance(x,Node): |
| # if x.is_struct(): |
| # return 1 |
| # return 0 |
| |
| |
| #def explain(self): |
| #l = [] |
| #for x in self: |
| #if isinstance(x,Node): |
| #l.append(x.explain()) |
| #else: |
| #l.append(str(x)) |
| #return string.join(l," ") |
| ##(self.__class__.__name__,string.join(l) ) |
| |
| def psource(self): |
| if hasattr(self,'lines'): |
| # print "# "+string.join(self.lines,"\n# ")+"\n" |
| print "# "+"\n# ".join(self.lines)+"\n" |
| |
| def cstr(self,l=None): |
| """ |
| Build a list of tokens; return the joined tokens string |
| """ |
| if l is None: |
| l = [] |
| for x in self: |
| if isinstance(x,Node): |
| x.cstr(l) |
| else: |
| l.insert(0,str(x)+' ') |
| s = ''.join(l) |
| return s |
| |
| def ctype(self): # anon_clone |
| " return clone of self without identifiers " |
| #print "%s.ctype()"%self |
| l=[] |
| for x in self: |
| if isinstance(x,Node): |
| l.append(x.ctype()) |
| else: |
| l.append(x) |
| #print "%s.__class__(*%s)"%(self,l) |
| return self.__class__(*l, **self.__dict__) # XX **self.__dict__ ? |
| |
| def cbasetype(self): |
| " return ctype with all TypeAlias's replaced " |
| # WARNING: we cache results (so do not mutate self!!) |
| l=[] |
| for x in self: |
| if isinstance(x,Node): |
| l.append(x.cbasetype()) |
| else: |
| l.append(x) |
| #print "%s.__class__(*%s)"%(self,l) |
| return self.__class__(*l, **self.__dict__) # XX **self.__dict__ ? |
| |
| def signature( self, tank=None ): |
| if tank is None: |
| tank = {} |
| for node in self.nodes(): |
| if not tank.has_key( type(node) ): |
| tank[ type(node) ] = {} |
| type(node).tank = tank[type(node)] |
| shape = tuple( [ type(_node).__name__ for _node in node ] ) |
| if not tank[type(node)].has_key(shape): |
| tank[type(node)][shape] = [] |
| tank[type(node)][shape].append( node ) |
| return tank |
| |
| def psig( self, tank=None ): |
| if tank is None: |
| tank = {} |
| tank = self.signature(tank) |
| for key in tank.keys(): |
| print key.__name__ |
| for shape in tank[key].keys(): |
| print " ", shape |
| |
| # |
| ################################################# |
| |
| class Named(genpyx.Named, Node): |
| " has a .name property " |
| def get_name(self): |
| if self: |
| assert type(self[0])==str |
| return self[0] |
| return None |
| def set_name(self, name): |
| if self: |
| self[0] = name |
| else: |
| self.append(name) |
| name = property(get_name,set_name) |
| |
| |
| class BasicType(genpyx.BasicType, Named): |
| "float double void char int" |
| pass |
| |
| class Qualifier(genpyx.Qualifier, Named): |
| "register signed unsigned short long const volatile inline" |
| pass |
| |
| class StorageClass(genpyx.StorageClass, Named): |
| "extern static auto" |
| pass |
| |
| class Ellipses(genpyx.Ellipses, Named): |
| "..." |
| pass |
| |
| class GCCBuiltin(genpyx.GCCBuiltin, BasicType): |
| "things with __builtin prefix" |
| pass |
| |
| class Identifier(genpyx.Identifier, Named): |
| """ |
| shape = +( str, +ConstExpr ) |
| """ |
| #def explain(self): |
| #if len(self)==1: |
| #return "%s"%self.name |
| #else: |
| #return "%s initialized to %s"%(self.name, |
| #Node(self[1]).explain()) # will handle Initializer |
| |
| # def ctype(self): |
| # return self.__class__(*self[1:]) #.clone() ? |
| |
| # def get_name(self): |
| # if self: |
| # return self[0] |
| # def set_name(self, name): |
| # if self: |
| # self[0] = name |
| # else: |
| # self.append(name) |
| # name = property(get_name,set_name) |
| |
| def cstr(self,l=None): |
| if l is None: |
| l=[] |
| if len(self)>1: |
| assert len(self)==2 |
| l.append( '%s = %s'%(self[0],self[1]) ) |
| elif len(self)==1: |
| l.append( str(self[0]) ) |
| return " ".join(l) |
| |
| class TypeAlias(genpyx.TypeAlias, Named): |
| """ |
| typedefed things, eg. size_t |
| |
| """ |
| def cbasetype( self ): |
| node = self.typedef.cbasetype().get_rest() |
| return node |
| |
| class Function(genpyx.Function, Node): |
| """ |
| """ |
| #def explain(self): |
| #if len(self): |
| #return "function (%s), returning"%\ |
| #", ".join( map(lambda x:x.explain(),self) ) |
| #else: |
| #return "function returning" |
| |
| def cstr(self,l): |
| #print '%s.cstr(%s)'%(self,l) |
| _l=[] |
| assert len(self) |
| i=0 |
| while isinstance(self[i],Declarator): |
| _l.append( self[i].cstr() ) |
| i=i+1 |
| l.append( '(%s)'% ', '.join(_l) ) |
| while i<len(self): |
| self[i].cstr(l) |
| i=i+1 |
| return " ".join(l) |
| |
| def return_type(self): |
| node = self[-1] |
| #assert isinstance(node,DeclarationSpecifiers) |
| return Declarator( Identifier(), node ) |
| ret = property(return_type) |
| |
| def get_args(self): |
| args = [ arg for arg in self[:-1] if not arg.is_void() ] |
| return args |
| args = property(get_args) |
| |
| def arg_types(self): |
| return [ AbstractDeclarator().init_from( arg.ctype() ) for arg in self[:-1]] |
| |
| def is_varargs(self): |
| for node in self.nodes(): |
| if isinstance(node,Ellipses) or 'va_list' in node: |
| # print self, 'is_varargs' |
| return True |
| # print self, 'is_varargs' |
| return False |
| # return fn.deepfind(Ellipses) or fn.deepfind('va_list') |
| |
| def ctype(self): |
| return Function(*self.arg_types()+[self[-1]]) # XX self[-1].ctype |
| |
| |
| class Pointer(genpyx.Pointer, Node): |
| """ |
| """ |
| def get_spec(self): |
| if type(self[0])==TypeSpecifiers: # isinstance ?? |
| return self[0] |
| spec = property(get_spec) |
| |
| #def explain(self): |
| #return "pointer to" |
| |
| def cstr(self,l): |
| assert len(self) |
| node=self[0] |
| l.insert(0,'*') |
| if isinstance(node,Function): |
| l.insert(0,'(') |
| l.append(')') |
| elif isinstance(node,Array): |
| l.insert(0,'(') |
| l.append(')') |
| return Node.cstr(self,l) |
| |
| class Array(genpyx.Array, Node): |
| """ |
| """ |
| #def explain(self): |
| #s='' |
| #if len(self): |
| #if type(self[0])==int: |
| #s='0 to %s '%(self[0]-1) |
| #return "array %sof"%s |
| def has_size(self): |
| try: |
| int(self.size) |
| return True |
| except: |
| return False |
| |
| def get_size(self): |
| if type(self[-1])==str: |
| try: return int(self[-1]) |
| except: return self[-1] |
| return self[-1] # None |
| size = property(get_size) |
| |
| def get_spec(self): |
| if type(self[0])==TypeSpecifiers: # isinstance ?? |
| return self[0] |
| spec = property(get_spec) |
| |
| def to_pointer(self): |
| node = Pointer() |
| node.init_from( self.clone() ) |
| node.pop() # pop the size element |
| return node |
| |
| def cstr(self,l): |
| if self.size is None: |
| l.append('[]') |
| else: |
| l.append('[%s]'%self.size) |
| return Node( *self[:-1] ).cstr( l ) |
| |
| class Tag(genpyx.Tag, Named): |
| " the tag of a Struct, Union or Enum " |
| pass |
| |
| class Taged(genpyx.Taged, Node): |
| "Struct, Union or Enum " |
| def get_tag(self): |
| if len(self): |
| tag = self[0] |
| assert type(tag)==Tag # isinstance ?? |
| else: |
| tag = None |
| return tag |
| def set_tag(self,tag): |
| if len(self): |
| self[0] = tag |
| else: |
| self.append(tag) |
| tag = property( get_tag, set_tag ) |
| def has_members(self): |
| return len(self)>1 # more than just a tag |
| def get_members(self): |
| return self[1:] |
| members = property(get_members) # fields ? |
| |
| def ctype(self): |
| if not self.tag.name: |
| #print "# WARNING : anonymous struct " # OK i think |
| return self.clone() |
| # self = self.clone() |
| # return self[:1] # just the tag |
| return self.__class__( self.tag, **self.__dict__ ) # just the Tag |
| # return self.__class__( *self, **self.__dict__ ) |
| |
| def cbasetype(self): |
| return self.ctype() # is this enough ??? |
| # return Node.cbasetype(self) # XX lookup my tag if i am empty ..? |
| |
| |
| class Compound(genpyx.Compound, Taged): |
| "Struct or Union" |
| |
| def cstr(self,_l=None): |
| assert isinstance( self[0], Tag ) |
| tag='' |
| if len(self[0]): |
| tag=' '+self[0][0] |
| if isinstance(self,Struct): |
| l=[ 'struct%s '%tag ] |
| elif isinstance(self,Union): |
| l=[ 'union%s '%tag ] |
| if len(self)>1: |
| l.append(' { ') |
| for decl in self[1:]: |
| l.append( decl.cstr()+"; " ) |
| l.append('} ') |
| if _l is None: |
| _l=[] |
| while l: |
| _l.insert( 0, l.pop() ) |
| # XX empty struct with no tag -> "struct" XX |
| return "".join( _l ) |
| |
| def ctype(self): |
| tp = Taged.ctype(self) |
| for i in range(1,len(tp)): |
| tp[i] = StructDeclarator().init_from( tp[i] ) |
| return tp |
| |
| class Struct(genpyx.Struct, Compound): |
| """ |
| """ |
| pass |
| |
| |
| class Union(genpyx.Union, Compound): |
| """ |
| """ |
| pass |
| |
| |
| class Enum(genpyx.Enum, Taged): |
| """ |
| """ |
| def cstr(self,_l=None): |
| assert isinstance( self[0], Tag ) |
| tag='' |
| if len(self[0]): |
| tag=' '+self[0][0] |
| l=[ 'enum%s '%tag ] |
| if len(self)>1: |
| l.append(' { ') |
| for node in self[1:]: |
| l.append( node.cstr()+', ' ) |
| l.append('} ') |
| if _l is None: |
| _l=[] |
| while l: |
| _l.insert( 0, l.pop() ) |
| return ''.join( _l ) |
| |
| class Declarator(genpyx.Declarator, Node): |
| """ |
| """ |
| |
| def __eq__(self,other): |
| " unordered equality " |
| # ordering sometimes gets lost when we do a cbasetype |
| if not isinstance(other,Node): |
| return False |
| a, b = self[:], other[:] |
| a.sort() |
| b.sort() |
| return a == b |
| |
| def __hash__( self ): |
| hs = [hash(item) for item in self] |
| hs.sort() |
| return hash( tuple([hash(type(self))]+hs) ) |
| |
| def transform(self): |
| return |
| |
| def get_identifier(self): |
| if len(self)>1: |
| return self[0] |
| def set_identifier(self, identifier): |
| if len(self)>1: |
| self[0] = identifier |
| else: |
| self.insert(0,identifier) |
| identifier = property(get_identifier,set_identifier) |
| |
| def get_spec(self): |
| spec = self[-1] |
| if type(spec)==TypeSpecifiers: # isinstance ?? |
| return spec |
| spec = property(get_spec) |
| |
| def get_type_alias(self): |
| if self.spec: |
| if isinstance(self.spec[0], TypeAlias): |
| return self.spec[0] |
| type_alias = property(get_type_alias) |
| |
| def get_tagged(self): |
| if self.spec: |
| return self.spec.tagged # i am a tagged |
| tagged = property(get_tagged) |
| |
| def get_compound(self): |
| if self.spec: |
| return self.spec.compound # i am a compound |
| compound = property(get_compound) |
| |
| def get_struct(self): |
| if self.spec: |
| return self.spec.struct # i am a struct |
| struct = property(get_struct) |
| |
| def get_union(self): |
| if self.spec: |
| return self.spec.union # i am a union |
| union = property(get_union) |
| |
| def get_enum(self): |
| if self.spec: |
| return self.spec.enum # i am an enum |
| enum = property(get_enum) |
| |
| def get_function(self): |
| if len(self)>1 and type(self[1])==Function: # isinstance ?? |
| return self[1] |
| function = property(get_function) |
| |
| def get_pointer(self): |
| if len(self)>1 and type(self[1])==Pointer: # isinstance ?? |
| return self[1] |
| pointer = property(get_pointer) |
| |
| def get_array(self): |
| if len(self)>1 and type(self[1])==Array: # isinstance ?? |
| return self[1] |
| array = property(get_array) |
| |
| def get_name(self): |
| if self.identifier: |
| return self.identifier.name |
| def set_name(self, name): |
| assert self.identifier is not None |
| self.identifier.name = name |
| name = property(get_name, set_name) |
| |
| def get_rest(self): # XX needs a better name |
| if len(self)>1: |
| return self[1] |
| return self[0] |
| |
| def pointer_to( self ): |
| " return Declarator pointing to self's type " |
| decl = Declarator(Identifier(), Pointer(self.get_rest().clone())) |
| return decl |
| |
| def deref( self ): |
| " return (clone of) Declarator that self is pointing to " |
| node = self.ctype() # clone |
| pointer = node.pointer or node.array |
| assert pointer, "cannot dereference non-pointer" |
| node[1:2] = pointer |
| return node |
| |
| def is_void(self): |
| return self.spec and BasicType('void') in self.spec |
| |
| def is_pointer_to_fn(self): |
| return self.pointer and self.deref().function |
| |
| def is_pointer_to_char(self): |
| # return self.ctype() == TransUnit("char *a;").transform()[0].ctype() |
| node = self.pointer or self.array |
| if node: |
| spec = node.spec |
| if spec and BasicType('char') in spec and not BasicType('unsigned') in spec: |
| return True |
| return False |
| |
| def is_callback(self): |
| " i am a pointer to a function whose last arg is void* " |
| if self.is_pointer_to_fn(): |
| fn = self.deref().function |
| if fn.args: |
| arg = fn.args[-1] |
| if arg.pointer and arg.deref().is_void(): |
| return True |
| |
| def is_complete( self, tag_lookup ): |
| if self.tagged and self.tagged.tag.name in tag_lookup and not tag_lookup[self.tagged.tag.name].has_members(): |
| return False |
| return True |
| |
| def is_primative( self ): |
| "i am a char,short,int,float,double... " |
| spec = self.cbasetype().spec |
| return spec and spec.find(BasicType) |
| |
| def is_pyxnative( self ): |
| # pyrex handles char* too |
| # but i don't know if we should make this the default |
| # sometimes we want to send a NULL, so ... XXX |
| self = self.cbasetype() |
| if self.is_void(): |
| return False |
| if self.is_primative(): |
| return True |
| if self.enum: |
| return True |
| # pointer = None |
| # if self.pointer: |
| # pointer = self.pointer |
| # elif self.array: |
| # pointer = self.array |
| # if pointer and pointer.spec: |
| # spec = pointer.spec |
| # if BasicType("char") in spec and not Qualifier("unsigned") in spec: |
| # # char*, const char* |
| ## print self.deepstr() |
| # return True |
| return False |
| |
| def cstr(self,l=None): |
| return Node.cstr(self,l).strip() |
| |
| def ctype(self): |
| decl=Declarator() |
| decl.init_from( self.clone() ) |
| decl.identifier = Identifier() |
| for i in range(1,len(decl)): |
| decl[i]=decl[i].ctype() |
| return decl |
| |
| def cbasetype(self): |
| # WARNING: we cache results (so do not mutate self!!) |
| try: |
| # this cache improves performance by 50% |
| return self.__cbasetype.clone() |
| except AttributeError: |
| pass |
| decl = self.ctype() # gets rid of Identifier names |
| for i, node in enumerate(decl): |
| decl[i] = decl[i].cbasetype() |
| # return decl.get_rest() |
| |
| done = False |
| while not done: |
| done = True |
| nodes = decl.deepfilter( TypeSpecifiers ) |
| for node in nodes: |
| if node.deepfind( TypeSpecifiers ) != node: |
| # this node has another TypeSpecifier; |
| decl.expose_node( node ) |
| done = False |
| break # start again... |
| |
| # each TypeSpecifier needs to absorb primitive siblings (StorageClass, BasicType etc.) |
| nodes = decl.deepfilter( TypeSpecifiers ) |
| for node in nodes: |
| parent = decl.get_parent(node) |
| i = 0 |
| while i < len(parent): |
| assert not type(parent[i]) in (TypeAlias, Enum, Struct, Union) |
| if type(parent[i]) in (StorageClass, BasicType, Qualifier): |
| node.append( parent.pop(i) ) |
| else: |
| i = i + 1 |
| |
| self.__cbasetype = decl.clone() |
| return decl |
| |
| def invalidate(self): |
| # flush cache, etc. |
| try: |
| del self.__cbasetype |
| except AttributeError: |
| pass |
| |
| def declare_str(self,name): |
| " return c string declaring name with same type as self " |
| tp = self.ctype() |
| tp.name = name |
| return tp.cstr()+";" |
| |
| class Typedef(genpyx.Typedef, Declarator): |
| def cstr(self,l=None): |
| return 'typedef ' + Declarator.cstr(self,l) #.strip() |
| |
| class AbstractDeclarator(genpyx.AbstractDeclarator, Declarator): |
| """ used in Function; may lack an identifier """ |
| |
| #def cstr(self,l=None): |
| #return Node.cstr(self,l) |
| |
| # def ctype(self): |
| # # _type_ ignores the name of our identifier |
| # return Node.ctype(self) |
| |
| class FieldLength(genpyx.FieldLength, Node): |
| """ |
| """ |
| #def explain(self): |
| #return "" |
| |
| def cstr(self,l): |
| l.append(':%s'%self[0]) |
| |
| class StructDeclarator(genpyx.StructDeclarator, Declarator): # also used in Union |
| """ |
| """ |
| #def explain(self): |
| #flen = self.find(FieldLength) |
| #if flen is not None: |
| #i = self.index(flen) |
| #self.pop(i) |
| #s = Declarator.explain(self) |
| #self.insert(i,flen) |
| #width = flen[0] |
| #if width > 0: |
| #return s+" bitfield %s wide"%width |
| #else: |
| #return s+" alignment bitfield" |
| #else: |
| #return Declarator.explain(self) |
| # def ctype(self): |
| # return self |
| def get_field_length(self): |
| if len(self)>1 and isinstance( self[1], FieldLength ): |
| return self[1] |
| field_length = property(get_field_length) |
| |
| |
| class DeclarationSpecifiers(genpyx.DeclarationSpecifiers, Node): |
| #class TypeSpecifiers(Node): |
| """ |
| """ |
| def __eq__(self,other): |
| " unordered equality " |
| if not isinstance(other,Node): |
| return False |
| a, b = self[:], other[:] |
| a.sort() |
| b.sort() |
| return a == b |
| |
| def __hash__( self ): |
| hs = [hash(item) for item in self] |
| hs.sort() |
| return hash( tuple([hash(type(self))]+hs) ) |
| |
| # def is_struct(self): |
| # return self.find(Struct) is not None |
| |
| |
| class TypeSpecifiers(genpyx.TypeSpecifiers, DeclarationSpecifiers): |
| """ |
| """ |
| def get_tagged(self): |
| if self and isinstance(self[0],Taged): |
| return self[0] |
| tagged = property(get_tagged) |
| |
| def get_compound(self): |
| if self and isinstance(self[0],Compound): |
| return self[0] |
| compound = property(get_compound) |
| |
| def get_struct(self): |
| if self and isinstance(self[0],Struct): |
| return self[0] |
| struct = property(get_struct) |
| |
| def get_union(self): |
| if self and isinstance(self[0],Union): |
| return self[0] |
| union = property(get_union) |
| |
| def get_enum(self): |
| if self and isinstance(self[0],Enum): |
| return self[0] |
| enum = property(get_enum) |
| |
| def cbasetype(self): |
| node = Node.cbasetype(self) |
| # node.expose( TypeSpecifiers ) |
| # if node.deepfind(TypeSpecifiers) != node: |
| return node |
| |
| class Initializer(genpyx.Initializer, Node): |
| """ |
| """ |
| pass |
| |
| |
| |
| class Declaration(genpyx.Declaration, Node): |
| """ |
| """ |
| def do_spec(self): |
| " distribute DeclarationSpecifiers over each Declarator " |
| spec=self[0] |
| assert isinstance(spec,DeclarationSpecifiers), spec.deepstr() |
| self.pop(0) |
| for declarator in self: |
| assert isinstance(declarator,Declarator) |
| #if isinstance(declarator,DeclarationSpecifiers #huh? |
| ##for node in spec: |
| ##declarator.append(node.clone()) |
| declarator.append(spec) |
| |
| def transform(self): |
| # children go first |
| for node in self.nodes(): |
| if isinstance(node,Declaration): |
| node.do_spec() |
| node.file = self.file # overkill ? |
| self.expose(Declaration) |
| |
| #def explain(self): |
| #return string.join([x.explain() for x in self],", ") |
| #return string.join(map(lambda x:x.explain(),self),", ") |
| |
| |
| class ParameterDeclaration(genpyx.ParameterDeclaration, Declaration): |
| """ |
| """ |
| pass |
| |
| |
| class StructDeclaration(genpyx.StructDeclaration, Declaration): |
| """ |
| """ |
| pass |
| |
| |
| class TransUnit(genpyx.TransUnit, Node): |
| """ |
| Top level node. |
| """ |
| def __init__( self, item ): # XX __init__ uses different signature ! XX |
| if type(item)==str: |
| node = cparse.TransUnit() |
| node.parse(item) |
| else: |
| node = item |
| assert isinstance( node, cparse.TransUnit ), str(node) |
| Node.__init__(self) |
| self[:] = [ self.convert(child) for child in node ] |
| self.__dict__.update( node.__dict__ ) |
| assert "name" not in node.__dict__ |
| |
| self.syms = {} # map identifier names to their Declarator's |
| self.typedefs = {} # map names to Typedef's |
| self.tag_lookup = {} # map struct, union, enum tags to Taged's |
| |
| # XX should call transform here XX |
| |
| # print self.deepstr() |
| def __getstate__( self ): |
| nodes = tuple( [ repr(node) for node in self ] ) |
| typedefs = tuple( [ (key,repr(val)) for key,val in self.typedefs.items() ] ) |
| return nodes, typedefs |
| def __setstate__( self, state ): |
| Node.__init__(self) |
| nodes, typedefs = state |
| nodes = [ eval(node) for node in nodes ] |
| self[:] = nodes |
| typedefs = [ (key,eval(val)) for key,val in typedefs ] |
| self.typedefs = dict(typedefs) |
| |
| def convert( self, node ): |
| # name = node.__class__.__name__ |
| # cls = globals()[ name ] |
| cls = cls_lookup[ type(node) ] |
| _node = cls() |
| for child in node: |
| if isinstance(child, node_module.Node): |
| child = self.convert( child ) |
| else: |
| assert child is None or type(child) in (str, int), type(child) |
| _node.append( child ) |
| _node.__dict__.update( node.__dict__ ) |
| return _node |
| |
| def strip(self,files): |
| " leave only the declarations from <files> " |
| i=0 |
| while i<len(self): |
| if self[i].file in files: |
| i=i+1 |
| else: |
| self.pop(i) |
| |
| def mark(self,cb,verbose=False): |
| " mark our child nodes such that cb(node).. mark dependants too. prune unmarked objects. " |
| # mark the nodes: |
| for node in self: |
| node.marked = cb(self, node) |
| if verbose and node.marked: |
| print '1:', node.cstr() |
| # propagate dependancy: |
| i=len(self) |
| while i: |
| i-=1 # we go backwards |
| for node in self[i].nodes(): # bottom-up search |
| if verbose and self[i].marked and not node.marked: |
| print '2:', str(node), '<--', self[i].cstr() |
| node.marked = self[i].marked or node.marked |
| if type(node)==TypeAlias: |
| if verbose and node.marked and not node.typedef.marked: |
| print '3:', node.typedef.cstr(), '<--', node.cstr() |
| node.typedef.marked = node.typedef.marked or node.marked |
| if isinstance(node, Taged): |
| if node.tag.name in self.tag_lookup: |
| _node = self.tag_lookup[ node.tag.name ] # look-up the def'n |
| if verbose and node.marked and not _node.marked: |
| print '4:', _node.cstr(), '<--', self[i].cstr() |
| # _node.marked = _node.marked or self[i].marked |
| _node.marked = _node.marked or node.marked |
| # else: |
| # # this guy has no tag |
| # print "lost tag:", self[i].cstr() |
| |
| # XX struct defs acquire marks from members, but XX |
| # XX ordinary definitions do not XX |
| # if node.marked and not self[i].marked: |
| # # one of my descendants is marked |
| # if verbose: |
| # print '5:', self[i].cstr(), '<--', node.cstr() |
| # self[i].marked = True |
| # if verbose: |
| # for node in self: |
| # print '-'*79 |
| # if node.enum: |
| # print str(node.marked) + ': ' + node.cstr() |
| # prune: |
| f = open(".tmp/pruned.txt","w") |
| f.write("// This file autogenerated by '%s' .\n"%__file__) |
| f.write("// List of functions pruned from parse tree, for various reasons.\n\n") |
| i=0 |
| while i<len(self): |
| if not self[i].marked: |
| if verbose: print 'pop:', self[i].cstr() |
| f.write( self[i].cstr() + "\n" ) |
| self.pop(i) |
| # elif self[i].compound: |
| # # XXXX for now, rip out all struct members XXXX |
| # self[i].compound[1:] = [] # XX encapsulation |
| # i = i + 1 |
| else: |
| i = i + 1 |
| for key, value in self.syms.items(): |
| if not value.marked: |
| del self.syms[key] |
| for key, value in self.typedefs.items(): |
| if not value.marked: |
| del self.typedefs[key] |
| for key, value in self.tag_lookup.items(): |
| if not value.marked: |
| del self.tag_lookup[key] |
| # sys.exit(1) |
| |
| def assert_no_dups(self): |
| check={} |
| for node in self.nodes(): |
| assert not check.has_key(id(node)) |
| check[id(node)]=1 |
| |
| def transform(self, verbose=False, test_parse=False, test_types=False ): |
| i=0 |
| while i < len(self): |
| if verbose: print "##"*25 |
| declaration=self[i] |
| |
| if verbose: declaration.psource() |
| if verbose: print declaration.deepstr(),'\n' |
| assert isinstance(declaration,Declaration) |
| if verbose: print "# expose declarators from declaration" |
| |
| # STAGE 1 |
| declaration.transform() |
| |
| if verbose: print declaration.deepstr(),'\n' |
| self[i:i+1] = declaration # expose declarators from declaration |
| |
| for j in range(len(declaration)): |
| declarator=self[i] |
| |
| assert isinstance(declarator,Declarator) |
| if verbose: print "# declarator.transform()" |
| |
| # STAGE 2 |
| declarator.transform() |
| |
| if verbose: print declarator.deepstr(),'\n' |
| if verbose: print "# self.visit_declarator(declarator)" |
| |
| # STAGE 3 |
| self[i] = declarator = self.visit_declarator(declarator) |
| |
| # STAGE 4 |
| if declarator.name: |
| if isinstance(declarator, Typedef): |
| if verbose: print "# typedef %s" % declarator.name |
| self.typedefs[ declarator.name ] = declarator |
| else: |
| if verbose: print "# sym %s" % declarator.name |
| self.syms[ declarator.name ] = declarator |
| |
| for node in declarator.nodes(): |
| if isinstance(node,Taged) and node.tag.name: |
| assert type(node.tag.name)==str, node.deepstr() |
| taged = self.tag_lookup.get( node.tag.name, None ) |
| if taged is None: |
| if verbose: print "# tag lookup %s = %s" % (declarator.name, node.tag.name) |
| self.tag_lookup[ node.tag.name ] = node |
| elif not taged.has_members(): |
| # this is (maybe) the definition of this tag |
| if verbose: print "# definition %s = %s" % (declarator.name, node.tag.name) |
| self.tag_lookup[ node.tag.name ] = node |
| |
| # Annotate the TypeAlias's |
| for node in declarator.deepfilter( TypeAlias ): |
| name = node[0] |
| assert type( name ) == str |
| node.typedef = self.typedefs[ name ] |
| |
| if verbose: print declarator.deepstr(),'\n' |
| #print declarator.ctype().deepstr(),'\n' |
| #assert declarator.clone() == declarator |
| |
| ################################################### |
| # TESTS: |
| if test_parse: |
| # test that parse of cstr gives same answer |
| cstr = declarator.cstr()+';\n' |
| if verbose: print '# '+cstr.replace('\n','\n# ') |
| #print |
| if isinstance(declarator,Typedef): |
| name = declarator[0][0] |
| assert type(name)==str |
| self.lexer.rmtypedef( name ) |
| declaration = cparse.Declaration() |
| self.lexer.lex( cstr ) |
| #print self.lexer.err_string() |
| declaration.parse( self.lexer, Symbols() ) # use new name-space |
| #declaration.parse( Lexer( cstr ), Symbols() ) |
| declaration = self.convert(declaration) |
| declaration.transform() |
| assert len(declaration)==1 |
| decl=declaration[0] |
| decl.transform() |
| decl = self.visit_declarator(decl) |
| if decl!=declarator: |
| if verbose: print "#???????????" |
| if verbose: print decl.deepstr(),'\n\n' |
| #if verbose: print declaration.deepstr(),'\n\n' |
| #assert 0 |
| elif verbose: print '# OK\n' |
| |
| if test_types: |
| node = declarator.ctype() |
| declare_str= node.declare_str("my_name") |
| if verbose: print "# declarator.ctype() " |
| if verbose: print node.deepstr(),"\n" |
| if verbose: print "#",declare_str.replace('\n','\n# '), '\n' |
| |
| i=i+1 |
| return self |
| |
| def visit(self,node): |
| #print 'visit(%s)'%node |
| for _node in node: |
| if isinstance(_node,Declarator): |
| _node = self.visit_declarator(_node) # XX replace _node |
| elif isinstance(_node,Node): |
| _node = self.visit(_node) # XX replace _node |
| return node |
| |
| def visit_declarator(self,decl): |
| assert isinstance(decl,Declarator) |
| |
| # STAGE 3.a |
| tp = decl.deepfind(Typedef) |
| if tp is not None: |
| decl.deeprm(tp) |
| tp.init_from( decl ) # warning: shallow init |
| decl = tp |
| |
| # STAGE 3.b |
| i=len(decl) |
| # accumulate nodes (they become the children of decl) |
| children=[] |
| while i: |
| i=i-1 |
| node=decl.pop(i) |
| if isinstance(node,Declarator): |
| node = self.visit_declarator(node) # replace node |
| else: |
| node = self.visit(node) # replace node |
| if isinstance(node,Pointer): |
| node+=children |
| children=[node] |
| elif isinstance(node,Function): |
| node+=children |
| children=[node] |
| elif isinstance(node,Array): |
| while children: |
| node.insert(0,children.pop()) |
| children=[node] |
| # array size (if any) at end |
| #elif isinstance(node,Identifier): |
| #node+=children |
| #children=[node] |
| else: |
| # accumulate |
| children.insert(0,node) |
| decl[:]=children |
| return decl |
| |
| cstr = None |
| ctype = None |
| cbasetype = None |
| |
| |
| # remap the global class definitions in genpyx to |
| # point to the definitions in this module |
| gbl = globals() |
| for key, val in gbl.items(): |
| if type(val)==type: |
| if issubclass(val,Node): |
| setattr( genpyx, key, val ) |
| assert genpyx.Node == Node |
| |
| cls_lookup = { |
| # Node : Node , |
| cparse.BasicType : BasicType , |
| cparse.Qualifier : Qualifier , |
| cparse.StorageClass : StorageClass , |
| cparse.Ellipses : Ellipses , |
| cparse.GCCBuiltin : GCCBuiltin , |
| cparse.Identifier : Identifier , |
| cparse.TypeAlias : TypeAlias , |
| cparse.Function : Function , |
| cparse.Pointer : Pointer , |
| cparse.Array : Array , |
| cparse.Tag : Tag , |
| cparse.Compound : Compound , |
| cparse.Struct : Struct , |
| cparse.Union : Union , |
| cparse.Enum : Enum , |
| cparse.Declarator : Declarator , |
| cparse.Typedef : Typedef , |
| cparse.AbstractDeclarator : AbstractDeclarator , |
| cparse.FieldLength : FieldLength , |
| cparse.StructDeclarator : StructDeclarator , |
| cparse.DeclarationSpecifiers : TypeSpecifiers , |
| cparse.TypeSpecifiers : TypeSpecifiers , |
| cparse.Initializer : Initializer , |
| cparse.Declaration : Declaration , |
| cparse.ParameterDeclaration : ParameterDeclaration , |
| cparse.StructDeclaration : StructDeclaration , |
| cparse.TransUnit : TransUnit , |
| } |
| |
| |
