def _add_size_virtuals(structure, type_definition): """Adds a $size_in_bits or $size_in_bytes virtual field to structure.""" names = { ir_pb2.TypeDefinition.BIT: "$size_in_bits", ir_pb2.TypeDefinition.BYTE: "$size_in_bytes", } size_field_name = names[type_definition.addressable_unit] size_clauses = [] for field in structure.field: # Virtual fields do not have a physical location, and thus do not contribute # to the size of the structure. if ir_util.field_is_virtual(field): continue size_clause = ir_pb2.Expression() size_clause.CopyFrom(_SIZE_CLAUSE_SKELETON) # Copy the appropriate clauses into `existence_condition ? start + size : 0` size_clause.function.args[0].CopyFrom(field.existence_condition) size_clause.function.args[1].function.args[0].CopyFrom( field.location.start) size_clause.function.args[1].function.args[1].CopyFrom( field.location.size) size_clauses.append(size_clause) size_expression = ir_pb2.Expression() size_expression.CopyFrom(_SIZE_SKELETON) size_expression.function.args.extend(size_clauses) _mark_as_synthetic(size_expression) size_field = ir_pb2.Field( read_transform=size_expression, name=ir_pb2.NameDefinition(name=ir_pb2.Word(text=size_field_name)), existence_condition=ir_pb2.Expression( boolean_constant=ir_pb2.BooleanConstant(value=True)), attribute=[_skip_text_output_attribute()]) structure.field.extend([size_field])
def test_hashable_form_of_reference(self): self.assertEqual( ("t.emb", "Foo", "Bar"), ir_util.hashable_form_of_reference( ir_pb2.Reference(canonical_name=ir_pb2.CanonicalName( module_file="t.emb", object_path=["Foo", "Bar"])))) self.assertEqual( ("t.emb", "Foo", "Bar"), ir_util.hashable_form_of_reference( ir_pb2.NameDefinition(canonical_name=ir_pb2.CanonicalName( module_file="t.emb", object_path=["Foo", "Bar"]))))
def _add_size_bound_virtuals(structure, type_definition): """Adds ${min,max}_size_in_{bits,bytes} virtual fields to structure.""" names = { ir_pb2.TypeDefinition.BIT: ("$max_size_in_bits", "$min_size_in_bits"), ir_pb2.TypeDefinition.BYTE: ("$max_size_in_bytes", "$min_size_in_bytes"), } for name in names[type_definition.addressable_unit]: bound_field = ir_pb2.Field( read_transform=_SIZE_BOUNDS[name], name=ir_pb2.NameDefinition(name=ir_pb2.Word(text=name)), existence_condition=expression_parser.parse("true"), attribute=[_skip_text_output_attribute()]) _mark_as_synthetic(bound_field.read_transform) structure.field.extend([bound_field])
def test_find_object(self): ir = ir_pb2.EmbossIr.from_json("""{ "module": [ { "type": [ { "structure": { "field": [ { "name": { "name": { "text": "field" }, "canonical_name": { "module_file": "test.emb", "object_path": [ "Foo", "field" ] } } } ] }, "name": { "name": { "text": "Foo" }, "canonical_name": { "module_file": "test.emb", "object_path": [ "Foo" ] } }, "runtime_parameter": [ { "name": { "name": { "text": "parameter" }, "canonical_name": { "module_file": "test.emb", "object_path": [ "Foo", "parameter" ] } } } ] }, { "enumeration": { "value": [ { "name": { "name": { "text": "QUX" }, "canonical_name": { "module_file": "test.emb", "object_path": [ "Bar", "QUX" ] } } } ] }, "name": { "name": { "text": "Bar" }, "canonical_name": { "module_file": "test.emb", "object_path": [ "Bar" ] } } } ], "source_file_name": "test.emb" }, { "type": [ { "external": {}, "name": { "name": { "text": "UInt" }, "canonical_name": { "module_file": "", "object_path": [ "UInt" ] } } } ], "source_file_name": "" } ] }""") # Test that find_object works with any of its four "name" types. canonical_name_of_foo = ir_pb2.CanonicalName(module_file="test.emb", object_path=["Foo"]) self.assertEqual( ir.module[0].type[0], ir_util.find_object( ir_pb2.Reference(canonical_name=canonical_name_of_foo), ir)) self.assertEqual( ir.module[0].type[0], ir_util.find_object( ir_pb2.NameDefinition(canonical_name=canonical_name_of_foo), ir)) self.assertEqual(ir.module[0].type[0], ir_util.find_object(canonical_name_of_foo, ir)) self.assertEqual(ir.module[0].type[0], ir_util.find_object(("test.emb", "Foo"), ir)) # Test that find_object works with objects other than structs. self.assertEqual(ir.module[0].type[1], ir_util.find_object(("test.emb", "Bar"), ir)) self.assertEqual(ir.module[1].type[0], ir_util.find_object(("", "UInt"), ir)) self.assertEqual(ir.module[0].type[0].structure.field[0], ir_util.find_object(("test.emb", "Foo", "field"), ir)) self.assertEqual( ir.module[0].type[0].runtime_parameter[0], ir_util.find_object(("test.emb", "Foo", "parameter"), ir)) self.assertEqual(ir.module[0].type[1].enumeration.value[0], ir_util.find_object(("test.emb", "Bar", "QUX"), ir)) self.assertEqual(ir.module[0], ir_util.find_object(("test.emb", ), ir)) self.assertEqual(ir.module[1], ir_util.find_object(("", ), ir)) # Test searching for non-present objects. self.assertIsNone(ir_util.find_object_or_none(("not_test.emb", ), ir)) self.assertIsNone( ir_util.find_object_or_none(("test.emb", "NotFoo"), ir)) self.assertIsNone( ir_util.find_object_or_none(("test.emb", "Foo", "not_field"), ir)) self.assertIsNone( ir_util.find_object_or_none( ("test.emb", "Foo", "field", "no_subfield"), ir)) self.assertIsNone( ir_util.find_object_or_none(("test.emb", "Bar", "NOT_QUX"), ir)) self.assertIsNone( ir_util.find_object_or_none( ("test.emb", "Bar", "QUX", "no_subenum"), ir)) # Test that find_parent_object works with any of its four "name" types. self.assertEqual( ir.module[0], ir_util.find_parent_object( ir_pb2.Reference(canonical_name=canonical_name_of_foo), ir)) self.assertEqual( ir.module[0], ir_util.find_parent_object( ir_pb2.NameDefinition(canonical_name=canonical_name_of_foo), ir)) self.assertEqual(ir.module[0], ir_util.find_parent_object(canonical_name_of_foo, ir)) self.assertEqual(ir.module[0], ir_util.find_parent_object(("test.emb", "Foo"), ir)) # Test that find_parent_object works with objects other than structs. self.assertEqual(ir.module[0], ir_util.find_parent_object(("test.emb", "Bar"), ir)) self.assertEqual(ir.module[1], ir_util.find_parent_object(("", "UInt"), ir)) self.assertEqual( ir.module[0].type[0], ir_util.find_parent_object(("test.emb", "Foo", "field"), ir)) self.assertEqual( ir.module[0].type[1], ir_util.find_parent_object(("test.emb", "Bar", "QUX"), ir))