idl-parser 0.0.10__py2.7.egg

EGG-INFO/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 1.1
+Name: idl-parser
+Version: 0.0.10
+Summary: Very simple OMG IDL (Interface Definition Language) parser. This parses IDL files and outputs intermediate class objects.
+Home-page: http://www.sugarsweetrobotics.com/
+Author: ysuga
+Author-email: ysuga@ysuga.net
+License: GPLv3
+Download-URL: https://github.com/sugarsweetrobotics/idl_parser
+Description: idl_parser
+        ============
+        
+        |Travis Build Status|  |Coverage Status|
+        
+        Description 
+        -----------
+        
+        OMG IDL file parser. This library just parse IDL files, and output intermidiate type objects.
+        
+        Example
+        -----------
+        
+        .. code:: python
+        
+          """
+          example for idl_parser package   
+          """
+            
+          from idl_parser import parser
+          parser_ = parser.IDLParser()
+          idl_str = """
+          module my_module {
+            struct Time {
+              long sec;
+              long usec;
+            };
+        
+            typedef sequence<double> DoubleSeq;
+          
+            struct TimedDoubleSeq {
+              Time tm;
+              DoubleSeq data;
+            };
+          
+            enum RETURN_VALUE {
+              RETURN_OK,
+              RETURN_FAILED,
+            };
+        
+            interface DataGetter {
+              RETURN_VALUE getData(out TimedDoubleSeq data);
+            };
+        
+          };
+          """
+            
+          global_module = parser_.load(idl_str)
+          my_module = global_module.module_by_name('my_module')
+          dataGetter = my_module.interface_by_name('DataGetter')
+          print 'DataGetter interface'
+          for m in dataGetter.methods: 
+            print '- method:'
+            print '  name:', m.name
+            print '  returns:', m.returns.name
+            print '  arguments:'
+            for a in m.arguments:
+              print '    name:', a.name
+              print '    type:', a.type
+              print '    direction:', a.direction
+            
+          doubleSeq = my_module.typedef_by_name('DoubleSeq')
+          print 'typedef %s %s' % (doubleSeq.type.name, doubleSeq.name)
+        
+          timedDoubleSeq = my_module.struct_by_name('TimedDoubleSeq')
+          print 'TimedDoubleSeq'
+          for m in timedDoubleSeq.members:
+            print '- member:'
+            print '  name:', m.name
+            print '  type:', m.type.name    
+        
+        How to install
+        ---------------
+        
+            sudo pip install idl_parser
+        
+        
+        Copyright
+        ------------
+        
+        - author: Yuki Suga
+        
+        - copyright: Yuki Suga @ ssr.tokyo
+        
+        - license: GPLv3
+        
+        .. |Travis Build Status| image:: https://travis-ci.org/sugarsweetrobotics/idl_parser.svg?branch=master
+           :target: https://travis-ci.org/sugarsweetrobotics/idl_parser
+           
+        .. |Coverage Status| image:: https://coveralls.io/repos/github/sugarsweetrobotics/idl_parser/badge.svg?branch=master :target: https://coveralls.io/github/sugarsweetrobotics/idl_parser?branch=master
+        
+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

EGG-INFO/SOURCES.txt

@@ -0,0 +1,17 @@
+README.rst
+setup.py
+idl_parser/__init__.py
+idl_parser/const.py
+idl_parser/enum.py
+idl_parser/interface.py
+idl_parser/module.py
+idl_parser/node.py
+idl_parser/parser.py
+idl_parser/struct.py
+idl_parser/token_buffer.py
+idl_parser/type.py
+idl_parser/typedef.py
+idl_parser.egg-info/PKG-INFO
+idl_parser.egg-info/SOURCES.txt
+idl_parser.egg-info/dependency_links.txt
+idl_parser.egg-info/top_level.txt

EGG-INFO/dependency_links.txt

@@ -0,0 +1 @@
+

EGG-INFO/top_level.txt

@@ -0,0 +1 @@
+idl_parser

EGG-INFO/zip-safe

@@ -0,0 +1 @@
+

idl_parser/__init__.py

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

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/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/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)
+
+