}
}
// Generate the switch conditional.
LocalVariable caseVar = null;
SwitchStatement switchStatement;
if (noAltVars /*&& (defaultAltProvided || !missingCases)*/) {
// If there are no alt vars and we don't have to fill in any missing cases we don't need a local
// variable holding the switchexpression. This means we can generate something like:
// switch (expression.evaluate().getOrdinal())
ExpressionContextPair ecp = generateUnboxedArgument(JavaTypeName.INT, eswitch.getSwitchExpr(), variableContext);
switchBlock.addStatement(ecp.getContextBlock());
JavaExpression conditionExpression = ecp.getJavaExpression();
switchStatement = new SwitchStatement(conditionExpression);
switchBlock.addStatement(switchStatement);
} else {
// If there are alternates that have alt vars we generate something like:
// RTValue caseVar;
// switch ((caseVar = expression.evaluate()).getIntValue())
// We do the assignment of the local in the actual switch statement
// because analysis of the generated bytecode has shown this to be
// slightly more efficient than initializing the local as part of the
// declaration.
JavaStatement caseVarDeclaration = null;
Expression switchExpression = eswitch.getSwitchExpr();
// Generate a local variable and assign the evaluated value of the expression
// we are switching on.
JavaTypeName typeClassName = isEnumDataType ? JavaTypeNames.RTVALUE : CALToJavaNames.createTypeNameFromType(typeCons, module);
caseVar = new LocalVariable("$case" + nestedCaseLevel, typeClassName);
// Add the local variable declaration.
caseVarDeclaration = new LocalVariableDeclaration(caseVar);
switchBlock.addStatement(caseVarDeclaration);
// Compile the expression we are switching on strictly.
ExpressionContextPair pair = genS_E(switchExpression, variableContext);
switchBlock.addStatement(pair.getContextBlock());
JavaExpression caseExpression = pair.getJavaExpression();
//caseExpression = releaseVarsInSwitchCondition(eswitch, caseExpression, variableContext);
// We may need to cast the result of the case expression to the type of the local variable.
caseExpression = (isEnumDataType || caseExpression instanceof ClassInstanceCreationExpression) ? caseExpression : new CastExpression(typeClassName, caseExpression);
// Assign the result of the switch expression to the local an then get the ordinal value.
JavaExpression assignLocal = new JavaExpression.Assignment(caseVar, caseExpression);
JavaExpression getOrdinal = SCJavaDefn.createInvocation(assignLocal, SCJavaDefn.GETORDINALVALUE);
switchStatement = new SwitchStatement(getOrdinal);
switchBlock.addStatement(switchStatement);
}
// Populate the switch statement with case statement groups.
for (final SwitchAlt alt : alts) {
List<Object> altTags = alt.getAltTags();
// If no variables are used, we can share the code among all data constructors for this alt.
if (!alt.hasVars()) {
Block caseBlock = new Block();
// Add a comment for the data constructors in the group if any (ie. if not the default alt).
if (alt.getFirstAltTag() instanceof DataConstructor) {
StringBuilder commentSB = new StringBuilder();
boolean firstDC = true;
for (final Object tag : altTags) {
DataConstructor tagDC = (DataConstructor)tag;
if (firstDC) {
firstDC = false;
} else {
commentSB.append(", ");
}
commentSB.append(tagDC.getName().getQualifiedName());
}
caseBlock.addStatement(new LineComment(commentSB.toString()));
}
// Create a new child variable scope to handle the alternate and any let variables it contains.
variableContext.pushJavaScope();
// Compile the body of the alternate.
JavaStatement altStatement = genS_R(alt.getAltExpr(), variableContext);
caseBlock.addStatement(variableContext.popJavaScope());
caseBlock.addStatement(altStatement);
if (alt.isDefaultAlt()) {
switchStatement.addCase(new SwitchStatement.DefaultCase(caseBlock));
} else {
int[] caseLabels = new int[altTags.size()];
int index = 0;
for (final Object tag : altTags) {
if (!(tag instanceof DataConstructor)) {
throw new CodeGenerationException ("Unknown tag type in DC case statement in " + getFunctionName() + ": " + tag.getClass().getName());
}
caseLabels[index] = ((DataConstructor)tag).getOrdinal();
index++;
}
switchStatement.addCase(new SwitchStatement.IntCaseGroup(caseLabels, caseBlock));
}
} else {
// The alts use variables.
if (alt instanceof SwitchAlt.Positional) {
// Positional notation for extracted variables.
// For now, a separate code block must be generated for each data constructor in the case.
Collection<List<DataConstructor>> tagGroups = consolidatePositionalSwitchAlt((SwitchAlt.Positional)alt);
for (final List<DataConstructor> group : tagGroups) {
// Must be a data constructor tag, since there are field names (see Expression.Switch.SwitchAlt).
Block caseBlock = new Block();
int[] caseLabels = new int[group.size()];
int index = 0;
DataConstructor firstDC = null;
// Must be a data constructor tag, since there are field names (see Expression.Switch.SwitchAlt).
for (final DataConstructor tagDC : group) {
if (firstDC == null) {
firstDC = tagDC;
} else
if (tagDC.getOrdinal() < firstDC.getOrdinal()) {
firstDC = tagDC;
}
caseBlock.addStatement(new LineComment(tagDC.getName().getQualifiedName()));
caseLabels[index] = tagDC.getOrdinal();
index++;
}
caseBlock.addStatement(new LineComment("Decompose data type to access members."));
// Create a new child variable scope to handle the alternate and any let variables it contains.
variableContext.pushJavaScope();
// Get this alternative's variables. These have to be added to the active list of scope variables
TypeExpr fieldTypes[] = SCJavaDefn.getFieldTypesForDC(firstDC);
for (final AltVarIndexPair altVarIndexPair : getAltVarIndexList(alt, firstDC)) {
String altVar = altVarIndexPair.getAltVar();
int fieldIndex = altVarIndexPair.getIndex();
QualifiedName qn = QualifiedName.make(currentModuleName, altVar);
VarInfo.DCMember vi = variableContext.addDCField(qn, fieldTypes[fieldIndex]);
boolean fieldIsStrict =
!LECCMachineConfiguration.IGNORE_STRICTNESS_ANNOTATIONS;
for (final DataConstructor tagDC : group) {
fieldIsStrict = fieldIsStrict && tagDC.isArgStrict(fieldIndex);
}
if (fieldIsStrict) {
vi.setEvaluated(true);
}
String fieldName = SCJavaDefn.getJavaFieldNameFromDC(firstDC, fieldIndex);
String fieldGetterName = "get" + fieldName;
// Generate the code defining the variable.
if (fieldIsStrict) {
if (SCJavaDefn.canTypeBeUnboxed(fieldTypes[fieldIndex])) {
// This is a strict field of a primitive type so has both a boxed and unboxed form.
JavaExpression unboxedInitializer =
new JavaExpression.MethodInvocation.Instance(caseVar,
fieldGetterName + "_As_" + SCJavaDefn.getNameForPrimitive(fieldTypes[fieldIndex]),
SCJavaDefn.typeExprToTypeName(fieldTypes[fieldIndex]),
JavaExpression.MethodInvocation.InvocationType.VIRTUAL);
vi.updateUnboxedVarDef(unboxedInitializer);
JavaExpression localVar = new LocalVariable(vi.getJavaName()+"$U", vi.getUnboxedType());
vi.updateUnboxedReference(localVar);
JavaExpression boxedDef = SCJavaDefn.boxExpression(vi.getUnboxedType(), localVar);
vi.updateStrictReference(boxedDef);
vi.updateLazyReference(boxedDef);
} else {
// RTValue altVarName = ((DCClass)caseVar).getFieldn();
JavaExpression initializer = new JavaExpression.MethodInvocation.Instance(caseVar, fieldGetterName, JavaTypeNames.RTVALUE, JavaExpression.MethodInvocation.InvocationType.VIRTUAL);
vi.updateStrictVarDef (initializer);
JavaExpression localVar = new LocalVariable(vi.getJavaName(), JavaTypeNames.RTVALUE);
vi.updateStrictReference(localVar);
vi.updateLazyReference(localVar);
}
} else {
// RTValue altVarName = ((DCClass)caseVar).getFieldn();
JavaExpression initializer = new JavaExpression.MethodInvocation.Instance(caseVar, fieldGetterName, JavaTypeNames.RTVALUE, JavaExpression.MethodInvocation.InvocationType.VIRTUAL);
vi.updateLazyVarDef (initializer);
JavaExpression localVar = new LocalVariable(vi.getJavaName(), JavaTypeNames.RTVALUE);
vi.updateLazyReference(localVar);
JavaExpression evaluatedVar = SCJavaDefn.createInvocation(localVar, SCJavaDefn.EVALUATE, SCJavaDefn.EXECUTION_CONTEXT_VAR);
vi.updateStrictReference(evaluatedVar);
if (SCJavaDefn.canTypeBeUnboxed(fieldTypes[fieldIndex])) {
vi.updateUnboxedReference(SCJavaDefn.unboxValue(vi.getUnboxedType(), evaluatedVar));
}
}
}
// Compile the actual body of the alternate.
JavaStatement altStatement = genS_R(alt.getAltExpr(), variableContext);
caseBlock.addStatement(variableContext.popJavaScope());
caseBlock.addStatement(altStatement);
switchStatement.addCase(new SwitchStatement.IntCaseGroup(caseLabels, caseBlock));
}
} else {
// Matching notation for switch alternate.
Map<FieldName, String> fieldNameToVarNameMap = ((SwitchAlt.Matching)alt).getFieldNameToVarNameMap();
Block caseBlock = new Block();
int[] caseLabels = new int[altTags.size()];
int index = 0;
DataConstructor firstDC = null;
// Must be a data constructor tag, since there are field names (see Expression.Switch.SwitchAlt).
for (final Object altTag : altTags) {
DataConstructor tagDC = (DataConstructor)altTag;
if (firstDC == null) {
firstDC = tagDC;
} else if (tagDC.getOrdinal() < firstDC.getOrdinal()) {
firstDC = tagDC;
}
caseBlock.addStatement(new LineComment(tagDC.getName().getQualifiedName()));
caseLabels[index] = tagDC.getOrdinal();
index++;
}
caseBlock.addStatement(new LineComment("Decompose data type to access members."));
// Create a new child variable scope to handle the alternate and any let variables it contains.
variableContext.pushJavaScope();
for (int iField = 0; iField < firstDC.getArity(); ++iField) {
FieldName fn = firstDC.getNthFieldName(iField);
String altVar = fieldNameToVarNameMap.get(fn);
if (altVar == null) {
continue;
}
QualifiedName qn = QualifiedName.make(currentModuleName, altVar);
TypeExpr fieldType = SCJavaDefn.getFieldTypeForDC(firstDC, fn);
VarInfo.DCMember vi = variableContext.addDCField(qn, fieldType);
boolean fieldIsStrict = !LECCMachineConfiguration.IGNORE_STRICTNESS_ANNOTATIONS;
for (final Object altTag : altTags) {
DataConstructor tagDC = (DataConstructor)altTag;
fieldIsStrict = fieldIsStrict & tagDC.isArgStrict(tagDC.getFieldIndex(fn));
}
if (fieldIsStrict) {
vi.setEvaluated(true);
}
String fieldName = SCJavaDefn.getJavaFieldNameFromFieldName(fn);
String fieldGetterName = "get" + fieldName;
// Generate the code defining the variable.
if (fieldIsStrict) {
if (SCJavaDefn.canTypeBeUnboxed(fieldType)) {
// This is a strict field of a primitive type so has both a boxed and unboxed form.
JavaExpression unboxedInitializer =
new JavaExpression.MethodInvocation.Instance(caseVar,
fieldGetterName + "_As_" + SCJavaDefn.getNameForPrimitive(fieldType),
SCJavaDefn.typeExprToTypeName(fieldType),
JavaExpression.MethodInvocation.InvocationType.VIRTUAL);
vi.updateUnboxedVarDef(unboxedInitializer);
JavaExpression localVar = new LocalVariable(vi.getJavaName()+"$U", vi.getUnboxedType());
vi.updateUnboxedReference(localVar);
JavaExpression boxedDef = SCJavaDefn.boxExpression(vi.getUnboxedType(), localVar);
vi.updateStrictReference(boxedDef);
vi.updateLazyReference(boxedDef);
} else {
// RTValue altVarName = ((DCClass)caseVar).getFieldn();
JavaExpression initializer = new JavaExpression.MethodInvocation.Instance(caseVar, fieldGetterName, JavaTypeNames.RTVALUE, JavaExpression.MethodInvocation.InvocationType.VIRTUAL);
vi.updateStrictVarDef (initializer);
JavaExpression localVar = new LocalVariable(vi.getJavaName(), JavaTypeNames.RTVALUE);
vi.updateStrictReference(localVar);
vi.updateLazyReference(localVar);
}
} else {
// RTValue altVarName = ((DCClass)caseVar).getFieldn();
JavaExpression initializer = new JavaExpression.MethodInvocation.Instance(caseVar, fieldGetterName, JavaTypeNames.RTVALUE, JavaExpression.MethodInvocation.InvocationType.VIRTUAL);
vi.updateLazyVarDef (initializer);
JavaExpression localVar = new LocalVariable(vi.getJavaName(), JavaTypeNames.RTVALUE);
vi.updateLazyReference(localVar);
JavaExpression evaluatedVar = SCJavaDefn.createInvocation(localVar, SCJavaDefn.EVALUATE, SCJavaDefn.EXECUTION_CONTEXT_VAR);
vi.updateStrictReference(evaluatedVar);
if (SCJavaDefn.canTypeBeUnboxed(fieldType)) {
vi.updateUnboxedReference(SCJavaDefn.unboxValue(vi.getUnboxedType(), evaluatedVar));
}
}
}
// Compile the actual body of the alternate.
JavaStatement altStatement = genS_R(alt.getAltExpr(), variableContext);
caseBlock.addStatement(variableContext.popJavaScope());
caseBlock.addStatement(altStatement);
switchStatement.addCase(new SwitchStatement.IntCaseGroup(caseLabels, caseBlock));
}
}
}
// If no default case is provided, add case alternates for any missing data constructors.
// Switches in java are marginally more efficient if the case tags cover a contiguous block.
JavaStatement defaultCase = switchStatement.getDefaultStatement();
if (defaultCase == null) {
// Iterate over the array. For each case not provided, treat as an error.
List<Integer> intTagList = new ArrayList<Integer>();
for (int i = 0; i < caseExistsArray.length; ++i) {
if (!caseExistsArray[i]) {
// Add the ordinal to the list.
intTagList.add(Integer.valueOf(i));
}
}
addMissingCases(intTagList, typeCons, switchStatement, eswitch);
// Create a default default case.
defaultCase = generateReturn(getBadSwitchIndexCall(eswitch.getErrorInfo()), variableContext);
switchStatement.addCase (new SwitchStatement.DefaultCase(defaultCase));
}
return switchBlock;
}