idl-parser 0.0.1__tar.gz

idl_parser-0.0.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 1.1
+Name: idl_parser
+Version: 0.0.1
+Summary: OMG IDL Parser
+Home-page: http://www.sugarsweetrobotics.com/
+Author: ysuga
+Author-email: ysuga@ysuga.net
+License: GPLv3
+Download-URL: https://github.com/sugarsweetrobotics/idl_parser
+Description: UNKNOWN
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering

idl_parser-0.0.1/idl_parser/__init__.py

@@ -0,0 +1,7 @@
+#from parser import IDLParser
+__all__=['parser']
+
+
+
+    
+    

idl_parser-0.0.1/idl_parser/const.py

@@ -0,0 +1,50 @@
+import os, sys, traceback
+
+from . import node
+sep = '::'
+
+
+class IDLConst(node.IDLNode):
+    
+    def __init__(self, name, typename, value, parent, filepath=None):
+        super(IDLConst, self).__init__('IDLConst', name, parent)
+        self._typename = typename
+        self._verbose = True
+        self._value = value
+        self._filepath= filepath
+
+    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 'const %s %s = %s' % (self.typename, name, self.value)
+        dic = { 'const %s' % name : { 'type' : self.typename,
+                                      'value' : self.value } }
+        return dic
+                    
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'filepath' : self.filepath,
+                'classname' : self.classname,
+                'typename' : self.typename,
+                'value' : self.value }
+        return dic
+
+    @property
+    def typename(self):
+        return self._typename
+    
+    @property
+    def type(self):
+        return self.root_node.find_types(self.typename)[0]
+    @property
+    def value(self):
+        return self._value
+
+    @property
+    def value_string(self):
+        return self._value
+
+    @property
+    def full_path(self):
+        return self.parent.full_path + sep + self.name
+    

idl_parser-0.0.1/idl_parser/enum.py

@@ -0,0 +1,114 @@
+import os, sys, traceback
+
+from . import node
+sep = '::'
+
+class IDLEnumValue(node.IDLNode):
+    def __init__(self, value, parent):
+        super(IDLEnumValue, self).__init__('IDLEnumValue', '', parent)
+        self._verbose = True
+        self._value = value
+
+    def parse_blocks(self, blocks, filepath=None):
+        self._filepath = filepath
+        if len(blocks) == 1:
+            self._name = blocks[0]
+        else:
+            sys.stdout.write('Unkown Enum format %s\n' % blocks)
+        #name, type = self._name_and_type(blocks)
+        #self._name = name
+        #self._type = type
+
+    @property
+    def full_path(self):
+        return self.full_path + '.' + self.name
+
+    def to_simple_dic(self):
+        dic = {self.name : self.value }
+        return dic
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'filepath' : self.filepath,
+                'classname' : self.classname,
+                'value' : self.value }
+        return dic
+    @property
+    def value(self):
+        return self._value
+    
+
+
+
+class IDLEnum(node.IDLNode):
+    
+    def __init__(self, name, parent):
+        super(IDLEnum, self).__init__('IDLEnum', name, parent)
+        self._verbose = True
+        self._values = []
+
+    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 'enum %s' % name 
+        dic = { 'enum %s' % name : [v.to_simple_dic() for v in self.values] }
+        return dic
+                    
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'classname' : self.classname,
+                'values' : [v.to_dic() for v in self.values] }
+        return dic
+
+    @property
+    def full_path(self):
+        return self.parent.full_path + sep + self.name
+    
+    def parse_tokens(self, token_buf, filepath=None):
+        self._filepath = filepath
+        self._counter = 0
+        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()
+
+                if len(block_tokens) > 0:
+                    self._parse_block(block_tokens)
+                break
+            
+            if token == ',':
+                self._parse_block(block_tokens)
+                block_tokens = []
+                continue
+            block_tokens.append(token)
+            
+    def _parse_block(self, blocks):
+        v = IDLEnumValue(self._counter, self)
+        self._counter = self._counter+ 1
+        v.parse_blocks(blocks, self.filepath)
+        self._values.append(v)
+
+    @property
+    def values(self):
+        return self._values
+
+
+    def value_by_name(self, name):
+        for m in self.values:
+            if m.name == name:
+                return m
+        return None

