def exitArray_component_association(self, ctx):
if self.ctx.cur_spec is not None:
if self.ctx.cur_type and (not isinstance(self.ctx.cur_type, str)):
if self.ctx.cur_type.ttype == AdaType.ENUM_TYPE:
self.ctx.cur_type.items[(cpu.get_texts(ctx.discrete_choice_list()).upper())].solve_value(
cpu.get_texts(ctx.expression())
)
def exitRange_state(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_range = {}
rar = ctx.range_attribute_reference()
if rar:
rar = cpu.get_texts(rar)
self.ctx.cur_range = {'type': 'attr', 'base': rar[:rar.find("'")]}
else:
self.ctx.cur_range = {'type': 'range',
'first': cpu.solve_expr(self.ctx, cpu.get_texts(ctx.simple_expression(0)))[0],
'last': cpu.solve_expr(self.ctx, cpu.get_texts(ctx.simple_expression(1)))[0]
}
if self.ctx.cur_const and self.ctx.cur_const['type'] == 'range':
self.ctx.cur_const.update({'range': self.ctx.cur_range}) # always here
my_log.debug("exitRange_state1: %s" % self.ctx.cur_type)
my_log.debug("exitRange_state2: %s" % self.ctx.cur_const)
elif self.ctx.cur_fm.cur_states[-1] == FileMng.States.SUB_DER_TYPE:
self.ctx.cur_const = {'type': 'range',
'range': self.ctx.cur_range}
my_log.debug("exitRange_state3: %s" % self.ctx.cur_type)
my_log.debug("exitRange_state4: %s" % self.ctx.cur_const)
elif self.ctx.cur_fm.cur_states[-1] in (FileMng.States.FIELD_TYPE, FileMng.States.VAR_TYPE, FileMng.States.ARRAY_DEFINE):
self.ctx.cur_const = {'type': 'range',
'range': self.ctx.cur_range}
else:
my_log.error("ignore range statement: %s" % ctx.getText())
def exitSigned_integer_type_definition(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_type = AdaIntType(self.ctx.cur_type,
self.ctx.cur_spec.package,
self.ctx,
)
self.ctx.cur_type.solve_first(cpu.get_texts(ctx.simple_expression(0)))
self.ctx.cur_type.solve_last(cpu.get_texts(ctx.simple_expression(1)))
def __init__(self, f_path, ctx=None, listener=None):
super(FileMng, self).__init__()
self.f_path = f_path
self.dir_name = os.path.dirname(f_path)
self.f_name = os.path.basename(f_path)
self.ctx = ctx
self.ctx.cur_fm = self
self.package = None
self.istream = None
self.lexer = None
self.stream = None
self.parser = None
self.tree = None
self.walker = None
self.withs = set()
self.solved_withs = {}
self.uses = set()
self.use_types = set()
self.istream = FileStream(self.f_path)
self.lexer = ADA95Lexer(self.istream)
self.stream = CommonTokenStream(self.lexer)
self.parser = ADA95Parser(self.stream)
self.tree = self.parser.compilation()
self.cur_states = [FileMng.States.FILE]
self.to_print = ['f_path', 'cur_states']
self.leader_str = "'[%s:%s][%s:%s]'%(self.tree.start.line, self.tree.start.column, self.tree.stop.line, self.tree.stop.column)"
self.listener = listener
self.skip_walk = False
culs = self.tree.compilation_unit()
if len(culs) >= 1:
cis = culs[0].context_item()
for ci in cis:
wc = ci.with_clause()
if wc:
for lib_name in cpu.get_texts(wc.library_unit_name()):
self.solved_withs.update({
lib_name.upper():
self.ctx.check_with(lib_name.upper())
})
self.withs = set(self.solved_withs.keys())
if getattr(culs[0], 'library_item', None):
li = culs[0].library_item()
if li:
lud = li.library_unit_declaration()
if lud:
pd = lud.package_declaration()
if pd:
self.package = cpu.get_texts(
pd.package_specification(
).defining_program_unit_name()).upper()
else:
self.skip_walk = True
my_log.info("[%s]\nsolved_withs: %s" %
(self.f_path, self.solved_withs))
def exitAttribute_definition_clause(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_type = cpu.find_name(
cpu.get_texts(ctx.local_name()),
self.ctx,
'type')[0]
if not isinstance(self.ctx.cur_type, str):
attr = cpu.get_texts(ctx.attribute_designator())
if attr.lower() == 'size':
self.ctx.cur_spec.types[self.ctx.cur_type.package][
self.ctx.cur_type.name].solve_size(cpu.get_texts(ctx.expression()))
def exitComponent_clause(self, ctx):
if self.ctx.cur_spec is not None:
field_n = cpu.get_texts(ctx.component_local_name()).upper()
my_log.debug("exitComponent_clause: %s" % field_n)
cur_type = self.ctx.cur_spec.types[self.ctx.cur_type.package][self.ctx.cur_type.name]
my_log.debug(self.ctx.cur_type.package)
my_log.debug(self.ctx.cur_type.name)
cur_type.fields[field_n].solve_pos(cpu.get_texts(ctx.position()))
cur_type.fields[field_n].solve_start_bit(cpu.get_texts(ctx.first_bit()))
cur_type.fields[field_n].solve_end_bit(cpu.get_texts(ctx.last_bit()))
cur_type.add_pos(field_n)
my_log.debug(cur_type.fields[field_n])
my_log.debug(cur_type.fpos)
def enterSubtype_declaration(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_fm.cur_states.append(FileMng.States.TYPE)
self.ctx.cur_type = AdaSubtype(
cpu.get_texts(ctx.defining_identifier()),
self.ctx.cur_spec.package,
self.ctx)
def exitModular_type_definition(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_type = AdaIntType(self.ctx.cur_type,
self.ctx.cur_spec.package,
self.ctx,
)
self.ctx.cur_type.solve_mod(cpu.get_texts(ctx.expression()))
self.ctx.cur_type.print()
def exitRecord_representation_clause(self, ctx):
if self.ctx.cur_spec is not None:
if not isinstance(self.ctx.cur_type, str):
mod_cls = ctx.mod_clause()
if mod_cls is not None:
mod_cls = cpu.get_texts(mod_cls)
else:
mod_cls = None
self.ctx.cur_spec.types[self.ctx.cur_type.package][self.ctx.cur_type.name].mod_clause = mod_cls
def exitDiscriminant_specification(self, ctx):
if self.ctx.cur_spec is not None:
if self.ctx.cur_discrim is not None:
a_memb = AdaRecordField(self.ctx.cur_idents.pop(), self.ctx.cur_type, self.ctx)
a_memb.solve_field_type(self.get_cur_submark(ctx))
def_val = ctx.default_expression()
a_memb.solve_default(cpu.get_texts(def_val) if def_val else None)
self.ctx.cur_discrim.append(a_memb)
for ident in self.ctx.cur_idents:
self.ctx.cur_discrim.append(a_memb.copy(ident))
def exitNumber_declaration(self, ctx):
if self.ctx.cur_spec is not None:
av = AdaVar(self.ctx.cur_idents.pop(),
self.ctx.cur_spec.package,
self.ctx)
av.solve_value(cpu.get_texts(ctx.expression()))
self.ctx.cur_spec.add_var(av)
my_log.debug("exitNumber_declaration: %s" % av)
for ident in self.ctx.cur_idents:
self.ctx.cur_spec.add_var(av.copy(ident))
self.exit_state(FileMng.States.VAR, ctx)
def exitObject_declaration(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_var.set_name(self.ctx.cur_idents.pop())
obj_val = ctx.object_value()
self.ctx.cur_var.solve_value(cpu.get_texts(obj_val) if obj_val else None)
self.ctx.cur_spec.add_var(self.ctx.cur_var)
for ident in self.ctx.cur_idents:
self.ctx.cur_spec.add_var(self.ctx.cur_var.copy(ident))
self.ctx.cur_var = None
self.exit_state(FileMng.States.VAR, ctx)
#def exitMod_clause(self, ctx):
# if self.ctx.cur_spec is not None:
# self.cur_mod, dummy = cpu.solve_expr(self.ctx, cpu.get_texts(ctx.expression()))
def exitComponent_declaration(self, ctx):
if self.ctx.cur_spec is not None:
cur_fields = []
a_memb = AdaRecordField(self.ctx.cur_idents.pop(), self.ctx.cur_type.name, self.ctx)
#a_memb.solve_type(cpu.get_texts(ctx.component_definition()))
a_memb.solve_constraint(self.ctx.cur_field['constraint'])
a_memb.solve_field_type(self.ctx.cur_field['based'])
def_val = ctx.default_expression()
a_memb.solve_default(cpu.get_texts(def_val) if def_val else None)
cur_fields.append(a_memb)
for ident in self.ctx.cur_idents:
cur_fields.append(a_memb.copy(ident))
self.ctx.cur_type.add_fields(cur_fields)
#self.ctx.cur_type.print()
self.exit_state(FileMng.States.FIELD, ctx)
def enterEnumeration_type_definition(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_type = AdaEnumType(
self.ctx.cur_type,
self.ctx.cur_spec.package,
self.ctx)
#if self.ctx.cur_discrim:
# self.ctx.cur_type.add_discrim(self.ctx.cur_discrim)
enums = cpu.get_texts(ctx.enumeration_literal_specification())
my_log.debug("enterEnumeration_type_definition: %s" % enums)
for e in enums:
e_item = AdaEnumItem(e, self.ctx.cur_type, self.ctx)
self.ctx.cur_type.add_enum(e_item)
self.ctx.cur_spec.add_enum(e_item)
my_log.debug(self.ctx.cur_type)
self.ctx.cur_field = None
def exitDiscrete_subtype_definition(self, ctx):
if self.ctx.cur_spec is not None:
if self.ctx.cur_fm.cur_states[-1] == FileMng.States.ARRAY_DEFINE and self.ctx.cur_type:
dsi = ctx.discrete_subtype_indication()
if dsi:
cur_mark = re.search(self.MARK_PATTERN, cpu.get_texts(dsi))
cur_mark = cur_mark.group()
a_index = AdaArrayIndex(self.ctx.cur_type, cur_mark, None)
a_index.solve_constraint()
a_index.solve_based()
self.ctx.cur_type.add_index(a_index)
else:
a_index = AdaArrayIndex(self.ctx.cur_type, None, self.ctx.cur_const)
a_index.solve_constraint()
a_index.solve_based()
self.ctx.cur_type.add_index(a_index)
self.ctx.cur_const = None
def enterPackage_specification(self, ctx):
self.ctx.cur_fm.cur_states.append(FileMng.States.PACKAGE)
if self.ctx.cur_spec:
self.ctx.cur_spec_list.append(self.ctx.cur_spec)
self.ctx.cur_spec = AdaSpec(
ctx.parser.getTokenStream().tokenSource.inputStream.fileName,
self.ctx)
self.ctx.cur_spec.uses.update(map(lambda x: x.package, self.ctx.cur_spec_list))
self.ctx.cur_spec.package = cpu.get_texts(ctx.defining_program_unit_name()).upper()
if self.ctx.cur_spec_list:
self.ctx.cur_spec.package = ".".join([self.ctx.cur_spec_list[-1].package, self.ctx.cur_spec.package])
self.ctx.cur_spec.withs.add(self.ctx.cur_spec_list[0].package)
self.ctx.cur_spec.uses.update(self.ctx.cur_fm.uses)
self.ctx.cur_spec.withs.update(self.ctx.cur_fm.withs)
self.ctx.cur_spec.use_types.update(self.ctx.cur_fm.use_types)
my_log.debug("enterPackage_specification: %s" % self.ctx.cur_spec.package)
my_log.debug("withs: %s" % self.ctx.cur_spec.withs)
my_log.debug("uses: %s" % self.ctx.cur_spec.uses)
def exitUse_type_clause(self, ctx):
if self.ctx.cur_spec:
self.ctx.cur_spec.add_use_types(cpu.get_texts(ctx.subtype_mark()))
else:
self.ctx.cur_fm.add_use_types(cpu.get_texts(ctx.subtype_mark()))
def exitUse_package_clause(self, ctx):
if self.ctx.cur_spec:
self.ctx.cur_spec.add_use(cpu.get_texts(ctx.package_name()))
else:
self.ctx.cur_fm.add_use(cpu.get_texts(ctx.package_name()))
def exitDelta_constraint(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_const.update({
'delta': cpu.solve_expr(self.ctx, cpu.get_texts(ctx.expression()))[0],
'range': self.ctx.cur_range})
def exitWith_clause(self, ctx:ADA95Parser.With_clauseContext):
if self.ctx.cur_spec:
self.ctx.cur_spec.add_with(cpu.get_texts(ctx.library_unit_name()))
else:
self.ctx.cur_fm.add_with(cpu.get_texts(ctx.library_unit_name()))
def exitReal_range_specification(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_type.solve_first(cpu.get_texts(ctx.simple_expression(0)))
self.ctx.cur_type.solve_last(cpu.get_texts(ctx.simple_expression(1)))
def exitDecimal_fixed_point_definition(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_type.solve_delta(cpu.get_texts(ctx.expression(0)))
self.ctx.cur_type.solve_digits(cpu.get_texts(ctx.expression(1)))
def exitOrdinary_fixed_point_definition(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_type.solve_delta(cpu.get_texts(ctx.expression()))
def exitFloating_point_definition(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_type.solve_digits(cpu.get_texts(ctx.expression()))
def get_cur_submark(self, ctx):
cur_mark = re.search(self.MARK_PATTERN, cpu.get_texts(ctx.subtype_mark()))
cur_mark = cur_mark.group()
return cur_mark
def exitDefining_identifier_list(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_idents = cpu.get_texts(ctx.defining_identifier())
def exitDiscriminant_association(self, ctx):
if self.ctx.cur_spec is not None:
for n in cpu.get_texts(ctx.discriminant_selector_name()):
self.ctx.cur_const['choice'][n] = cpu.solve_expr(
self.ctx,
cpu.get_texts(ctx.expression()))[0]
def enterFirst_subtype_local_name(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_type = cpu.find_name(
cpu.get_texts(ctx.local_name()),
self.ctx,
'type')[0]
def enterType_definition_clause(self, ctx: ADA95Parser.Type_definition_clauseContext):
if self.ctx.cur_spec is not None:
self.ctx.cur_fm.cur_states.append(FileMng.States.TYPE)
self.ctx.cur_type = cpu.get_texts(ctx.defining_identifier())
self.ctx.cur_discrim = []
def exitIndex_constraint(self, ctx):
if self.ctx.cur_spec is not None:
self.ctx.cur_const.update({
'discrete': cpu.get_texts(ctx.discrete_range())})
