public AAddrNotEqualsBinaryExpIR consParamNotNullComp( AIdentifierVarExpIR param) { AAddrNotEqualsBinaryExpIR fieldComparison = new AAddrNotEqualsBinaryExpIR(); fieldComparison.setType(new ABoolBasicTypeIR()); AIdentifierVarExpIR instanceField = new AIdentifierVarExpIR(); instanceField.setType(param.getType().clone()); instanceField.setIsLocal(true); instanceField.setName(param.getName()); fieldComparison.setLeft(instanceField); fieldComparison.setRight(info.getExpAssistant().consNullExp()); return fieldComparison; }
private SVarExpIR consIdVar(String name, boolean isLambda, STypeIR typeCg, boolean isLocalDef) { AIdentifierVarExpIR varExp = new AIdentifierVarExpIR(); varExp.setType(typeCg); varExp.setIsLocal(isLocalDef); varExp.setName(name); varExp.setIsLambda(isLambda); return varExp; }
/** * Returns a deep clone of this {@link AIdentifierVarExpIR} node. * @return a deep clone of this {@link AIdentifierVarExpIR} node */ public AIdentifierVarExpIR clone() { return new AIdentifierVarExpIR( _sourceNode, _tag, _metaData, cloneNode(_type), _isLambda, _isLocal, _name ); }
private SExpIR consFieldValueToMatch(AIdentifierVarExpIR patternVar, int fieldNumber, STypeIR currentType, boolean cast) { if (patternVar.getType() instanceof ATupleTypeIR) { return consTupleFieldExp(patternVar, fieldNumber, currentType, cast); } else if (patternVar.getType() instanceof ARecordTypeIR) { return consRecFieldExp(patternVar, fieldNumber, currentType, cast); } return null; }
@Override public void caseAIdentifierVarExpIR(AIdentifierVarExpIR node) throws AnalysisException { INode var = AssistantBase.getVdmNode(node); if(var instanceof AVariableExp) { PDefinition def = ((AVariableExp) var).getVardef(); if(def instanceof ARenamedDefinition) { ARenamedDefinition renamedDef = (ARenamedDefinition) def; AClassTypeIR definingClass = new AClassTypeIR(); definingClass.setName(renamedDef.getDef().getName().getModule()); definingClass.setSourceNode(node.getSourceNode()); AExplicitVarExpIR expVar = new AExplicitVarExpIR(); expVar.setName(renamedDef.getDef().getName().getName()); expVar.setType(node.getType().clone()); expVar.setIsLambda(node.getIsLambda()); expVar.setIsLocal(node.getIsLocal()); expVar.setMetaData(node.getMetaData()); expVar.setTag(node.getTag()); expVar.setSourceNode(node.getSourceNode()); expVar.setClassType(definingClass); assist.replaceNodeWith(node, expVar); } } }
fieldExp.setSourceNode(node.getSourceNode()); fieldExp.setTag(node.getTag()); fieldExp.setType(node.getType().clone()); setFieldNames(fieldExp, stateDecl, node.getName());
public ACallObjectExpStmIR consAddTraceVarCall(AIdentifierVarExpIR subject, AIdentifierVarExpIR t) { ANewExpIR newVar = new ANewExpIR(); newVar.setName(getTransAssist().consTypeNameForClass(traceTrans.getTracePrefixes().traceVarClassName())); newVar.setType(getTransAssist().consClassType(traceTrans.getTracePrefixes().traceVarClassName())); newVar.getArgs().add(getInfo().getExpAssistant().consStringLiteral(t.getName(), false)); newVar.getArgs().add(getInfo().getExpAssistant().consStringLiteral("" + getTransAssist().getInfo().getTypeAssistant().getVdmType(t.getType()), false)); newVar.getArgs().add(traceTrans.getToStringBuilder().toStringOf(t.clone())); return getTransAssist().consInstanceCallStm(subject.getType(), subject.getName(), traceTrans.getTracePrefixes().addVarFirstMethodName(), newVar); }
private AFieldNumberExpIR consTupleFieldExp( AIdentifierVarExpIR tuplePatternVar, int i, STypeIR currentType, boolean cast) { AFieldNumberExpIR fieldNumberExp = new AFieldNumberExpIR(); fieldNumberExp.setType(currentType.clone()); if (!cast) { fieldNumberExp.setTuple(tuplePatternVar.clone()); } else { ACastUnaryExpIR castedExp = new ACastUnaryExpIR(); castedExp.setType(tuplePatternVar.getType().clone()); castedExp.setExp(tuplePatternVar.clone()); fieldNumberExp.setTuple(castedExp); } fieldNumberExp.setField(new Long(1 + i)); return fieldNumberExp; }
protected AAssignToExpStmIR assignToVar(AIdentifierVarExpIR var, SExpIR exp) { AAssignToExpStmIR assignment = new AAssignToExpStmIR(); assignment.setTarget(var.clone()); assignment.setExp(exp.clone()); return assignment; }
if(!getJavaSettings().genRecsAsInnerClasses() && (var != null && !var.getIsLocal())) ADefaultClassDeclIR enclosingIrClass = var.getAncestor(ADefaultClassDeclIR.class); if(!fieldNames.contains(var.getName())) varName += module.getName().getName() + "." + var.getName(); varName = var.getName(); varName = var.getName(); varName = var.getName();
throws AnalysisException if (node.parent() instanceof AFieldExpIR && node.getName().equals(paramName)) AFieldExpIR field = (AFieldExpIR) node.parent(); } else SourceNode sourceNode = node.getSourceNode(); if (sourceNode != null) func.setIsLocal(false); func.setSourceNode(sourceNode); func.setName(node.getName());
public SVarExpIR idStateDesignatorToExp(AIdentifierStateDesignatorIR node) { if (node.getExplicit()) { AClassTypeIR classType = new AClassTypeIR(); classType.setName(node.getClassName()); AExplicitVarExpIR explicitVar = new AExplicitVarExpIR(); explicitVar.setClassType(classType); explicitVar.setIsLambda(false); explicitVar.setIsLocal(node.getIsLocal()); explicitVar.setName(node.getName()); explicitVar.setSourceNode(node.getSourceNode()); explicitVar.setTag(node.getTag()); explicitVar.setType(node.getType().clone()); return explicitVar; } else { AIdentifierVarExpIR idVar = consIdVar(node.getName(), node.getType().clone()); idVar.setTag(node.getTag()); idVar.setSourceNode(node.getSourceNode()); idVar.setIsLocal(node.getIsLocal()); return idVar; } }
/** * Called by the {@link AIdentifierVarExpIR} node from {@link AIdentifierVarExpIR#apply(IAnalysis)}. * @param node the calling {@link AIdentifierVarExpIR} node */ public void caseAIdentifierVarExpIR(AIdentifierVarExpIR node) throws AnalysisException { _visitedNodes.add(node); inAIdentifierVarExpIR(node); if(node.getType() != null && !_visitedNodes.contains(node.getType())) { node.getType().apply(this); } outAIdentifierVarExpIR(node); }
public SExpIR consStoreLookup(AIdentifierVarExpIR node, boolean noCast) { AClassTypeIR storeType = transAssistant.consClassType(tracePrefixes.storeClassName()); AIdentifierVarExpIR idArg = transAssistant.getInfo().getExpAssistant().consIdVar(idConstNameMap.get(node.getName()), new ANatNumericBasicTypeIR()); SExpIR call = transAssistant.consInstanceCall(storeType, tracePrefixes.storeVarName(), node.getType(), tracePrefixes.storeGetValueMethodName(), idArg); if (noCast || node.getType() instanceof AUnionTypeIR || node.getType() instanceof AUnknownTypeIR || node.getType() instanceof AObjectTypeIR) { return call; } else { ACastUnaryExpIR cast = new ACastUnaryExpIR(); cast.setType(node.getType().clone()); cast.setExp(call); return cast; } } }
private ABlockStmIR consUnionTypedTuplePatternCheck( boolean declarePatternVar, AUnionTypeIR unionType, PatternBlockData patternData, SExpIR actualValue, ATuplePatternIR tuplePattern) { ATupleTypeIR resTupleType = transAssistant.getInfo().getPatternAssistant().getTupleType(unionType, tuplePattern); ABlockStmIR tuplePatternCheck = consTuplePatternCheck(declarePatternVar, tuplePattern, resTupleType, patternData, actualValue, true); AIsOfClassExpIR instanceCheck = new AIsOfClassExpIR(); instanceCheck.setType(new ABoolBasicTypeIR()); instanceCheck.setCheckedType(patternData.getRootPatternVar().getType().clone()); instanceCheck.setExp(patternData.getRootPatternVar().clone()); AIfStmIR typeCheck = new AIfStmIR(); typeCheck.setIfExp(instanceCheck); typeCheck.setThenStm(tuplePatternCheck); ABlockStmIR block = new ABlockStmIR(); block.getStatements().add(typeCheck); return block; }
private AFieldExpIR consRecFieldExp(AIdentifierVarExpIR patternVar, STypeIR currentType, String fieldName) { AFieldExpIR fieldExp = new AFieldExpIR(); fieldExp.setType(currentType.clone()); fieldExp.setObject(patternVar.clone()); fieldExp.setMemberName(fieldName); return fieldExp; }
@Override public void caseAIdentifierVarExpIR(AIdentifierVarExpIR node) throws AnalysisException { if (localVarNames.contains(node.getName())) { getTransAssist().replaceNodeWith(node, storeAssistant.consStoreLookup(node)); } } });
/** * Creates a deep clone of this {@link AIdentifierVarExpIR} node while putting all * old node-new node relations in the map {@code oldToNewMap}. * @param oldToNewMap the map filled with the old node-new node relation * @return a deep clone of this {@link AIdentifierVarExpIR} node */ public AIdentifierVarExpIR clone(Map<INode,INode> oldToNewMap) { AIdentifierVarExpIR node = new AIdentifierVarExpIR( _sourceNode, _tag, _metaData, cloneNode(_type, oldToNewMap), _isLambda, _isLocal, _name ); oldToNewMap.put(this, node); return node; }