if(node.getName() != null ) node.getName().apply(this); if(node.getClassDefinition() != null && !_visitedNodes.contains(node.getClassDefinition())) node.getClassDefinition().apply(this); if(node.getAccess() != null && !_visitedNodes.contains(node.getAccess())) node.getAccess().apply(this); if(node.getType() != null && !_visitedNodes.contains(node.getType())) node.getType().apply(this); if(node.getExpression() != null && !_visitedNodes.contains(node.getExpression())) node.getExpression().apply(this); if(node.getExpType() != null && !_visitedNodes.contains(node.getExpType())) node.getExpType().apply(this); if(node.getOldname() != null ) node.getOldname().apply(this);
public void initializedCheck(AInstanceVariableDefinition ivd) { if (!ivd.getInitialized() && !af.createPAccessSpecifierAssistant().isStatic(ivd.getAccess())) { TypeCheckerErrors.warning(5001, "Instance variable '" + ivd.getName() + "' is not initialized", ivd.getLocation(), ivd); } } }
public AssignmentContext(AInstanceVariableDefinition node, IVariableSubVisitor visitor, IPOContextStack ctxt) { super(ctxt); sub = new Substitution(node.getName(), node.getExpression()); subLast = sub; this.visitor = visitor; }
@Override public String caseAInstanceVariableDefinition( AInstanceVariableDefinition node, PrettyPrinterEnv question) throws AnalysisException { StringBuilder sb = new StringBuilder(question.getIdent()); sb.append(node.getName() + ":" + node.getType().apply(typePrinter, question) + (node.getExpression() != null ? " := " + node.getExpression() : "")); return sb.toString() + ";"; }
if (node.getExpression() instanceof AUndefinedExp) if (question.assistantFactory.createPAccessSpecifierAssistant().isStatic(node.getAccess())) + node.getName(), node.getLocation(), node); Environment cenv = new PrivateClassEnvironment(question.assistantFactory, node.getClassDefinition(), question.env); if (question.assistantFactory.createPAccessSpecifierAssistant().isStatic(node.getAccess())) node.setExpType(node.getExpression().apply(THIS, new TypeCheckInfo(question.assistantFactory, cenv, NameScope.NAMESANDSTATE, question.qualifiers))); ExcludedDefinitions.clearExcluded(); node.setType(question.assistantFactory.createPTypeAssistant().typeResolve(question.assistantFactory.createPDefinitionAssistant().getType(node), null, THIS, question)); if (node.getExpType() instanceof AVoidType) TypeCheckerErrors.report(3048, "Expression does not return a value", node.getExpression().getLocation(), node.getExpression()); if (!question.assistantFactory.getTypeComparator().compatible(question.assistantFactory.createPDefinitionAssistant().getType(node), node.getExpType())) TypeCheckerErrors.report(3000, "Expression does not match declared type", node.getLocation(), node); TypeCheckerErrors.detail2("Declared", question.assistantFactory.createPDefinitionAssistant().getType(node), "Expression", node.getExpType()); return node.getType();
@Override public void caseAInstanceVariableDefinition( AInstanceVariableDefinition node) throws AnalysisException { handleNameToken(node, node.getName()); handleNameToken(node, node.getOldname()); node.getExpression().apply(this); node.getType().apply(this); }
@Override public SDeclIR caseAInstanceVariableDefinition( AInstanceVariableDefinition node, IRInfo question) throws AnalysisException { String access = node.getAccess().getAccess().toString(); String name = node.getName().getName(); boolean isStatic = node.getAccess().getStatic() != null; boolean isFinal = false; STypeIR type = node.getType().apply(question.getTypeVisitor(), question); SExpIR exp = node.getExpression().apply(question.getExpVisitor(), question); return question.getDeclAssistant().constructField(access, name, isStatic, isFinal, type, exp); }
@Override public NameValuePairList caseAInstanceVariableDefinition( AInstanceVariableDefinition def, Context initialContext) throws AnalysisException { try { Value v = def.getExpression().apply(VdmRuntime.getExpressionEvaluator(), initialContext); if (!v.isUndefined()) { v = v.convertTo(def.getType(), initialContext); } return new NameValuePairList(new NameValuePair(def.getName(), v.getUpdatable(null))); } catch (ValueException e) { VdmRuntimeError.abort(def.getLocation(), e); return null; } catch (AnalysisException e) { // TODO Auto-generated catch block e.printStackTrace(); return null; } }
public OpBodyEndContext(List<AInstanceVariableDefinition> state, IPogAssistantFactory af) { this.af = af; subs = new LinkedList<Substitution>(); for (AInstanceVariableDefinition i : state) { AVariableExp var_exp = new AVariableExp(); ILexNameToken it = i.getName(); String safename = it.getName() + "$"; ILexNameToken safeToken = new LexNameToken(it.getModule(), safename, it.getLocation().clone()); var_exp.setName(safeToken); var_exp.setType(i.getType().clone()); var_exp.setOriginal(i.getName().getName().toString()); subs.add(new Substitution(i.getOldname(), var_exp)); } }
public IProofObligationList caseAInstanceVariableDefinition( AInstanceVariableDefinition node, IPOContextStack question) throws AnalysisException { try { IProofObligationList obligations = new ProofObligationList(); PExp expression = node.getExpression(); PType type = node.getType(); PType expType = node.getExpType(); obligations.addAll(expression.apply(rootVisitor, question)); if (!assistantFactory.getTypeComparator().isSubType(question.checkType(expression, expType), type)) { TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(expression, type, expType, question, assistantFactory); if (sto != null) { obligations.add(sto); } } return obligations; } catch (Exception e) { throw new POException(node, e.getMessage()); } }
@Override public LexNameSet caseAInstanceVariableDefinition(AInstanceVariableDefinition node, FreeVarInfo info) throws AnalysisException { LexNameSet names = new LexNameSet(); names.addAll(node.getType().apply(this, info)); names.addAll(node.getExpression().apply(this, info)); return names; }
public static AInstanceVariableDefinition newAInstanceVariableDefinition( ILexNameToken name, PType type, PExp expression) { AInstanceVariableDefinition result = new AInstanceVariableDefinition(); // Definition initialization initDefinition(result, Pass.VALUES, name.getLocation(), name, NameScope.VARSANDSTATE); result.setType(type); result.setExpression(expression); if (result.getLocation() != null) { result.getLocation().executable(false); } result.setOldname(name.getOldName()); result.setInitialized(!(expression instanceof AUndefinedExp)); return result; }
@Override public PExp caseAInstanceVariableDefinition( AInstanceVariableDefinition def, Integer lineno) throws AnalysisException { return af.createPExpAssistant().findExpression(def.getExpression(), lineno); }
@Override public void caseAInstanceVariableDefinition( AInstanceVariableDefinition node, NewQuestion question) throws AnalysisException { try { node.setType(af.createPTypeAssistant().typeResolve(node.getType(), null, question.rootVisitor, question.question)); } catch (TypeCheckException e) { af.createPTypeAssistant().unResolve(node.getType()); throw e; } }
@Override public LexNameList caseAInstanceVariableDefinition( AInstanceVariableDefinition node) throws AnalysisException { return new LexNameList(node.getName()); }
@Override public PType caseAInstanceVariableDefinition( AInstanceVariableDefinition node) throws AnalysisException { return node.getType(); }
@Override public PDefinition caseAInstanceVariableDefinition( AInstanceVariableDefinition node, Newquestion question) throws AnalysisException { PDefinition found = af.createPDefinitionAssistant().findNameBaseCase(node, question.sought, question.scope); if (found != null) { return found; } return question.scope.matches(NameScope.OLDSTATE) && node.getOldname().equals(question.sought) ? node : null; }
if (ivdef.getInitialized())
AIdentifierPattern idPat = new AIdentifierPattern(); idPat.setName(gen.getUnique(var.getName().getName())); pats.add(idPat); r.setType(var.getType().clone()); newVar.setOriginal(idPat.getName().getFullName()); Substitution sub = new Substitution(var.getName().clone(), newVar); subs.add(sub); AVariableExp old_var = last_vars.get(var.getName()); if (old_var != null) Substitution sub_old = new Substitution(var.getOldname().toString(), old_var); subs.add(sub_old); } else var_exp.setName(var.getName().clone()); var_exp.setType(var.getType().clone()); var_exp.setOriginal(var.getName().getName()); Substitution sub_old = new Substitution(var.getOldname().toString(), var_exp); subs.add(sub_old); last_vars.put(var.getName(), newVar);
@Override public ValueList caseAInstanceVariableDefinition( AInstanceVariableDefinition def, ObjectContext ctxt) throws AnalysisException { return af.createPExpAssistant().getValues(def.getExpression(), ctxt); }