idl-parser 0.0.10__py2.7.egg

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

idl_parser/node.py

@@ -0,0 +1,115 @@
+class IDLNode(object):
+    def __init__(self, classname, name, parent):
+        self._classname = classname
+        self._parent = parent
+        self._name = name
+        self._filepath = None
+        self.sep = '::'
+
+    @property
+    def filepath(self):
+        return self._filepath
+
+    @property
+    def is_array(self):
+        return self._classname == 'IDLArray'
+    
+    @property
+    def is_void(self):
+        return self._classname == 'IDLVoid'
+
+    @property
+    def is_struct(self):
+        return self._classname == 'IDLStruct'
+
+    @property
+    def is_typedef(self):
+        return self._classname == 'IDLTypedef'
+
+    @property
+    def is_sequence(self):
+        return self._classname == 'IDLSequence'
+
+    @property
+    def is_primitive(self):
+        return self._classname == 'IDLPrimitive'
+
+    @property
+    def is_interface(self):
+        return self._classname == 'IDLInterface'
+
+    @property
+    def is_enum(self):
+        return self._classname == 'IDLEnum'
+
+    @property
+    def is_const(self):
+        return self._classname == 'IDLConst'
+
+    @property
+    def classname(self):
+        return self._classname
+
+
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def basename(self):
+        return self._name.split(self.sep)[-1]
+
+    @property
+    def basename(self):
+        if self.name.find(self.sep) > 0:
+            return self.name[self.name.rfind('::')+2:]
+        return self.name
+
+    @property
+    def pathname(self):
+        if self.name.find(self.sep) > 0:
+            return self.name[:self.name.rfind('::')]
+        return ''
+
+
+    @property
+    def parent(self):
+        return self._parent
+
+    def _name_and_type(self, blocks):
+        name = blocks[-1]
+        type = ''
+        for t in blocks[:-1]:
+            type = type + ' ' + t
+        type = type.strip()
+        return (name, type)
+
+    @property
+    def is_root(self):
+        return self.parent == None
+
+    @property
+    def root_node(self):
+        roots = []
+        def find_root(n):
+            if n.is_root:
+                roots.append(n)
+            else:
+                find_root(n.parent)
+        find_root(self)
+        return roots[0]
+
+    def refine_typename(self, typ):
+        global_module = self.root_node
+        if typ.find('sequence') >= 0:
+            typ_ = typ[typ.find('<')+1 : typ.find('>')]
+            typ__ = self.refine_typename(typ_)
+            return 'sequence < ' + typ__ + ' >'
+        else:
+        #f True:
+            typs = global_module.find_types(typ)
+            if len(typs) == 0:
+                return typ
+            else:
+                return typs[0].full_path

idl_parser/parser.py

