idl-parser 0.0.10__py2.7.egg

idl_parser/struct.py

@@ -0,0 +1,145 @@
+import os, sys, traceback
+
+from . import node
+from . import type as idl_type
+
+
+class IDLMember(node.IDLNode):
+    def __init__(self, parent):
+        super(IDLMember, self).__init__('IDLMember', '', parent)
+        self._verbose = True
+        self._type = None
+        self.sep = '::'
+    
+    @property
+    def full_path(self):
+        return self.parent.full_path + self.sep + self.name
+
+    def parse_blocks(self, blocks, filepath=None):
+        self._filepath = filepath
+        name, typ = self._name_and_type(blocks)
+        if name.find('[') >= 0:
+            name_ = name[:name.find('[')]
+            typ = typ.strip() + ' ' + name[name.find('['):]
+            name = name_
+        self._name = name
+        self._type = idl_type.IDLType(typ, self)
+
+    def to_simple_dic(self, recursive=False, member_only=False):
+        if recursive:
+            if self.type.is_primitive:
+                return str(self.type) + ' ' + self.name
+            elif self.type.obj.is_enum:
+                return str('enum') + ' ' + self.name
+            dic = {str(self.type) +' ' + self.name : 
+                   self.type.obj.to_simple_dic(recursive=recursive, member_only=True)}
+            return dic
+        dic = {self.name : str(self.type) }
+        return dic
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'filepath' : self.filepath, 
+                'classname' : self.classname,
+                'type' : str(self.type) }
+        return dic
+
+    @property
+    def type(self):
+        if self._type.classname == 'IDLBasicType': # Struct
+            return self.root_node.find_types(self._type.name)[0]
+        return self._type
+
+    def get_type(self, extract_typedef=False):
+        if extract_typedef:
+            if self.type.is_typedef:
+                return self.type.type
+        return self.type
+    
+
+    def post_process(self):
+        #self._type = self.refine_typename(self.type)
+        pass
+                
+
+class IDLStruct(node.IDLNode):
+    
+    def __init__(self, name, parent):
+        super(IDLStruct, self).__init__('IDLStruct', name.strip(), parent)
+        self._verbose = True
+        self._members = []
+        self.sep = '::'
+        
+    @property
+    def full_path(self):
+        return (self.parent.full_path + self.sep + self.name).strip()
+
+    def to_simple_dic(self, quiet=False, full_path=False, recursive=False, member_only=False):
+        name = self.full_path if full_path else self.name
+        if quiet:
+            return 'struct %s' % name 
+        
+        dic = { 'struct %s' % name : [v.to_simple_dic(recursive=recursive) for v in self.members] }
+
+        if member_only:
+            return dic.values()[0]
+        return dic
+                    
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'classname' : self.classname,
+                'members' : [v.to_dic() for v in self.members] }
+        return dic
+    
+    def parse_tokens(self, token_buf, filepath=None):
+        self._filepath = filepath
+        kakko = token_buf.pop()
+        if not kakko == '{':
+            if self._verbose: sys.stdout.write('# Error. No kakko "{".\n')
+            raise InvalidIDLSyntaxError()
+        
+        block_tokens = []        
+        while True:
+
+            token = token_buf.pop()
+            if token == None:
+                if self._verbose: sys.stdout.write('# Error. No kokka "}".\n')
+                raise InvalidIDLSyntaxError()
+            
+            elif token == '}':
+                token = token_buf.pop()
+                if not token == ';':
+                    if self._verbose: sys.stdout.write('# Error. No semi-colon after "}".\n')
+                    raise InvalidIDLSyntaxError()
+                break
+            
+            if token == ';':
+                self._parse_block(block_tokens)
+                block_tokens = []
+                continue
+            block_tokens.append(token)
+
+        self._post_process()
+            
+    def _parse_block(self, blocks):
+        v = IDLMember(self)
+        v.parse_blocks(blocks, self.filepath)
+        self._members.append(v)
+    
+    def _post_process(self):
+        self.forEachMember(lambda m : m.post_process())
+
+    @property
+    def members(self):
+        return self._members
+
+    def member_by_name(self, name):
+        for m in self._members:
+            if m.name == name:
+                return m
+    
+        return None
+    def forEachMember(self, func):
+        for m in self._members:
+            func(m)

idl_parser/token_buffer.py

@@ -0,0 +1,25 @@
+
+
+class TokenBuffer():
+    
+    def __init__(self, lines):
+        self._tokens = []
+        self._token_offset = 0
+        for line in lines:
+            ts = line.split(' ')
+            for t in ts:
+                if len(t.strip()) != 0:
+                    self._tokens.append(t.strip())
+
+    @property
+    def t_debug(self):
+        return self._tokens
+
+    def pop(self):
+        if len(self._tokens) == self._token_offset:
+            return None
+        t = self._tokens[self._token_offset].strip()
+        self._token_offset = self._token_offset + 1
+        return t.strip()
+
+    

