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