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))