@@ -0,0 +1,274 @@
+import os, sys
+
+from . import  module, token_buffer
+from . import type as idl_type
+
+
+
+class IDLParser():
+
+    def __init__(self, idl_dirs=[]):
+        self._global_module = module.IDLModule()
+        self._dirs = idl_dirs
+        self._verbose = False
+    @property
+    def global_module(self):
+        return self._global_module
+
+    def is_primitive(self, name):
+        return idl_type.is_primitive(name)
+
+    @property
+    def dirs(self):
+        return self._dirs
+
+    def load(self, input_str, include_dirs=[]):
+        self._dirs = self._dirs + include_dirs
+        lines = [l for l in input_str.split('\n')]
+        self.parse_lines(lines)
+        return self._global_module
+
+    def parse(self, idls=[], idl_dirs=[], except_files=[]):
+        """ Parse IDL files. Result of parsing can be accessed via global_module property.
+        :param idls: List of IDL files. Must be fullpath.
+        :param idl_dirs: List of directory which contains target IDL files. Must be fullpath.
+        :param except_files: List of IDL files that should be ignored. Do not have to use fullpath.
+        :returns: None
+        """
+        self.forEachIDL(self.parse_idl, except_files=except_files, idls=idls, idl_dirs=idl_dirs)
+
+    def parse_idl(self, idl_path):
+        if self._verbose: sys.stdout.write(' - Parsing IDL (%s)\n' % idl_path)
+        f = open(idl_path, 'r')
+        lines = []
+        for line in f:
+            lines.append(line)
+
+        self.parse_lines(lines)
+
+    def parse_lines(self, lines):
+
+        lines = self._clear_comments(lines)
+        lines = self._paste_include(lines)            
+        lines = self._clear_ifdef(lines)
+
+        self._token_buf = token_buffer.TokenBuffer(lines)
+
+        self._global_module.parse_tokens(self._token_buf, filepath=None)
+
+    def includes(self, idl_path):
+        included_filepaths = []
+        included_filenames = []
+        f = open(idl_path, 'r')
+        lines = []
+        for line in f:
+            if line.find('#include') >= 0:
+                if line.find('"') >= 0:
+                    file = line[line.find('"')+1:line.rfind('"')].strip()
+                elif line.find('<') >= 0:
+                    file = line[line.find('<')+1:line.rfind('>')].strip()
+                included_filenames.append(file)
+        def get_fullpath(idl_path):
+            if os.path.basename(idl_path) in included_filenames:
+                included_filepaths.append(idl_path)
+                included_filenames.remove(os.path.basename(idl_path))
+
+        self.forEachIDL(get_fullpath)
+        if len(included_filenames) > 0:
+            raise IDLCanNotFindException()
+                
+        return included_filepaths
+
+
+    def forEachIDL(self, func, idl_dirs=[], except_files=[], idls=[]):
+        """ Parse IDLs and apply function.
+        :param func: Function. IDL file fullpath will be passed to the function.
+        :param idls: List of IDL files. Must be fullpath.
+        :param idl_dirs: List of directory which contains target IDL files. Must be fullpath.
+        :param except_files: List of IDL files that should be ignored. Do not have to use fullpath.
+        :returns: None
+        """
+        idl_dirs = self._dirs + idl_dirs
+        self._dirs = idl_dirs
+        idls_ = []
+        basenames_ = []
+        for idl_dir in idl_dirs:
+            for f in os.listdir(idl_dir):
+                if f.endswith('.idl'):
+                    if not f in except_files:
+                        path = os.path.join(idl_dir, f)
+                        if not f in basenames_:
+                            idls_.append(path)
+                            basenames_.append(os.path.basename(path))
+
+        idls_ = idls_ + idls
+        for f in idls_:
+            if self._verbose: sys.stdout.write(' - Apply function to %s\n' % f)
+            func(f)
+
+    def _find_idl(self, filename, apply_func, idl_dirs=[]):
+        if self._verbose: sys.stdout.write(' --- Find %s\n' % filename)
+        
+        global retval
+        retval = None
+        def func(filepath):
+            if os.path.basename(filepath) == filename:
+                global retval
+                retval = apply_func(filepath)
+                
+        self.forEachIDL(func, idl_dirs=idl_dirs)
+        return retval
+
+    def _paste_include(self, lines):
+        output_lines = []
+        for line in lines:
+            output_line = ''
+            if line.startswith('#include'):
+                def _include_paste(filepath):
+                    return filepath
+
+                if line.find('"') >= 7:
+                    filename = line[line.find('"')+1 : line.rfind('"')]
+                    if self._verbose: sys.stdout.write(' -- Includes %s\n' % filename)
+                    p = self._find_idl(filename, _include_paste)
+                    if p is None:
+                        sys.stdout.write(' # IDL (%s) can not be found.\n' % filename)
+                        raise IDLFileNotFoundErrorx
+                    self.parse_idl(idl_path = p)
+
+                    inc_lines = []
+                    f = open(p, 'r')
+                    for l in f:
+                        inc_lines.append(l)
+                    inc_lines = self._clear_comments(inc_lines)
+                    inc_lines = self._paste_include(inc_lines)
+                    output_lines = output_lines + inc_lines
+
+                elif line.find('<') >= 7:
+                    filename = line[line.find('<')+1 : line.rfind('>')]
+                    if self._verbose: sys.stdout.write(' -- Includes %s\n' % filename)
+                    p = self._find_idl(filename, _include_paste)
+                    if p is None:
+                        sys.stdout.write(' # IDL (%s) can not be found.\n' % filename)
+                        raise IDLFileNotFoundErrorx
+                    inc_lines = []
+
+                    self.parse_idl(idl_path = p)
+
+                    f = open(p, 'r')
+                    for l in f:
+                        inc_lines.append(l)
+                    inc_lines = self._clear_comments(inc_lines)
+                    inc_lines = self._paste_include(inc_lines)
+                    output_lines = output_lines + inc_lines
+
+            else:
+                output_line = line
+                
+            output_lines.append(output_line)
+
+        return output_lines
+
+
+
+    def _clear_comments(self, lines):
+        output_lines = []
+        in_comment = False
+
+        for line in lines:
+            line = line.strip()
+            output_line = ''
+            if line.find('//') >= 0:
+                line = line[:line.find('//')]
+
+            for token in line.split(' '):
+                
+                if in_comment and token.find('*/') >= 0:
+                    in_comment = False
+                    output_line = output_line + ' ' + token[token.find('*/')+2:].strip()
+
+                elif in_comment:
+                    continue
+
+                elif token.startswith('//'):
+                    break # ignore this line
+                
+                elif token.find('/*') >= 0:
+                    in_comment = True
+                    output_line = output_line + ' ' + token[0: token.find('/*')]
+                else:
+                    if token.find('{') >= 0:
+                        token = token.replace('{', ' { ')
+                    if token.find(';') >= 0:
+                        token = token.replace(';', ' ;')
+                    if token.find('(') >= 0:
+                        token = token.replace('(', ' ( ')
+                    token = token.replace(',', ' , ')
+                    token = token.replace(')', ' ) ')
+                    token = token.replace('}', ' } ')
+                    output_line = output_line + ' ' + token.strip()
+            if len(output_line.strip()) > 0:
+                output_lines.append(output_line.strip() + '\n')
+        
+        return output_lines
+
+    def _clear_ifdef(self, lines):
+        output_lines = []
+        def_tokens = []
+        global offset
+        offset = 0
+        def _parse(flag):
+            global offset
+            while offset < len(lines):
+                line = lines[offset]
+                if line.startswith('#define'):
+                    def_token = line.split(' ')[1]
+                    def_tokens.append(def_token)
+                    offset = offset + 1
+                elif line.startswith('#ifdef'):
+                    def_token = line.split(' ')[1]
+                    offset = offset + 1
+                    _parse(def_token in def_tokens)
+
+                elif line.startswith('#ifndef'):
+                    def_token = line.split(' ')[1]
+                    offset = offset + 1
+                    _parse(not def_token in def_tokens)
+
+                elif line.startswith('#endif'):
+                    offset = offset + 1
+                    return
+
+                else:
+                    offset = offset + 1
+                    if flag:
+                        output_lines.append(line)
+
+        _parse(True)
+        return output_lines
+
+
+    def generate_constructor_python(self, typ):
+        code = ''
+        if typ.is_sequence:
+            code = code + '[]'
+        if typ.is_array:
+            code = code + '['
+            for i in range(typ.size):
+                code = code + self.generate_constructor_python(typ.inner_type)
+                if i != typ.size-1:
+                    code = code + ', '
+            code = code + ']'
+        elif typ.is_primitive:
+            code = code + '0'
+        elif typ.is_typedef:
+            code = code + self.generate_constructor_python(typ.type)
+        elif typ.is_struct:
+            code = code + typ.full_path + '('
+            for m in typ.members:
+                if m.type.is_primitive:
+                    code = code + self.generate_constructor_python(m.type) + ', '
+                else:
+                    code = code + self.generate_constructor_python(m.type.obj) + ', '
+            code = code[:-2] + ')'
+        return code.replace('::', '.')