idl_parser/type.py

@@ -0,0 +1,249 @@
+import os, sys, traceback
+
+from . import node
+
+sep = '::'
+
+primitive = [
+    'boolean',
+    'char', 'byte', 'octet', 
+    'short', 'wchar', 
+    'long', 
+    'float',
+    'double',
+    'string',
+    'wstring']
+           
+def is_primitive(name):
+    for n in name.split(' '):
+        if n in primitive:
+            return True
+    return False
+
+def IDLType(name, parent):
+    if name == 'void':
+        return IDLVoid(name, parent)
+
+    elif name.find('sequence') >= 0:
+        return IDLSequence(name, parent)
+    elif name.find('[') >= 0:
+        return IDLArray(name, parent)
+
+    if is_primitive(name):
+        return IDLPrimitive(name, parent)
+
+    return IDLBasicType(name, parent)
+
+class IDLTypeBase(node.IDLNode):
+    def __init__(self, classname, name, parent):
+        super(IDLTypeBase, self).__init__(classname, name, parent.root_node)
+        self._is_sequence = False
+        self._is_primitive = False
+
+    def __str__(self):
+        return self.name
+
+    @property
+    def is_sequence(self):
+        return self._is_sequence
+
+    @property
+    def is_primitive(self):
+        return self._is_primitive
+
+
+class IDLVoid(IDLTypeBase):
+    def __init__(self, name, parent):
+        super(IDLVoid, self).__init__('IDLVoid', name, parent.root_node)
+        self._verbose = True
+
+class IDLSequence(IDLTypeBase):
+    def __init__(self, name, parent):
+        super(IDLSequence, self).__init__('IDLSequence', name, parent.root_node)
+        self._verbose = True
+        if name.find('sequence') < 0:
+            raise InvalidIDLSyntaxError()
+        typ_ = name[name.find('<')+1 : name.find('>')]
+        self._type = IDLType(typ_, parent)        
+        self._is_primitive = False #self.inner_type.is_primitive
+        self._is_sequence = True
+
+    @property
+    def inner_type(self):
+        return self._type
+
+    def __str__(self):
+        return 'sequence<%s>' % str(self.inner_type)
+    
+    @property
+    def obj(self):
+        return self
+
+
+    def __hoge(self):
+        global_module = self.root_node
+        typs = global_module.find_types(self.inner_type)
+        # print self.inner_type
+        if len(typs) == 0:
+            # print 'None'
+            return None
+        else:
+            # print typs[0]
+            return typs[0]
+
+    @property
+    def type(self):
+        return self._type
+
+    @property
+    def full_path(self):
+        return self.parent.full_path + sep + self.name
+
+    def to_simple_dic(self, quiet=False, full_path=False, recursive=False, member_only=False):
+        name = self.full_path if full_path else self.name
+        if quiet:
+            return 'sequence<%s>' % str(self.inner_type)
+
+        if recursive:
+            if self.type.is_primitive:
+                return { 'sequence<%s>' % str(self.type) : str(self.type)}
+            else:
+                return { 'sequence<%s>' % str(self.type) : self.type.obj.to_simple_dic(recursive=recursive, member_only=True)}
+        """
+            n = 'typedef ' + str(self.type) +' ' + name
+            if not self.type.is_primitive:
+                dic = { n : (self.type.obj.to_simple_dic(recursive=recursive, member_only=True))}
+            else:
+                dic = { n : str(self.type) }
+            if member_only:
+                return dic
+            return {name : dic}
+
+        dic = 'typedef %s %s' % (self.type, name)
+        return dic
+        """
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'classname' : self.classname,
+                'type' : str(self.type) }
+        return dic
+
+class IDLArray(IDLTypeBase):
+    def __init__(self, name, parent):
+        super(IDLArray, self).__init__('IDLArray', name.strip(), parent.root_node)
+
+        self._verbose = True
+        if name.find('[') < 0:
+            raise InvalidIDLSyntaxError()
+        primitive_type_name = name[:name.find('[')]
+        size = name[name.find('[')+1 : name.find(']')]
+        inner_type_name = primitive_type_name + name[name.find(']')+1:]
+        self._size = int(size)
+        self._type = IDLType(inner_type_name.strip(), parent)
+        self._is_primitive = False #self.inner_type.is_primitive
+        self._is_sequence = False
+        self._is_array = True
+
+
+    @property
+    def inner_type(self):
+        return self._type
+
+    @property
+    def primitive_type(self):
+        if self.inner_type.is_array:
+            return self.inner_type.primitive_type
+        else:
+            return self.inner_type
+
+    def __str__(self):
+        n = ['%s' % self.primitive_type.name]
+        def _apply_size(typ):
+            n[0] = n[0] + '[%s]' % typ.size
+            if typ.inner_type.is_array:
+                _apply_size(typ.inner_type)
+        
+        _apply_size(self)
+        return n[0]
+    
+    @property
+    def obj(self):
+        return self
+    
+    @property
+    def size(self):
+        return self._size
+
+    def __hoge(self):
+        global_module = self.root_node
+        typs = global_module.find_types(self.inner_type)
+        # print self.inner_type
+        if len(typs) == 0:
+            # print 'None'
+            return None
+        else:
+            # print typs[0]
+            return typs[0]
+
+    @property
+    def type(self):
+        return self._type
+
+    @property
+    def full_path(self):
+        return self.parent.full_path + sep + self.name
+
+    def to_simple_dic(self, quiet=False, full_path=False, recursive=False, member_only=False):
+        name = self.full_path if full_path else self.name
+        if quiet:
+            return str(self)
+
+        if recursive:
+            if self.type.is_primitive:
+                return str(self) 
+            else:
+                return str(self) 
+        """
+            n = 'typedef ' + str(self.type) +' ' + name
+            if not self.type.is_primitive:
+                dic = { n : (self.type.obj.to_simple_dic(recursive=recursive, member_only=True))}
+            else:
+                dic = { n : str(self.type) }
+            if member_only:
+                return dic
+            return {name : dic}
+
+        dic = 'typedef %s %s' % (self.type, name)
+        return dic
+        """
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'classname' : self.classname,
+                'type' : str(self.type) }
+        return dic
+
+        
+class IDLPrimitive(IDLTypeBase):
+    def __init__(self, name, parent):
+        super(IDLPrimitive, self).__init__('IDLPrimitive', name, parent.root_node)
+        self._verbose = True
+        self._is_primitive = True
+
+class IDLBasicType(IDLTypeBase):
+    def __init__(self, name, parent):
+        super(IDLBasicType, self).__init__('IDLBasicType', name, parent.root_node)
+        self._verbose = True
+        #if self.name.find('['):
+        #    self._name = self.name[self.name.find('[')+1:]
+        self._name = self.refine_typename(self.name)
+        
+    @property
+    def obj(self):
+        global_module = self.root_node
+        typs = global_module.find_types(self.name)
+        if len(typs) == 0:
+            return None
+        else:
+            return typs[0]

