diff --git a/idl_parser/const.py b/idl_parser/const.py index 1e993f8..f35840e 100644 --- a/idl_parser/const.py +++ b/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 - + diff --git a/idl_parser/node.py b/idl_parser/node.py index 9293c9e..8380685 100644 --- a/idl_parser/node.py +++ b/idl_parser/node.py @@ -110,7 +110,7 @@ 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] @@ -118,6 +118,6 @@ def refine_typename(self, typ): else: typs = global_module.find_types(typ.name) if len(typs) == 0: - return typ + return typ.name else: return typs[0].name diff --git a/idl_parser/parser.py b/idl_parser/parser.py index adba8b5..a01b3d0 100644 --- a/idl_parser/parser.py +++ b/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): diff --git a/idl_parser/token_buffer.py b/idl_parser/token_buffer.py index 44ef58f..af4a913 100644 --- a/idl_parser/token_buffer.py +++ b/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() - + diff --git a/idl_parser/type.py b/idl_parser/type.py index 1ca8776..ff229ec 100644 --- a/idl_parser/type.py +++ b/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 diff --git a/idls/basic_module_test.idl b/idls/basic_module_test.idl index 07d5a93..c6fd356 100644 --- a/idls/basic_module_test.idl +++ b/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; +}; diff --git a/tests/module_test.py b/tests/module_test.py index de45364..21b6dd7 100644 --- a/tests/module_test.py +++ b/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()