@Override
public SStmCG caseAIfStm(AIfStm node, IRInfo question) throws AnalysisException {
SExpCG ifExp = node.getIfExp().apply(question.getExpVisitor(), question);
SStmCG thenStm = node.getThenStm().apply(question.getStmVisitor(), question);
AIfStmCG ifStm = new AIfStmCG();
ifStm.setIfExp(ifExp);
ifStm.setThenStm(thenStm);
LinkedList<AElseIfStm> elseIfs = node.getElseIf();
for (AElseIfStm stm : elseIfs) {
ifExp = stm.getElseIf().apply(question.getExpVisitor(), question);
thenStm = stm.getThenStm().apply(question.getStmVisitor(), question);
AElseIfStmCG elseIfStm = new AElseIfStmCG();
elseIfStm.setElseIf(ifExp);
elseIfStm.setThenStm(thenStm);
ifStm.getElseIf().add(elseIfStm);
}
if (node.getElseStm() != null) {
SStmCG elseStm = node.getElseStm().apply(question.getStmVisitor(), question);
ifStm.setElseStm(elseStm);
}
return ifStm;
}
@Override
public SStmCG caseAReturnStm(AReturnStm node, IRInfo question) throws AnalysisException {
PExp exp = node.getExpression();
AExplicitOperationDefinition operation = node.getAncestor(AExplicitOperationDefinition.class);
if (operation != null && operation.getIsConstructor()) {
if (exp instanceof ASelfExp) {
// The expression of the return statement points to 'null' since the OO AST
// does not allow constructors to return references to explicitly
// created types. Simply 'returning' in a constructor means returning
// a reference for the object currently being created.
return new AReturnStmCG();
} else {
question.addUnsupportedNode(
operation,
"Unexpected expression returned by constructor: Values expliclty returned by constructors must be 'self'.");
return null;
}
}
AReturnStmCG returnStm = new AReturnStmCG();
if (exp != null) {
SExpCG expCg = exp.apply(question.getExpVisitor(), question);
returnStm.setExp(expCg);
}
return returnStm;
}
@Override
public SStmCG caseAForPatternBindStm(AForPatternBindStm node, IRInfo question)
throws AnalysisException {
// Example for mk_(a,b) in [mk_(1,2), mk_(3,4)] do skip;
PPattern pattern = node.getPatternBind().getPattern();
PExp exp = node.getExp();
PStm stm = node.getStatement();
Boolean reverse = node.getReverse();
SPatternCG patternCg = pattern.apply(question.getPatternVisitor(), question);
SExpCG seqExpCg = exp.apply(question.getExpVisitor(), question);
SStmCG stmCg = stm.apply(question.getStmVisitor(), question);
AForAllStmCG forAll = new AForAllStmCG();
forAll.setPattern(patternCg);
forAll.setBody(stmCg);
if (reverse != null && reverse) {
AReverseUnaryExpCG reversedExp = new AReverseUnaryExpCG();
reversedExp.setType(seqExpCg.getType().clone());
reversedExp.setExp(seqExpCg);
forAll.setExp(reversedExp);
} else {
forAll.setExp(seqExpCg);
}
return forAll;
}
@Override
public SStmCG caseAStartStm(AStartStm node, IRInfo question) throws AnalysisException {
PType type = node.getType();
PExp exp = node.getObj();
if (exp.getType() instanceof ASetType) {
STypeCG typeCG = type.apply(question.getTypeVisitor(), question);
SExpCG expCG = exp.apply(question.getExpVisitor(), question);
AStartlistStmCG s = new AStartlistStmCG();
s.setType(typeCG);
s.setExp(expCG);
return s;
} else {
STypeCG typeCG = type.apply(question.getTypeVisitor(), question);
SExpCG expCG = exp.apply(question.getExpVisitor(), question);
AStartStmCG thread = new AStartStmCG();
thread.setType(typeCG);
thread.setExp(expCG);
return thread;
}
}
@Override
public SStmCG caseAClassInvariantStm(AClassInvariantStm node, IRInfo question)
throws AnalysisException {
List<PExp> exps = new LinkedList<PExp>();
for (PDefinition d : node.getInvDefs()) {
if (!(d instanceof AClassInvariantDefinition)) {
Logger.getLog()
.printErrorln(
"Expected class invariant definition in '"
+ this.getClass().getName()
+ "'. Got: "
+ d);
return null;
}
AClassInvariantDefinition invDef = (AClassInvariantDefinition) d;
exps.add(invDef.getExpression());
}
AReturnStmCG returnStmCg = new AReturnStmCG();
if (exps.isEmpty()) {
// Should not really be necessary
returnStmCg.setExp(question.getExpAssistant().consBoolLiteral(true));
} else if (exps.size() == 1) {
SExpCG expCg = exps.get(0).apply(question.getExpVisitor(), question);
returnStmCg.setExp(expCg);
} else {
// We have more than one expressions from which we will build an 'and chain'
AAndBoolBinaryExpCG andExpTopCg = new AAndBoolBinaryExpCG();
andExpTopCg.setType(new ABoolBasicTypeCG());
andExpTopCg.setLeft(exps.get(0).apply(question.getExpVisitor(), question));
AAndBoolBinaryExpCG previousAndExpCg = andExpTopCg;
// The remaining ones except the last
for (int i = 1; i < exps.size() - 1; i++) {
SExpCG nextExpCg = exps.get(i).apply(question.getExpVisitor(), question);
AAndBoolBinaryExpCG nextAndExpCg = new AAndBoolBinaryExpCG();
nextAndExpCg.setType(new ABoolBasicTypeCG());
nextAndExpCg.setLeft(nextExpCg);
previousAndExpCg.setRight(nextAndExpCg);
previousAndExpCg = nextAndExpCg;
}
previousAndExpCg.setRight(
exps.get(exps.size() - 1).apply(question.getExpVisitor(), question));
returnStmCg.setExp(andExpTopCg);
}
return returnStmCg;
}
@Override
public SStmCG caseACallObjectStm(ACallObjectStm node, IRInfo question) throws AnalysisException {
PType type = node.getType();
PObjectDesignator objectDesignator = node.getDesignator();
ILexNameToken field = node.getField();
LinkedList<PExp> args = node.getArgs();
STypeCG typeCg = type.apply(question.getTypeVisitor(), question);
SObjectDesignatorCG objectDesignatorCg =
objectDesignator.apply(question.getObjectDesignatorVisitor(), question);
if (node.getExplicit()) {
SClassDefinition enclosingClass = node.getAncestor(SClassDefinition.class);
if (enclosingClass != null) {
if (!field.getModule().equals(enclosingClass.getName().getName())) {
// A quoted method call is only supported if the explicit
// module name is equal to that of the enclosing class. Say A
// is a sub class of S and 'a' is an instance of A then a.A`op();
// is allowed (although it is the same as a.op()). However,
// a.S`op(); is not allowed.
question.addUnsupportedNode(
node,
"A quoted object call statement is only supported if the explicit module name is equal to that of the enclosing class");
}
} else {
Logger.getLog()
.printErrorln(
"Could not find enclosing the statement of call a call object statement.");
}
}
String fieldNameCg = field.getName();
ACallObjectStmCG callObject = new ACallObjectStmCG();
callObject.setType(typeCg);
callObject.setDesignator(objectDesignatorCg);
callObject.setFieldName(fieldNameCg);
for (PExp arg : args) {
SExpCG argCg = arg.apply(question.getExpVisitor(), question);
if (argCg != null) {
callObject.getArgs().add(argCg);
} else {
return null;
}
}
return callObject;
}
@Override
public SStmCG caseAAssignmentStm(AAssignmentStm node, IRInfo question) throws AnalysisException {
PStateDesignator target = node.getTarget();
PExp exp = node.getExp();
SStateDesignatorCG targetCg = target.apply(question.getStateDesignatorVisitor(), question);
SExpCG expCg = exp.apply(question.getExpVisitor(), question);
AAssignmentStmCG assignment = new AAssignmentStmCG();
assignment.setTarget(targetCg);
assignment.setExp(expCg);
return assignment;
}
@Override
public SStmCG caseAWhileStm(AWhileStm node, IRInfo question) throws AnalysisException {
PStm stm = node.getStatement();
PExp exp = node.getExp();
SStmCG bodyCg = stm.apply(question.getStmVisitor(), question);
SExpCG expCg = exp.apply(question.getExpVisitor(), question);
AWhileStmCG whileStm = new AWhileStmCG();
whileStm.setExp(expCg);
whileStm.setBody(bodyCg);
return whileStm;
}
@Override
public SStmCG caseALetStm(ALetStm node, IRInfo question) throws AnalysisException {
ABlockStmCG block = new ABlockStmCG();
block.setScoped(question.getStmAssistant().isScoped(node));
question.getDeclAssistant().setLocalDefs(node.getLocalDefs(), block.getLocalDefs(), question);
SStmCG stm = node.getStatement().apply(question.getStmVisitor(), question);
if (stm != null) {
block.getStatements().add(stm);
}
return block;
}
@Override
public SStmCG caseACaseAlternativeStm(ACaseAlternativeStm node, IRInfo question)
throws AnalysisException {
PPattern pattern = node.getPattern();
PStm result = node.getResult();
SPatternCG patternCg = pattern.apply(question.getPatternVisitor(), question);
SStmCG resultCg = result.apply(question.getStmVisitor(), question);
ACaseAltStmStmCG caseCg = new ACaseAltStmStmCG();
caseCg.setPattern(patternCg);
caseCg.setResult(resultCg);
return caseCg;
}
private AMethodDeclCG consGetInstanceMethod(String name) {
AClassTypeCG quoteClassType = new AClassTypeCG();
quoteClassType.setName(name);
AIdentifierVarExpCG instanceVar =
transAssistant.getInfo().getExpAssistant().consIdVar(INSTANCE_FIELD, quoteClassType);
AEqualsBinaryExpCG nullCompare = new AEqualsBinaryExpCG();
nullCompare.setType(new ABoolBasicTypeCG());
nullCompare.setLeft(instanceVar);
nullCompare.setRight(info.getExpAssistant().consNullExp());
AIdentifierVarExpCG instanceId =
transAssistant
.getInfo()
.getExpAssistant()
.consIdVar(INSTANCE_FIELD, quoteClassType.clone());
ATypeNameCG typeName = new ATypeNameCG();
typeName.setDefiningClass(null);
typeName.setName(name);
ANewExpCG newQuote = new ANewExpCG();
newQuote.setName(typeName);
newQuote.setType(quoteClassType);
AAssignToExpStmCG assignInstance = new AAssignToExpStmCG();
assignInstance.setTarget(instanceId);
assignInstance.setExp(newQuote);
AIfStmCG ensureInstance = new AIfStmCG();
ensureInstance.setIfExp(nullCompare);
ensureInstance.setThenStm(assignInstance);
AReturnStmCG returnInstance = new AReturnStmCG();
returnInstance.setExp(instanceVar.clone());
ABlockStmCG body = new ABlockStmCG();
body.getStatements().add(ensureInstance);
body.getStatements().add(returnInstance);
AMethodTypeCG methodType = new AMethodTypeCG();
methodType.setResult(quoteClassType.clone());
AMethodDeclCG getInstanceMethod = new AMethodDeclCG();
getInstanceMethod.setImplicit(false);
getInstanceMethod.setAbstract(false);
getInstanceMethod.setAccess(IJavaConstants.PUBLIC);
getInstanceMethod.setIsConstructor(false);
getInstanceMethod.setName(GET_INSTANCE_METHOD);
getInstanceMethod.setStatic(true);
getInstanceMethod.setMethodType(methodType);
getInstanceMethod.setBody(body);
return getInstanceMethod;
}
@Override
public SStmCG caseAForAllStm(AForAllStm node, IRInfo question) throws AnalysisException {
// Example: for all x in set {1,2,3} do skip;
PPattern pattern = node.getPattern();
PExp set = node.getSet();
PStm body = node.getStatement();
SPatternCG patternCg = pattern.apply(question.getPatternVisitor(), question);
SExpCG setExpCg = set.apply(question.getExpVisitor(), question);
SStmCG bodyCg = body.apply(question.getStmVisitor(), question);
AForAllStmCG forAll = new AForAllStmCG();
forAll.setPattern(patternCg);
forAll.setExp(setExpCg);
forAll.setBody(bodyCg);
return forAll;
}
@Override
public SStmCG caseACasesStm(ACasesStm node, IRInfo question) throws AnalysisException {
PExp exp = node.getExp();
PStm others = node.getOthers();
LinkedList<ACaseAlternativeStm> cases = node.getCases();
SExpCG expCg = exp.apply(question.getExpVisitor(), question);
SStmCG othersCg = others != null ? others.apply(question.getStmVisitor(), question) : null;
ACasesStmCG casesStmCg = new ACasesStmCG();
casesStmCg.setExp(expCg);
casesStmCg.setOthers(othersCg);
question
.getStmAssistant()
.handleAlternativesCasesStm(question, exp, cases, casesStmCg.getCases());
return casesStmCg;
}
@Override
public SStmCG caseALetBeStStm(ALetBeStStm node, IRInfo question) throws AnalysisException {
PMultipleBind multipleBind = node.getBind();
if (!(multipleBind instanceof ASetMultipleBind)) {
question.addUnsupportedNode(
node,
"Generation of the let be st statement is only supported for a multiple set bind. Got: "
+ multipleBind);
return null;
}
ASetMultipleBind multipleSetBind = (ASetMultipleBind) multipleBind;
SMultipleBindCG multipleBindCg =
multipleSetBind.apply(question.getMultipleBindVisitor(), question);
if (!(multipleBindCg instanceof ASetMultipleBindCG)) {
return null;
}
ASetMultipleBindCG multipleSetBindCg = (ASetMultipleBindCG) multipleBindCg;
PExp suchThat = node.getSuchThat();
PStm stm = node.getStatement();
SExpCG suchThatCg =
suchThat != null ? suchThat.apply(question.getExpVisitor(), question) : null;
SStmCG stmCg = stm.apply(question.getStmVisitor(), question);
ALetBeStStmCG letBeSt = new ALetBeStStmCG();
AHeaderLetBeStCG header = question.getExpAssistant().consHeader(multipleSetBindCg, suchThatCg);
letBeSt.setHeader(header);
letBeSt.setStatement(stmCg);
return letBeSt;
}
@Override
public SStmCG caseAForIndexStm(AForIndexStm node, IRInfo question) throws AnalysisException {
ILexNameToken var = node.getVar();
PExp from = node.getFrom();
PExp to = node.getTo();
PExp by = node.getBy();
PStm stm = node.getStatement();
String varCg = var.getName();
SExpCG fromCg = from.apply(question.getExpVisitor(), question);
SExpCG toCg = to.apply(question.getExpVisitor(), question);
SExpCG byCg = by != null ? by.apply(question.getExpVisitor(), question) : null;
SStmCG bodyCg = stm.apply(question.getStmVisitor(), question);
AForIndexStmCG forStm = new AForIndexStmCG();
forStm.setVar(varCg);
forStm.setFrom(fromCg);
forStm.setTo(toCg);
forStm.setBy(byCg);
forStm.setBody(bodyCg);
return forStm;
}
private AFieldDeclCG consInstanceField(String name) {
AClassTypeCG quoteClassType = new AClassTypeCG();
quoteClassType.setName(name);
AFieldDeclCG field = new AFieldDeclCG();
field.setAccess(IJavaConstants.PRIVATE);
field.setVolatile(false);
field.setFinal(false);
field.setStatic(true);
field.setName(INSTANCE_FIELD);
field.setType(quoteClassType);
field.setInitial(info.getExpAssistant().consNullExp());
return field;
}
private AMethodDeclCG consToStringMethod(String name) {
SExpCG stringLit = info.getExpAssistant().consStringLiteral("<" + name + ">", false);
AReturnStmCG returnStr = new AReturnStmCG();
returnStr.setExp(stringLit);
AMethodDeclCG toStringMethod = consToStringSignature();
ABlockStmCG body = new ABlockStmCG();
body.getStatements().add(returnStr);
toStringMethod.setBody(body);
return toStringMethod;
}
@Override
public SStmCG caseAAtomicStm(AAtomicStm node, IRInfo question) throws AnalysisException {
AAtomicStmCG atomicBlock = new AAtomicStmCG();
for (AAssignmentStm assignment : node.getAssignments()) {
SStmCG stmCg = assignment.apply(question.getStmVisitor(), question);
if (stmCg != null) {
atomicBlock.getStatements().add(stmCg);
} else {
return null;
}
}
return atomicBlock;
}
@Override
public SStmCG caseAPeriodicStm(APeriodicStm node, IRInfo question) throws AnalysisException {
String opName = node.getOpname().getName();
APeriodicStmCG periodicStmCg = new APeriodicStmCG();
periodicStmCg.setOpname(opName);
for (PExp exp : node.getArgs()) {
SExpCG expCg = exp.apply(question.getExpVisitor(), question);
if (expCg != null) {
periodicStmCg.getArgs().add(expCg);
} else {
return null;
}
}
return periodicStmCg;
}
public STypeCG toIrType(IRInfo info) {
try {
STypeCG irType = type.apply(info.getTypeVisitor(), info);
if (irType != null) {
irType.setOptional(optional);
}
return irType;
} catch (AnalysisException e) {
Logger.getLog()
.printErrorln(
"Problems encountered while attempting "
+ "to construct the IR type from a VDM type: "
+ e.getMessage()
+ " in '"
+ this.getClass().getSimpleName()
+ "'");
e.printStackTrace();
}
return null;
}
@Override
public SStmCG caseABlockSimpleBlockStm(ABlockSimpleBlockStm node, IRInfo question)
throws AnalysisException {
ABlockStmCG blockStm = new ABlockStmCG();
blockStm.setScoped(question.getStmAssistant().isScoped(node));
LinkedList<AAssignmentDefinition> assignmentDefs = node.getAssignmentDefs();
for (AAssignmentDefinition def : assignmentDefs) {
PType type = def.getType();
String name = def.getName().getName();
PExp exp = def.getExpression();
STypeCG typeCg = type.apply(question.getTypeVisitor(), question);
AIdentifierPatternCG idPattern = new AIdentifierPatternCG();
idPattern.setName(name);
SExpCG expCg = exp.apply(question.getExpVisitor(), question);
AVarDeclCG localDecl =
question.getDeclAssistant().consLocalVarDecl(def, typeCg, idPattern, expCg);
if (expCg instanceof AUndefinedExpCG) {
question.getDeclAssistant().setDefaultValue(localDecl, typeCg);
} else {
localDecl.setExp(expCg);
}
blockStm.getLocalDefs().add(localDecl);
}
LinkedList<PStm> stms = node.getStatements();
for (PStm pStm : stms) {
SStmCG stmCg = pStm.apply(question.getStmVisitor(), question);
if (stmCg != null) {
blockStm.getStatements().add(stmCg);
} else {
return null;
}
}
return blockStm;
}
@Override
public SStmCG caseACallStm(ACallStm node, IRInfo question) throws AnalysisException {
PDefinition rootdef = node.getRootdef();
LinkedList<PExp> args = node.getArgs();
List<SExpCG> argsCg = new LinkedList<SExpCG>();
for (PExp arg : args) {
SExpCG argCg = arg.apply(question.getExpVisitor(), question);
if (argCg != null) {
argsCg.add(argCg);
} else {
return null;
}
}
boolean isStaticOrSl =
Settings.dialect == Dialect.VDM_SL
|| question.getTcFactory().createPDefinitionAssistant().isStatic(rootdef);
while (rootdef instanceof AInheritedDefinition) {
rootdef = ((AInheritedDefinition) rootdef).getSuperdef();
}
if (rootdef instanceof AExplicitOperationDefinition) {
AExplicitOperationDefinition op = (AExplicitOperationDefinition) rootdef;
if (op.getIsConstructor()) {
String initName = question.getObjectInitializerCall(op);
APlainCallStmCG callStm = new APlainCallStmCG();
callStm.setType(new AVoidTypeCG());
callStm.setClassType(null);
callStm.setName(initName);
callStm.setArgs(argsCg);
return callStm;
}
}
PType type = node.getType();
ILexNameToken nameToken = node.getName();
String name = nameToken.getName();
AClassTypeCG classType = null;
STypeCG typeCg = type.apply(question.getTypeVisitor(), question);
if (!isStaticOrSl) {
ILexNameToken rootDefClassName = node.getRootdef().getClassDefinition().getName();
ILexNameToken enclosingClassName = node.getAncestor(SClassDefinition.class).getName();
if (!rootDefClassName.equals(enclosingClassName)) {
ASuperCallStmCG superCall = new ASuperCallStmCG();
superCall.setIsStatic(isStaticOrSl);
superCall.setType(typeCg);
superCall.setName(name);
superCall.setArgs(argsCg);
return superCall;
}
} else if (nameToken != null && nameToken.getExplicit() && isStaticOrSl) {
String className = nameToken.getModule();
classType = new AClassTypeCG();
classType.setName(className);
}
APlainCallStmCG callStm = new APlainCallStmCG();
callStm.setType(typeCg);
callStm.setIsStatic(isStaticOrSl);
callStm.setName(name);
callStm.setClassType(classType);
callStm.setArgs(argsCg);
return callStm;
}