Add step to prepare input before parsing idl file

idl_parser/const.py

@@ -5,7 +5,7 @@
 
 
 class IDLConst(node.IDLNode):
-    
+
     def __init__(self, name, typename, value, parent, filepath=None):
         super(IDLConst, self).__init__('IDLConst', name, parent)
         self._typename = typename
@@ -20,7 +20,7 @@ def to_simple_dic(self, quiet=False, full_path=False, recursive=False, member_on
         dic = { 'const %s' % name : { 'type' : self.typename,
                                       'value' : self.value } }
         return dic
-                    
+
     def to_dic(self):
         dic = { 'name' : self.name,
                 'filepath' : self.filepath,
@@ -32,7 +32,7 @@ def to_dic(self):
     @property
     def typename(self):
         return self._typename
-    
+
     @property
     def type(self):
         return self.root_node.find_types(self.typename)[0]
@@ -47,4 +47,4 @@ def value_string(self):
     @property
     def full_path(self):
         return self.parent.full_path + sep + self.name
-    
+

idl_parser/node.py

@@ -110,14 +110,14 @@ def refine_typename(self, typ):
             name = typ.name[typ.name.find('<')+1 : typ.name.find('>')].strip()
             typs = global_module.find_types(name)
             if len(typs) == 0:
-                typ__ = typs
+                typ__ = typ
             else:
                 typ__  = typs[0]
 
             return 'sequence < ' + typ__.name + ' >'
         else:
             typs = global_module.find_types(typ.name)
             if len(typs) == 0:
-                return typ
+                return typ.name
             else:
                 return typs[0].name

idl_parser/parser.py

@@ -24,8 +24,27 @@ def is_primitive(self, name, except_string=False):
     def dirs(self):
         return self._dirs
 
+    def prepare_input(self, data):
+        from re import compile, UNICODE, MULTILINE
+        flags = UNICODE | MULTILINE
+
+        pattern = compile('\[[ \n]+', flags)
+        data = pattern.sub('[', data)
+
+        pattern = compile('[ \n]+\]', flags)
+        data = pattern.sub(']', data)
+
+        pattern = compile('\<[ \n]+', flags)
+        data = pattern.sub('<', data)
+
+        pattern = compile('[ \n]+\>', flags)
+        data = pattern.sub('>', data)
+
+        return data
+
     def load(self, input_str, include_dirs=[], filepath=None):
         self._dirs = self._dirs + include_dirs
+        input_str = self.prepare_input(input_str)
         lines = [l for l in input_str.split('\n')]
         self.parse_lines(lines, filepath=filepath)
         return self._global_module
@@ -55,7 +74,6 @@ def parse_lines(self, lines, filepath=None):
         lines = self._clear_ifdef(lines)
 
         self._token_buf = token_buffer.TokenBuffer(lines)
-
         self._global_module.parse_tokens(self._token_buf, filepath=filepath)
 
     def includes(self, idl_path):

idl_parser/token_buffer.py

@@ -1,7 +1,7 @@
 
 
 class TokenBuffer():
-    
+
     def __init__(self, lines):
         self._tokens = []
         self._token_offset = 0
@@ -22,4 +22,4 @@ def pop(self):
         self._token_offset = self._token_offset + 1
         return t.strip()
 
-    
+

idl_parser/type.py

@@ -139,7 +139,10 @@ def __init__(self, name, parent):
         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)
+
+        size_literal = self.parse_size(size)
+
+        self._size = size_literal
         self._type = IDLType(inner_type_name.strip(), parent)
         self._is_primitive = False #self.inner_type.is_primitive
         self._is_sequence = False
@@ -186,6 +189,34 @@ def __hoge(self):
             # print typs[0]
             return typs[0]
 
+    def parse_size(self, size):
+        is_const_type = None
+
+        if self.root_node.modules:
+            is_const_type = self.root_node.modules[-1].const_by_name(size)
+        else:
+            is_const_type = self.root_node.const_by_name(size)
+
+        # maybe there are modules but the constant is defined at a global scope?
+        if not is_const_type:
+            is_const_type = self.root_node.const_by_name(size)
+
+        size_literal = None
+
+        if is_const_type:
+            size_literal = is_const_type.value
+        else:
+            size_literal = size
+
+        try:
+            size_literal = int(size_literal)
+        except:
+            if self._verbose: sys.stdout.write(
+                "# Error. Array index '%s' not an integer.\n" % size_literal)
+            raise InvalidDataTypeException()
+
+        return size_literal
+
     @property
     def type(self):
         return self._type

idls/basic_module_test.idl

@@ -2,6 +2,12 @@
  * This IDL is for test
  */
 
+const short GLOBAL_CONSTANT = 44;
+
+module first_module {
+    const double MY_CONSTANT = 77.7;
+};
+
 module my_module {
   struct my_struct1 {
     long long_member;
@@ -62,7 +68,7 @@ module my_module {
   enum my_enum1 {
     data1,
     data2,
-    data3,
+    data3
   };
 
   const long value1 = -1;
@@ -72,5 +78,26 @@ module my_module {
 
   typedef unsigned long  Matrix3456[3][4][5][6];
 
+  /* 'MY_CONSTANT' defined diffenently in each module. Ensure with tests
+   * that the value of the 'MY_CONSTANT' is correctly associated with this
+   * module during parsing process.
+   */
+  const short MY_CONSTANT = 10;
+
+  struct another_struct {
+    double another_struct_array1[ MY_CONSTANT ];
+    short another_struct_array2[
+      11
+      ];
+    short another_struct_array3[GLOBAL_CONSTANT];
+    sequence< my_byte > another_struct_seq1;
+    sequence<
+      long
+      > another_struct_seq2;
+  };
+
 };
 
+module lase_module {
+    const double MY_CONSTANT = 99.9;
+};

tests/module_test.py

@@ -17,7 +17,7 @@ def test_module(self):
         parser_ = parser.IDLParser()
         m = parser_.load(open(idl_path, 'r').read())
         self.assertEqual(m.name,'__global__')
-        my_module = m.modules[0]
+        my_module = m.modules[1]
         self.assertEqual(my_module.name, 'my_module')
         my_struct = my_module.struct_by_name('my_struct1')
         self.assertEqual(my_struct.name, 'my_struct1')
@@ -26,7 +26,7 @@ def test_primitive_types(self):
         parser_ = parser.IDLParser()
         m = parser_.load(open(idl_path, 'r').read())
         self.assertEqual(m.name,'__global__')
-        my_module = m.modules[0]
+        my_module = m.modules[1]
         self.assertEqual(my_module.name, 'my_module')
         my_struct = my_module.struct_by_name('my_struct3')
         self.assertEqual(my_struct.name, 'my_struct3')
@@ -60,7 +60,7 @@ def test_typedef_types(self):
         parser_ = parser.IDLParser()
         m = parser_.load(open(idl_path, 'r').read())
         self.assertEqual(m.name,'__global__')
-        my_module = m.modules[0]
+        my_module = m.modules[1]
         self.assertEqual(my_module.name, 'my_module')
 
         my_byte = my_module.typedef_by_name('my_byte')
@@ -76,7 +76,7 @@ def test_interface_types(self):
         parser_ = parser.IDLParser()
         m = parser_.load(open(idl_path, 'r').read())
         self.assertEqual(m.name,'__global__')
-        my_module = m.modules[0]
+        my_module = m.modules[1]
         self.assertEqual(my_module.name, 'my_module')
 
         my_int = my_module.interface_by_name('my_interface1')
@@ -109,7 +109,7 @@ def test_struct_types(self):
         parser_ = parser.IDLParser()
         m = parser_.load(open(idl_path, 'r').read())
         self.assertEqual(m.name,'__global__')
-        my_module = m.modules[0]
+        my_module = m.modules[1]
         self.assertEqual(my_module.name, 'my_module')
         my_struct2 = my_module.struct_by_name('my_struct2')
         self.assertEqual(my_struct2.basename, 'my_struct2')
@@ -125,7 +125,7 @@ def test_union_types(self):
         parser_ = parser.IDLParser()
         m = parser_.load(open(idl_path, 'r').read())
         self.assertEqual(m.name,'__global__')
-        my_module = m.modules[0]
+        my_module = m.modules[1]
         self.assertEqual(my_module.name, 'my_module')
         my_union_1 = my_module.union_by_name('my_union1')
         self.assertEqual(my_union_1.basename, 'my_union1')
@@ -164,7 +164,7 @@ def test_enum_types(self):
         parser_ = parser.IDLParser()
         m = parser_.load(open(idl_path, 'r').read())
         self.assertEqual(m.name,'__global__')
-        my_module = m.modules[0]
+        my_module = m.modules[1]
         self.assertEqual(my_module.name, 'my_module')
 
         my_enum1 = my_module.enum_by_name('my_enum1')
@@ -180,7 +180,7 @@ def test_const_types(self):
         parser_ = parser.IDLParser()
         m = parser_.load(open(idl_path, 'r').read())
         self.assertEqual(m.name,'__global__')
-        my_module = m.modules[0]
+        my_module = m.modules[1]
         self.assertEqual(my_module.name, 'my_module')
 
         value1 = my_module.const_by_name('value1')
@@ -197,7 +197,7 @@ def test_sequence_test(self):
         parser_ = parser.IDLParser()
         m = parser_.load(open(idl_path, 'r').read())
         self.assertEqual(m.name,'__global__')
-        my_module = m.modules[0]
+        my_module = m.modules[1]
         self.assertEqual(my_module.name, 'my_module')
 
         doubleSeq = my_module.find_types('DoubleSeq')[0]
@@ -210,7 +210,7 @@ def test_arraye_test(self):
         parser_ = parser.IDLParser()
         m = parser_.load(open(idl_path, 'r').read())
         self.assertEqual(m.name,'__global__')
-        my_module = m.modules[0]
+        my_module = m.modules[1]
         self.assertEqual(my_module.name, 'my_module')
 
         mat34 = my_module.find_types('Matrix34')[0]
@@ -232,7 +232,7 @@ def test_arraye_test(self):
         self.assertTrue(mat3456.is_typedef)
         arr_arr_arr_arr_ul = mat3456.type
         self.assertTrue(arr_arr_arr_arr_ul.is_array)
-        self.assertEqual(arr_arr_arr_arr_ul.size, 3)
+        self.assertEqual(arr_arr_arr_arr_ul.size,3)
 
         arr_arr_arr_ul = arr_arr_arr_arr_ul.inner_type
         self.assertTrue(arr_arr_arr_ul.is_array)
@@ -247,6 +247,30 @@ def test_arraye_test(self):
         self.assertEqual(arr_ul.size, 6)
         self.assertTrue(arr_ul.inner_type.name, 'unsigned long')
 
+    def test_odd_spaces(self):
+        parser_ = parser.IDLParser()
+        m = parser_.load(open(idl_path, 'r').read())
+        self.assertEqual(m.name,'__global__')
+        my_module = m.modules[1]
+        self.assertEqual(my_module.name, 'my_module')
+        another_struct = my_module.struct_by_name('another_struct')
+        m = another_struct.member_by_name('another_struct_array1')
+        self.assertTrue(m.type.is_array)
+        self.assertEqual(m.type.inner_type.name, 'double')
+        self.assertEqual(m.type.size, 10)
+        m = another_struct.member_by_name('another_struct_array2')
+        self.assertEqual(m.type.inner_type.name, 'short')
+        self.assertTrue(m.type.is_array)
+        self.assertEqual(m.type.size, 11)
+        m = another_struct.member_by_name('another_struct_array3')
+        self.assertEqual(m.type.inner_type.name, 'short')
+        self.assertTrue(m.type.is_array)
+        self.assertEqual(m.type.size, 44)
+        m = another_struct.member_by_name('another_struct_array1')
+        m = another_struct.member_by_name('another_struct_seq1')
+        self.assertEqual(m.type.inner_type.name, 'my_byte')
+        m = another_struct.member_by_name('another_struct_seq2')
+        self.assertEqual(m.type.inner_type.name, 'long')
 
 if __name__ == '__main__':
     unittest.main()