internal Cases_Cast(ASwitchStm obj)
{
this.obj = obj;
}
public virtual void InASwitchStm(ASwitchStm node)
{
DefaultIn(node);
}
public virtual void OutASwitchStm(ASwitchStm node)
{
DefaultOut(node);
}
public override void CaseASwitchStm(ASwitchStm node)
{
InASwitchStm(node);
{
Object[] temp = new Object[node.GetCases().Count];
node.GetCases().CopyTo(temp, 0);
for (int i = temp.Length - 1; i >= 0; i--)
{
((PStm)temp[i]).Apply(this);
}
}
if (node.GetTest() != null)
{
node.GetTest().Apply(this);
}
if (node.GetToken() != null)
{
node.GetToken().Apply(this);
}
OutASwitchStm(node);
}
public virtual void CaseASwitchStm(ASwitchStm node)
{
DefaultCase(node);
}
public override void OutAEnumDecl(AEnumDecl node)
{
AStructDecl replacer = new AStructDecl(node.GetVisibilityModifier(), null, null, null, node.GetEndToken(),
node.GetName(), new ArrayList(), null, new ArrayList());
TIdentifier typeIdentifier = new TIdentifier("byte");
ASwitchStm switchStm = new ASwitchStm(new TSwitch("switch"),
new ALvalueExp(
new AAmbiguousNameLvalue(new AAName(new ArrayList() {new TIdentifier("enum")}))),
new ArrayList());
;
AMethodDecl toStringMethod = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null,
new ANamedType(new TIdentifier("string"), null),
new TIdentifier("toString"),
new ArrayList()
{
new AALocalDecl(new APublicVisibilityModifier(), null,
null, null, null,
new ANamedType(typeIdentifier, null),
new TIdentifier("enum"), null)
},
new AABlock(
new ArrayList()
{
switchStm,
new AValueReturnStm(new TReturn("return"), new ANullExp())
}, new TRBrace("}")));
replacer.GetLocals().Add(new ADeclLocalDecl(toStringMethod));
int intVal = 0;
int min = int.MaxValue;
int max = int.MinValue;
List<TIdentifier> types = new List<TIdentifier>(){typeIdentifier};
Dictionary<int, List<AALocalDecl>> usedValues = new Dictionary<int, List<AALocalDecl>>();
foreach (AAEnumLocal value in node.GetValues())
{
AIntConstExp intConst;
if (value.GetValue() != null)
{
intConst = (AIntConstExp) value.GetValue();
intVal = int.Parse(intConst.GetIntegerLiteral().Text) + 1;
}
else
{
intConst = new AIntConstExp(new TIntegerLiteral(intVal.ToString(), value.GetName().Line, value.GetName().Pos));
intVal++;
}
min = Math.Min(intVal - 1, min);
max = Math.Max(intVal - 1, max);
typeIdentifier = new TIdentifier("byte", value.GetName().Line, value.GetName().Pos);
types.Add(typeIdentifier);
switchStm.GetCases().Add(
new ASwitchCaseStm(new ACaseSwitchCaseType(new TCase("case"), (PExp) intConst.Clone()),
new AABlock(
new ArrayList()
{
new AValueReturnStm(new TReturn("return"),
new AStringConstExp(
new TStringLiteral("\"" +
value.GetName().Text +
"\"")))
}, new TRBrace("}"))));
AALocalDecl localDecl = new AALocalDecl(new APublicVisibilityModifier(),
new TStatic("static", value.GetName().Line, value.GetName().Pos),
null, null,
new TConst("const", value.GetName().Line, value.GetName().Pos),
new ANamedType(typeIdentifier, null), value.GetName(), intConst);
replacer.GetLocals().Add(localDecl);
if (!usedValues.ContainsKey(intVal - 1))
usedValues[intVal - 1] = new List<AALocalDecl>();
usedValues[intVal - 1].Add(localDecl);
}
if (min < 0 || max > 255)
foreach (TIdentifier identifier in types)
{
identifier.Text = "int";
}
node.ReplaceBy(replacer);
foreach (KeyValuePair<int, List<AALocalDecl>> pair in usedValues)
{
if (pair.Value.Count <= 1)
continue;
int value = pair.Key;
List<ErrorCollection.Error> subErrors = new List<ErrorCollection.Error>();
foreach (AALocalDecl decl in pair.Value)
{
subErrors.Add(new ErrorCollection.Error(decl.GetName(), LocRM.GetString("ErrorText179")));
}
errors.Add(new ErrorCollection.Error(replacer.GetName(), LocRM.GetString("ErrorText180") + value + ".", false, subErrors.ToArray()));
}
replacer.Apply(this);
data.Enums.Add(replacer, min < 0 || max > 255);
}
public override void CaseASwitchStm(ASwitchStm node)
{
node.GetTest().Apply(this);
AALocalDecl fallThroughDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
new ANamedType(new TIdentifier("bool"), null),
new TIdentifier(MakeUniqueLocalName(node, "switchFallThrough")),
new ABooleanConstExp(new AFalseBool()));
AALocalDecl continueDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
new ANamedType(new TIdentifier("bool"), null),
new TIdentifier(MakeUniqueLocalName(node, "switchContinue")),
new ABooleanConstExp(new ATrueBool()));
AALocalDecl testVar = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
Util.MakeClone(data.ExpTypes[node.GetTest()], data),
new TIdentifier(MakeUniqueLocalName(node, "switchTestVar")),
node.GetTest());
AABlock bigBlock = new AABlock();
//AABlock previousBlock = bigBlock;
if (node.GetCases().Count > 0)
{
List<SwitchCaseData> switchCaseDatas = new List<SwitchCaseData>();
//Join cases without a body
for (int i = node.GetCases().Count - 1; i >= 0; i--)
{
ASwitchCaseStm caseStm = (ASwitchCaseStm) node.GetCases()[i];
SwitchCaseData caseData = new SwitchCaseData();
caseData.Block = (AABlock) caseStm.GetBlock();
if (caseStm.GetType() is ACaseSwitchCaseType)
caseData.Tests.Add(((ACaseSwitchCaseType)caseStm.GetType()).GetExp());
else
caseData.ContainsDefault = true;
caseData.IsLast = switchCaseDatas.Count == 0;
if (switchCaseDatas.Count == 0 || caseData.Block.GetStatements().Count > 0)
{
switchCaseDatas.Insert(0, caseData);
continue;
}
switchCaseDatas[0].Tests.AddRange(caseData.Tests);
}
for (int i = switchCaseDatas.Count - 1; i >= 0; i--)
{
switchCaseDatas[i].ContainsFallthrough = CanFallthrough(switchCaseDatas[i].Block, out switchCaseDatas[i].HasBreaks, out switchCaseDatas[i].RequiresWhile);
if (i == switchCaseDatas.Count - 1)
continue;
switchCaseDatas[i + 1].TargetForFallThrough = switchCaseDatas[i].ContainsFallthrough;
switchCaseDatas[i].RequiresContinue = !switchCaseDatas[i].ContainsFallthrough &&
(switchCaseDatas[i + 1].RequiresContinue ||
switchCaseDatas[i + 1].ContainsFallthrough);
}
AABlock previousBlock = bigBlock;
//Make code for specific case
foreach (SwitchCaseData switchCase in switchCaseDatas)
{
List<PExp> tests = new List<PExp>();
AABlock nextBlock;
if (switchCase.TargetForFallThrough)
{//Add if (continueSwitch) {}
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(continueDecl.GetName().Text));
ALvalueExp test = new ALvalueExp(lvalue);
nextBlock = new AABlock();
AIfThenStm ifStm = new AIfThenStm(new TLParen("("), test, new ABlockStm(new TLBrace("{"), nextBlock));
previousBlock.GetStatements().Add(ifStm);
previousBlock = nextBlock;
data.LocalLinks[lvalue] = continueDecl;
data.LvalueTypes[lvalue] = data.ExpTypes[test] = continueDecl.GetType();
//First test in next if: if (fallThrough || ...
lvalue = new ALocalLvalue(new TIdentifier(fallThroughDecl.GetName().Text));
test = new ALvalueExp(lvalue);
tests.Add(test);
data.LocalLinks[lvalue] = fallThroughDecl;
data.LvalueTypes[lvalue] = data.ExpTypes[test] = fallThroughDecl.GetType();
}
//Make code for the test in the if
foreach (PExp exp in switchCase.Tests)
{
ALocalLvalue leftSide = new ALocalLvalue(new TIdentifier(testVar.GetName().Text));
ALvalueExp lvalueExp = new ALvalueExp(leftSide);
ABinopExp test = new ABinopExp(lvalueExp, new AEqBinop(new TEq("==")), exp);
tests.Add(test);
data.LocalLinks[leftSide] = testVar;
data.LvalueTypes[leftSide] = data.ExpTypes[lvalueExp] = testVar.GetType();
data.ExpTypes[test] = new ANamedType(new TIdentifier("bool"), null);
}
if (switchCase.ContainsDefault)
{
ABooleanConstExp test = new ABooleanConstExp(new ATrueBool());
tests.Add(test);
data.ExpTypes[test] = new ANamedType(new TIdentifier("bool"), null);
}
PExp finalTest = tests[0];
tests.RemoveAt(0);
foreach (PExp exp in tests)
{
finalTest = new ABinopExp(finalTest, new ALazyOrBinop(new TOrOr("||")), exp);
data.ExpTypes[finalTest] = new ANamedType(new TIdentifier("bool"), null);
}
//Transform breaks into assignments
//If we can fallthrough, and there are breaks, encase in a while stm
AABlock testBlock = switchCase.Block;
if (switchCase.RequiresWhile)
{
AABlock newBlock = new AABlock();
PExp whileTest = new ABooleanConstExp(new ATrueBool());
AWhileStm whileStm = new AWhileStm(new TLParen("("), whileTest, new ABlockStm(new TLBrace("{"), switchCase.Block));
newBlock.GetStatements().Add(whileStm);
switchCase.Block = newBlock;
}
TransformBreaks(testBlock, switchCase, continueDecl, fallThroughDecl);
if (switchCase.ContainsFallthrough && !switchCase.TargetForFallThrough)
{//Add fallthrough = true;
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(fallThroughDecl.GetName().Text));
ABooleanConstExp rightSide = new ABooleanConstExp(new ATrueBool());
AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), lvalue, rightSide);
testBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment));
data.LocalLinks[lvalue] = fallThroughDecl;
data.LvalueTypes[lvalue] = data.ExpTypes[rightSide] = data.ExpTypes[assignment] = fallThroughDecl.GetType();
}
if (switchCase.RequiresWhile)
{//Add break at the end of the while
testBlock.GetStatements().Add(new ABreakStm(new TBreak("break")));
}
//Make if
PStm finalIfStm;
if (finalTest is ABooleanConstExp)
{//Final if is if(true). dont add it.
finalIfStm = new ABlockStm(new TLBrace("{"), switchCase.Block);
nextBlock = new AABlock();
}
else if (switchCase.IsLast || switchCase.ContainsFallthrough)
{//One armed if
finalIfStm = new AIfThenStm(new TLParen("("), finalTest,
new ABlockStm(new TLBrace("{"), switchCase.Block));
nextBlock = bigBlock;
}
else
{//Two armed if
nextBlock = new AABlock();
finalIfStm = new AIfThenElseStm(new TLParen("("), finalTest,
new ABlockStm(new TLBrace("{"), switchCase.Block),
new ABlockStm(new TLBrace("{"), nextBlock));
}
previousBlock.GetStatements().Add(finalIfStm);
previousBlock = nextBlock;
}
//If needed, add fallThroughDecl and continueDecl
data.Locals.Add(bigBlock, new List<AALocalDecl>());
if (data.LocalLinks.Values.Contains(fallThroughDecl))
{
bigBlock.GetStatements().Insert(0, new ALocalDeclStm(new TSemicolon(";"), fallThroughDecl));
data.Locals[bigBlock].Add(fallThroughDecl);
}
if (data.LocalLinks.Values.Contains(continueDecl))
{
bigBlock.GetStatements().Insert(0, new ALocalDeclStm(new TSemicolon(";"), continueDecl));
data.Locals[bigBlock].Add(continueDecl);
}
bigBlock.GetStatements().Insert(0, new ALocalDeclStm(new TSemicolon(";"), testVar));
data.Locals[bigBlock].Add(testVar);
node.ReplaceBy(new ABlockStm(new TLBrace("{"), bigBlock));
bigBlock.Apply(this);
}
}
ArrayList New277()
{
ArrayList nodeList = new ArrayList();
ArrayList nodeArrayList7 = (ArrayList) Pop();
ArrayList nodeArrayList6 = (ArrayList) Pop();
ArrayList nodeArrayList5 = (ArrayList) Pop();
ArrayList nodeArrayList4 = (ArrayList) Pop();
ArrayList nodeArrayList3 = (ArrayList) Pop();
ArrayList nodeArrayList2 = (ArrayList) Pop();
ArrayList nodeArrayList1 = (ArrayList) Pop();
TypedList listNode5 = new TypedList();
TSwitch tswitchNode2 = (TSwitch)nodeArrayList1[0];
PExp pexpNode3 = (PExp)nodeArrayList3[0];
TypedList listNode4 = (TypedList)nodeArrayList6[0];
if ( listNode4 != null )
{
listNode5.AddAll(listNode4);
}
ASwitchStm pstmNode1 = new ASwitchStm (
tswitchNode2,
pexpNode3,
listNode5
);
nodeList.Add(pstmNode1);
return nodeList;
}
