idl-parser 0.1.0__py3-none-any.whl

idl_parser/__init__.py

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

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
+        ln, fn, kakko = token_buf.pop()
+        if not kakko == '{':
+            if self._verbose: sys.stdout.write('# Error. No kakko "{".\n')
+            raise InvalidIDLSyntaxError()
+
+        block_tokens = []
+        while True:
+            ln, fn, token = token_buf.pop()
+            if token == None:
+                if self._verbose: sys.stdout.write('# Error. No kokka "}".\n')
+                raise InvalidIDLSyntaxError()
+
+            elif token == '}':
+                ln, fn, 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/exception.py

@@ -0,0 +1,37 @@
+
+
+
+class IDLParserException(Exception):
+
+    def __init__(self, line_number=None, file_name=None, message='IDLParserException occurred.'):
+        self._className = 'IDLParserException'
+        self._line_number = line_number
+        self._file_name = file_name
+        self._message = message
+
+    @property
+    def message(self):
+        return 'File "' + self.file_name + '", line %s, ' % self.line_number + '(' + self._className + '):"' + self._message
+
+    @property
+    def line_number(self):
+        return self._line_number
+        
+    @property
+    def file_name(self):
+        return self._file_name
+
+
+
+class InvalidIDLSyntaxError(IDLParserException):
+
+    def __init__(self, line_number=None, file_name=None, message='IDLParserException occurred.'):
+        super(InvalidIDLSyntaxError, self).__init__(line_number, file_name, message)
+        self._className = 'InvalidIDLSyntaxError'
+    pass
+
+class InvalidDataTypeException(IDLParserException):
+    pass
+
+class IDLCanNotFindException(IDLParserException):
+    pass

idl_parser/interface.py

@@ -0,0 +1,226 @@
+import sys
+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._name = self.refine_typename(self.type)
+
+
+
+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)' % blocks[1])
+            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 = []
+        self._inheritances = []
+
+    @property
+    def inheritances(self):
+        return [self.root_node.find_types(inheritance)[0] for inheritance in self._inheritances]
+
+    @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
+        ln, fn, token = token_buf.pop()
+        if token == ':': # Detect Inheritance
+            ln, fn, name = token_buf.pop()
+            interfaces = self.root_node.find_types(name)
+            if len(interfaces) == 0:
+                if self._verbose: sys.stdout.write('# Error. Can not find "%s" interface which is generalization of "%s"\n' % (name, self.name))
+                raise exception.InvalidDataTypeException
+            elif len(interfaces) > 1:
+                if self._verbose: sys.stdout.write('# Error. Multiple "%s" interfaces (one is generalization of "%s"). \n' % (name, self.name))
+                raise exception.InvalidDataTypeException
+            self._inheritances.append(interfaces[0].full_path)
+            ln, fn, token = token_buf.pop()
+
+        kakko = token
+        if not kakko == '{':
+            if self._verbose: sys.stdout.write('# Error. No kakko "{".\n')
+            raise exception.InvalidIDLSyntaxError()
+
+        block_tokens = []
+        while True:
+
+            ln, fn, token = token_buf.pop()
+            if token == None:
+                if self._verbose: sys.stdout.write('# Error. No kokka "}".\n')
+                raise InvalidIDLSyntaxError()
+
+            elif token == '}':
+                ln, fn, 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)
+
+