idl_parser-0.0.1/idl_parser/interface.py

@@ -0,0 +1,207 @@
+from . import node
+
+from . import type as idl_type
+
+sep = '::'
+
+class IDLArgument(node.IDLNode):
+    def __init__(self, parent):
+        super(IDLArgument, self).__init__('IDLArgument', '', parent)
+        self._verbose = True
+        self._dir = 'in'
+        self._type = None
+
+    def parse_blocks(self, blocks, filepath=None):
+        self._filepath= filepath
+        directions = ['in', 'out', 'inout']
+        self._dir = 'in'
+        if blocks[0] in directions:
+            self._dir = blocks[0]
+            blocks.pop(0)
+            pass
+        argument_name, argument_type = self._name_and_type(blocks)
+        self._name = argument_name
+        self._type = idl_type.IDLType(argument_type, self)
+
+    def to_simple_dic(self):
+        dic = '%s %s %s' % (self.direction, self.type, self.name)
+        return dic
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'classname' : self.classname,
+                'type' : str(self.type),
+                'direction' : self.direction,
+                'filepath' : self.filepath }
+        return dic
+
+    @property
+    def direction(self):
+        return self._dir
+
+    @property
+    def type(self):
+        return self._type
+
+    def post_process(self):
+        #self._type = self.refine_typename(self.type)
+        pass
+
+        
+class IDLMethod(node.IDLNode):
+    def __init__(self, parent):
+        super(IDLMethod, self).__init__('IDLValue', '', parent)
+        self._verbose = True
+        self._returns = None
+        self._arguments = []
+
+    def parse_blocks(self, blocks, filepath=None):
+        self._filepath=filepath
+
+        if blocks[0] == 'oneway':
+            self._oneway = True
+            blocks.pop(0)
+        else:
+            self._oneway = False
+
+        self._returns = idl_type.IDLType(blocks[0], self)
+        self._name = blocks[1]
+        self._arguments = []
+
+        if not blocks[2] == '(':
+            print(' -- Invalid Interface Token (%s)' % interface_name)
+            print( blocks)
+            
+        index = 3
+        argument_blocks = []
+        while True:
+            if index == len(blocks):
+                break
+            token = blocks[index]
+            if token == ',' or token == ')':
+                if len(argument_blocks) == 0:
+                    break
+
+                a = IDLArgument(self)
+                self._arguments.append(a)
+                a.parse_blocks(argument_blocks, self.filepath)
+
+                argument_blocks = []
+            else:
+                argument_blocks.append(token)
+            index = index + 1
+
+    def to_simple_dic(self):
+        return {self.name : {
+                'returns' : str(self.returns),
+                'params' : [a.to_simple_dic() for a in self.arguments]}}
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'filepath' : self.filepath,
+                'classname' : self.classname,
+                'returns' : str(self._returns),
+                'arguments' : [a.to_dic() for a in self.arguments]}
+        return dic
+
+    @property
+    def returns(self):
+        return self._returns
+
+    @property
+    def arguments(self):
+        return self._arguments
+
+    def argument_by_name(self, name):
+        for a in self.arguments:
+            if a.name == name:
+                return a
+
+        return None
+
+
+    def forEachArgument(self, func):
+        for a in self.arguments:
+            func(a)
+
+    def post_process(self):
+        #self._returns = self.refine_typename(self.returns)
+        #self.forEachArgument(lambda a : a.post_process())
+        pass
+
+class IDLInterface(node.IDLNode):
+    
+    def __init__(self, name, parent):
+        super(IDLInterface, self).__init__('IDLInterface', name, parent)
+        self._verbose = True
+        self._methods = []
+        
+    @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):
+        if quiet:
+            return 'interface %s' % self.name
+        dic = { 'interface ' + self.name : [m.to_simple_dic() for m in self.methods] }
+        return dic
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'filepath' : self.filepath, 
+                'classname' : self.classname,
+                'methods' : [m.to_dic() for m in self.methods] }
+        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 _post_process(self):
+        self.forEachMethod(lambda m : m.post_process())
+
+    def _parse_block(self, blocks):
+        v = IDLMethod(self)
+        v.parse_blocks(blocks, self.filepath)
+        self._methods.append(v)
+
+    @property
+    def methods(self):
+        return self._methods
+
+    def method_by_name(self, name):
+        for m in self.methods:
+            if name == m.name:
+                return m
+        return None
+
+    def forEachMethod(self, func):
+        for m in self.methods:
+            func(m)
+
+        