idl_parser/typedef.py

@@ -0,0 +1,85 @@
+from . import node
+from . import type as idl_type
+sep = '::'
+
+class IDLTypedef(node.IDLNode):
+    
+    def __init__(self, parent):
+        super(IDLTypedef, self).__init__('IDLTypedef', '', parent)
+        self._verbose = True
+        self._type = None
+
+    @property
+    def full_path(self):
+        return self.parent.full_path + sep + self.name
+
+    def to_simple_dic(self, quiet=False, full_path=False, recursive=False, member_only=False):
+        name = self.full_path if full_path else self.name
+        if quiet:
+            return 'typedef ' + name
+
+        if recursive:
+            n = 'typedef ' + str(self.type) +' ' + name
+            if not self.type.is_primitive:
+                dic = { n : (self.type.obj.to_simple_dic(recursive=recursive, member_only=True))}
+            else:
+                dic = { n : str(self.type) }
+            if member_only:
+                return dic
+            return {name : dic}
+
+        dic = 'typedef %s %s' % (self.type, name)
+        return dic
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'classname' : self.classname,
+                'type' : str(self.type) }
+        return dic
+
+    @property
+    def type(self):
+        if self._type.classname == 'IDLBasicType': # Struct
+            return self.root_node.find_types(self._type.name)[0]
+        return self._type
+
+    def get_type(self, extract_typedef=False):
+        if extract_typedef:
+            if self.type.is_typedef:
+                return self.type.type
+        return self.type
+
+    
+    def parse_blocks(self, blocks, filepath=None):
+        self._filepath = filepath
+        type_name_ = ''
+        rindex = 1
+        name = blocks[-rindex]
+        while True:
+            if name.find('[') < 0:
+                break
+            
+            if name.find('[') > 0:
+                type_name_ = name[name.find('['):]
+                name = name[:name.find('[')]
+                #rindex = rindex + 1
+                break
+
+            type_name_ = name + type_name_
+            rindex = rindex + 1
+            name = blocks[-rindex]
+
+        type_name = ''
+        for t in blocks[:-rindex]:
+            type_name = type_name + ' ' + t
+        type_name = type_name + ' ' + type_name_
+        type_name = type_name.strip()
+
+        self._type = idl_type.IDLType(type_name, self)
+        self._name = name
+
+        self._post_process()
+
+    def _post_process(self):
+        #self._type = self.refine_typename(self.type)
+        pass