idl_parser-0.0.1/idl_parser/module.py

@@ -0,0 +1,259 @@
+import os, sys, traceback
+
+from . import node, type
+from . import struct, typedef, interface, enum, const
+global_namespace = '__global__'
+sep = '::'
+
+class IDLModule(node.IDLNode):
+
+    def __init__(self, name=None, parent = None):
+        super(IDLModule, self).__init__('IDLModule', name, parent)
+        self._verbose = False
+        if name is None:
+            self._name = global_namespace
+            
+        self._interfaces = []
+        self._typedefs = []
+        self._structs = []
+        self._enums = []
+        self._consts = []
+        self._modules = []
+
+    @property
+    def is_global(self):
+        return self.name == global_namespace
+        
+    @property
+    def full_path(self):
+        if self.parent is None:
+            return '' # self.name
+        else:
+            if len(self.parent.full_path) == 0:
+                return self.name
+            return self.parent.full_path + sep + self.name
+
+    def to_simple_dic(self, quiet=False):
+        dic = {'module %s' % self.name : [s.to_simple_dic(quiet) for s in self.structs] +
+               [i.to_simple_dic(quiet) for i in self.interfaces] +
+               [m.to_simple_dic(quiet) for m in self.modules] + 
+               [e.to_simple_dic(quiet) for e in self.enums] + 
+               [t.to_simple_dic(quiet) for t in self.typedefs] + 
+               [t.to_simple_dic(quiet) for t in self.consts]}
+        return dic
+
+    def to_dic(self):
+        dic = { 'name' : self.name,
+                'filepath' : self.filepath, 
+                'classname' : self.classname,
+                'interfaces' : [i.to_dic() for i in self.interfaces],
+                'typedefs' : [t.to_dic() for t in self.typedefs],
+                'structs' : [s.to_dic() for s in self.structs],
+                'enums' : [e.to_dic() for e in self.enums],
+                'modules' : [m.to_dic() for m in self.modules],
+                'consts' : [c.to_dic() for c in self.consts] }
+        return dic
+    
+
+    def parse_tokens(self, token_buf, filepath=None):
+        self._filepath = filepath
+        if not self.name == global_namespace:
+            kakko = token_buf.pop()
+            if not kakko == '{':
+                if self._verbose: sys.stdout.write('# Error. No kakko "{".\n')
+                raise InvalidIDLSyntaxError()
+
+        while True:
+            token = token_buf.pop()
+            if token == None:
+                if self.name == global_namespace:
+                    break
+                if self._verbose: sys.stdout.write('# Error. No kokka "}".\n')
+                raise InvalidIDLSyntaxError()
+            elif token == 'module':
+                name_ = token_buf.pop()
+                m = self.module_by_name(name_)
+                if m == None:
+                    m = IDLModule(name_, self)
+                    self._modules.append(m)
+                m.parse_tokens(token_buf, filepath=filepath)
+            elif token == 'typedef':
+                blocks = []
+                while True:
+                    t = token_buf.pop()
+                    if t == None:
+                        raise InvalidIDLSyntaxError()
+                    elif t == ';':
+                        break
+                    else:
+                        blocks.append(t)
+                t = typedef.IDLTypedef(self)
+                self._typedefs.append(t)
+                t.parse_blocks(blocks, filepath=filepath)
+            elif token == 'struct':
+                name_ = token_buf.pop()
+                s_ = self.struct_by_name(name_)
+                s = struct.IDLStruct(name_, self)
+                s.parse_tokens(token_buf, filepath=filepath)
+                if s_:
+                    if self._verbose: sys.stdout.write('# Error. Same Struct Defined (%s)\n' % name_)
+                #    raise InvalidIDLSyntaxError
+                else:
+                    self._structs.append(s)
+
+            elif token == 'interface':
+                name_ = token_buf.pop()
+                s = interface.IDLInterface(name_, self)
+                s.parse_tokens(token_buf, filepath=filepath)
+
+                s_ = self.interface_by_name(name_)
+                if s_:
+                    if self._verbose: sys.stdout.write('# Error. Same Interface Defined (%s)\n' % name_)
+                #    raise InvalidIDLSyntaxError
+                else:
+                    self._interfaces.append(s)
+            
+            elif token == 'enum':
+                name_ = token_buf.pop()
+                s = enum.IDLEnum(name_, self)
+                s.parse_tokens(token_buf, filepath)
+                s_ = self.enum_by_name(name_)
+                if s_:
+                    if self._verbose: sys.stdout.write('# Error. Same Enum Defined (%s)\n' % name_)
+                #    raise InvalidIDLSyntaxError
+                else:
+                    self._enums.append(s)
+
+                pass
+
+            elif token == 'const':
+                values = []
+                while True:
+                    t = token_buf.pop()
+                    if t == ';':
+                        break
+                    values.append(t)
+
+                value_ = values[-1]
+                name_ = values[-3]
+                typename = ''
+                for t in values[:-3]:
+                    typename = typename + ' ' + t
+                typename = typename.strip()
+                s = const.IDLConst(name_, typename, value_, self, filepath=filepath)
+                s_ = self.const_by_name(name_)
+                if s_:
+                    if self._verbose: sys.stdout.write('# Error. Same Const Defined (%s)\n' % name_)
+                else:
+                    self._consts.append(s)
+                
+            elif token == '}':
+                break
+            
+        return True
+
+
+
+    @property
+    def modules(self):
+        return self._modules
+
+    def module_by_name(self, name):
+        for m in self.modules:
+            if m.name == name:
+                return m
+        return None
+
+    def forEachModule(self, func):
+        for m in self.modules:
+            func(m)
+
+    @property
+    def interfaces(self):
+        return self._interfaces
+
+    def interface_by_name(self, name):
+        for i in self.interfaces:
+            if i.name == name:
+                return i
+        return None
+
+    def forEachInterface(self, func):
+        for m in self.interfaces:
+            func(m)
+
+    @property
+    def structs(self):
+        return self._structs
+
+    def struct_by_name(self, name):
+        for s in self.structs:
+            if s.name == name:
+                return s
+        return None
+
+    def forEachStruct(self, func):
+        for m in self.structs:
+            func(m)
+
+    @property
+    def enums(self):
+        return self._enums
+
+    def enum_by_name(self, name):
+        for e in self.enums:
+            if e.name == name:
+                return e
+        return None
+
+    def forEachEnum(self, func):
+        for m in self.enums:
+            func(m)
+
+    @property
+    def consts(self):
+        return self._consts
+
+    def const_by_name(self, name):
+        for c in self.consts:
+            if c.name == name:
+                return c
+        return None
+
+    def forEachConst(self, func):
+        for m in self.consts:
+            func(m)
+
+    @property
+    def typedefs(self):
+        return self._typedefs
+
+    def typedef_by_name(self, name):
+        for t in self.typedefs:
+            if t.name == name:
+                return t
+        return None
+
+    def forEachTypedef(self, func):
+        for m in self.typedefs:
+            func(m)
+
+    def find_types(self, full_typename):
+        if type.is_primitive(full_typename):
+            return [type.IDLType(full_typename, self)]
+        typenode = []
+
+        def parse_node(s, name=str(full_typename)):
+            if s.name == name.strip() or s.full_path == name.strip():
+                typenode.append(s)
+
+        def parse_module(m):
+            m.forEachModule(parse_module)
+            m.forEachStruct(parse_node)
+            m.forEachTypedef(parse_node)
+            m.forEachEnum(parse_node)
+            m.forEachInterface(parse_node)
+
+        parse_module(self)
+
+        return typenode