private static PStm GetPrevious(PStm stm)
{
while (true)
{
AABlock pBlock = Util.GetAncestor <AABlock>(stm);
if (pBlock == null)
{
return(null);
}
int index = pBlock.GetStatements().IndexOf(stm);
while (index > 0)
{
stm = GetLast((PStm)pBlock.GetStatements()[index - 1]);
if (stm != null)
{
return(stm);
}
index--;
}
stm = Util.GetAncestor <PStm>(pBlock);
if (stm == null)
{
return(null);
}
}
}
public override void CaseAThisArrayPropertyDecl(AThisArrayPropertyDecl node)
{
APropertyDecl replacer = new APropertyDecl(node.GetVisibilityModifier(), null, node.GetType(),
new TIdentifier("array property", node.GetToken().Line, node.GetToken().Pos),
node.GetGetter(), node.GetSetter());
List <AALocalDecl> locals = new List <AALocalDecl>();
if (replacer.GetGetter() != null)
{
AABlock block = (AABlock)replacer.GetGetter();
AALocalDecl local = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
(PType)node.GetArgType().Clone(),
(TIdentifier)node.GetArgName().Clone(), null);
block.GetStatements().Insert(0, new ALocalDeclStm(new TSemicolon(";"), local));
locals.Add(local);
}
if (replacer.GetSetter() != null)
{
AABlock block = (AABlock)replacer.GetSetter();
AALocalDecl local = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
(PType)node.GetArgType().Clone(),
(TIdentifier)node.GetArgName().Clone(), null);
block.GetStatements().Insert(0, new ALocalDeclStm(new TSemicolon(";"), local));
locals.Add(local);
}
node.ReplaceBy(replacer);
replacer.Apply(this);
}
public override void CaseALocalDeclStm(ALocalDeclStm node)
{
AMethodDecl pMethod = Util.GetAncestor <AMethodDecl>(node);
AALocalDecl decl = (AALocalDecl)node.GetLocalDecl();
if (decl.GetInit() == null)
{
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(decl.GetName().Text));
data.LocalLinks[lvalue] = decl;
data.LvalueTypes[lvalue] = decl.GetType();
List <PStm> statements = AssignDefault(lvalue);
AABlock pBlock = (AABlock)node.Parent();
foreach (PStm statement in statements)
{
pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(node), statement);
}
pBlock.RemoveChild(node);
}
else
{
//Make an assignment expression before moving
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(decl.GetName().Text));
data.LvalueTypes[lvalue] = decl.GetType();
AAssignmentExp exp = new AAssignmentExp(new TAssign("="), lvalue, decl.GetInit());
AExpStm expStm = new AExpStm(new TSemicolon(";"), exp);
node.ReplaceBy(expStm);
data.LvalueTypes[lvalue] = decl.GetType();
data.ExpTypes[exp] = decl.GetType();
data.LocalLinks[lvalue] = decl;
}
AABlock block = (AABlock)pMethod.GetBlock();
block.GetStatements().Insert(0, node);
}
private static PStm GetNext(PStm stm)
{
while (true)
{
AABlock pBlock = Util.GetAncestor <AABlock>(stm);
if (pBlock == null)
{
return(null);
}
int index = pBlock.GetStatements().IndexOf(stm);
while (index < pBlock.GetStatements().Count - 1)
{
stm = GetFirst((PStm)pBlock.GetStatements()[index + 1]);
if (stm != null)
{
return(stm);
}
index++;
}
stm = Util.GetAncestor <PStm>(pBlock);
if (stm == null)
{
return(null);
}
}
}
public override void OutAMethodDecl(AMethodDecl node)
{
//If void return is missing, insert it.
if (node.GetReturnType() is AVoidType && node.GetBlock() != null)
{
AABlock block = (AABlock)node.GetBlock();
bool insertReturn = false;
while (true)
{
if (block.GetStatements().Count == 0)
{
insertReturn = true;
break;
}
PStm lastStm = (PStm)block.GetStatements()[block.GetStatements().Count - 1];
if (lastStm is AVoidReturnStm)
{
break;
}
if (lastStm is ABlockStm)
{
block = (AABlock)((ABlockStm)block.GetStatements()[block.GetStatements().Count - 1]).GetBlock();
continue;
}
insertReturn = true;
break;
}
if (insertReturn)
{
block.GetStatements().Add(new AVoidReturnStm(new TReturn("return", block.GetToken().Line, block.GetToken().Pos)));
}
}
base.OutAMethodDecl(node);
}
public override void OutAStructDecl(AStructDecl node)
{
//Insert init in each constructor
AThisLvalue thisLvalue = new AThisLvalue(new TThis("this"));
ALvalueExp thisExp = new ALvalueExp(thisLvalue);
APointerLvalue pointerLvalue = new APointerLvalue(new TStar("*"), thisExp);
ANamedType namedType = new ANamedType(new TIdentifier(node.GetName().Text), null);
data.StructTypeLinks[namedType] = node;
data.LvalueTypes[thisLvalue] =
data.ExpTypes[thisExp] = new APointerType(new TStar("*"), namedType);
data.LvalueTypes[pointerLvalue] = namedType;
foreach (AConstructorDecl constructor in node.GetLocals().OfType <ADeclLocalDecl>().Select(decl => decl.GetDecl()).OfType <AConstructorDecl>())
{
AABlock block = new AABlock(new ArrayList(), new TRBrace("}"));
MakeAssignments(block, namedType, pointerLvalue, false);
((AABlock)constructor.GetBlock()).GetStatements().Insert(0, new ABlockStm(new TLBrace("{"), block));
}
base.OutAStructDecl(node);
}
public override void CaseAWhileStm(AWhileStm node)
{
/*
* while(...){...}
* ->
* while(...){...}
* if (hasMethodReturnedVar)
* {
* break;
* }
*/
if (neededWhile)
{
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(hasMethodReturnedVar.GetName().Text));
data.LvalueTypes[lvalue] = hasMethodReturnedVar.GetType();
data.LocalLinks[lvalue] = hasMethodReturnedVar;
ALvalueExp exp = new ALvalueExp(lvalue);
data.ExpTypes[exp] = hasMethodReturnedVar.GetType();
AABlock ifBlock = new AABlock();
ifBlock.GetStatements().Add(new ABreakStm(new TBreak("break")));
ABlockStm ifBlockStm = new ABlockStm(new TLBrace("{"), ifBlock);
AIfThenStm ifStm = new AIfThenStm(new TLParen("("), exp, ifBlockStm);
AABlock pBlock = (AABlock)node.Parent();
pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(node) + 1, ifStm);
}
node.GetBody().Apply(this);
}
public override void CaseASimpleInvokeExp(ASimpleInvokeExp node)
{
PExp expNode = (PExp)node;
PType type = data.ExpTypes[expNode];
if (type is APointerType)
{
type = new ANamedType(new TIdentifier("string"), null);
}
ALocalLvalue local = new ALocalLvalue(new TIdentifier("tempName", 0, 0));
ALvalueExp exp = new ALvalueExp(local);
PStm stm = Util.GetAncestor <PStm>(node);
AABlock block = (AABlock)stm.Parent();
node.ReplaceBy(exp);
AALocalDecl localDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
Util.MakeClone(type, data),
new TIdentifier(varName, 0, 0), expNode);
ALocalDeclStm newStm = new ALocalDeclStm(new TSemicolon(";"), localDecl);
block.GetStatements().Insert(block.GetStatements().IndexOf(stm), newStm);
NewStatements.Add(newStm);
data.LvalueTypes[local] = type;
data.ExpTypes[exp] = type;
data.LocalLinks[local] = localDecl;
//localDecl.Apply(this);
exp.Apply(this);
return;
}
public override void CaseAVoidReturnStm(AVoidReturnStm node)
{
if (!neededWhile)
{
node.Parent().RemoveChild(node);
return;
}
/*
* return;
* ->
* hasMethodReturnedVar = true;
* break;
*/
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(hasMethodReturnedVar.GetName().Text));
data.LvalueTypes[lvalue] = hasMethodReturnedVar.GetType();
data.LocalLinks[lvalue] = hasMethodReturnedVar;
PExp exp = new ABooleanConstExp(new ATrueBool());
data.ExpTypes[exp] = new ANamedType(new TIdentifier("bool"), null);
exp = new AAssignmentExp(new TAssign("="), lvalue, exp);
data.ExpTypes[exp] = hasMethodReturnedVar.GetType();
PStm stm = new AExpStm(new TSemicolon(";"), exp);
AABlock block = new AABlock();
block.GetStatements().Add(stm);
block.GetStatements().Add(new ABreakStm(new TBreak("break")));
node.ReplaceBy(new ABlockStm(new TLBrace("{"), block));
}
public override void CaseAValueReturnStm(AValueReturnStm node)
{
/*
* return <exp>;
* ->
* methodReturnerVar = <exp>;
* hasMethodReturnedVar = true;
* break;
*/
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(methodReturnerVar.GetName().Text));
data.LvalueTypes[lvalue] = methodReturnerVar.GetType();
data.LocalLinks[lvalue] = methodReturnerVar;
AAssignmentExp exp = new AAssignmentExp(new TAssign("="), lvalue, node.GetExp());
data.ExpTypes[exp] = methodReturnerVar.GetType();
PStm stm = new AExpStm(new TSemicolon(";"), exp);
AABlock block = new AABlock();
block.GetStatements().Add(stm);
block.GetStatements().Add(new AVoidReturnStm(node.GetToken()));
node.ReplaceBy(new ABlockStm(new TLBrace("{"), block));
block.Apply(this);
}
public override void CaseAABlock(AABlock node)
{
Write("{\n");
foreach (PStm stm in node.GetStatements())
{
stm.Apply(this);
}
Write("}\n");
}
public static bool Parse(ControlFlowGraph cfg, SharedData data, out bool redoLivenessAnalysis)
{
bool changed = false;
redoLivenessAnalysis = false;
Dictionary <ControlFlowGraph.Node, List <ASimpleInvokeExp> > Modifications = new Dictionary <ControlFlowGraph.Node, List <ASimpleInvokeExp> >();
foreach (ControlFlowGraph.Node node in cfg.Nodes)
{
if (node.Expression is AAssignmentExp)
{
AAssignmentExp exp = (AAssignmentExp)node.Expression;
if (exp.GetLvalue() is ALocalLvalue)
{
AALocalDecl decl = data.LocalLinks[(ALocalLvalue)exp.GetLvalue()];
//If the variable is not live at any successors, remove this assignment
bool inUse = false;
foreach (ControlFlowGraph.Node successor in node.Successors)
{
if (successor.LiveVariables.Contains(decl))
{
inUse = true;
break;
}
}
if (!inUse)
{
//Move method invokes out
GetMethodInvokes getter = new GetMethodInvokes();
exp.GetExp().Apply(getter);
//Might also have to redo because we removed a reference to a variable in the right side
//if (getter.Invokes.Count > 0)
redoLivenessAnalysis = true;
Modifications[node] = getter.Invokes;
changed = true;
}
}
}
}
foreach (KeyValuePair <ControlFlowGraph.Node, List <ASimpleInvokeExp> > pair in Modifications)
{
ControlFlowGraph.Node node = pair.Key;
foreach (ASimpleInvokeExp invoke in pair.Value)
{
AExpStm stm = new AExpStm(new TSemicolon(";"), invoke);
AABlock pBlock = (AABlock)node.Statement.Parent();
pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(node.Statement), stm);
cfg.Insert(node, stm);
}
cfg.Remove(node);
node.Statement.Parent().RemoveChild(node.Statement);
}
return(changed);
}
public override void InAABlock(AABlock node)
{
AMethodDecl pMethod = Util.GetAncestor <AMethodDecl>(node);
if (!data.Locals.ContainsKey(node))
{
data.Locals.Add(node, new List <AALocalDecl>());
}
base.InAABlock(node);
}
public override void CaseAAssignmentExp(AAssignmentExp node)
{
if (!(node.Parent() is AExpStm))
{
PStm parentStm = Util.GetAncestor <PStm>(node);
MoveMethodDeclsOut mover = new MoveMethodDeclsOut("multipleAssignmentsVar", finalTrans.data);
node.GetLvalue().Apply(mover);
PLvalue lvalue = Util.MakeClone(node.GetLvalue(), finalTrans.data);
ALvalueExp exp = new ALvalueExp(lvalue);
finalTrans.data.ExpTypes[exp] = finalTrans.data.LvalueTypes[lvalue];
node.ReplaceBy(exp);
AExpStm stm = new AExpStm(new TSemicolon(";"), node);
AABlock block = (AABlock)parentStm.Parent();
//block.GetStatements().Insert(block.GetStatements().IndexOf(parentStm), localDeclStm);
block.GetStatements().Insert(block.GetStatements().IndexOf(parentStm), stm);
//localDeclStm.Apply(this);
stm.Apply(this);
if (parentStm is AWhileStm && Util.IsAncestor(exp, ((AWhileStm)parentStm).GetCondition()))
{
AWhileStm aStm = (AWhileStm)parentStm;
//Copy assignment before continues
//Before each continue in the while, and at the end.
//Add continue statement, if not present
block = (AABlock)((ABlockStm)aStm.GetBody()).GetBlock();
if (block.GetStatements().Count == 0 || !(block.GetStatements()[block.GetStatements().Count - 1] is AContinueStm))
{
block.GetStatements().Add(new AContinueStm(new TContinue("continue")));
}
//Get all continue statements in the while
ContinueFinder finder = new ContinueFinder();
block.Apply(finder);
foreach (AContinueStm continueStm in finder.Continues)
{
stm = new AExpStm(new TSemicolon(";"), Util.MakeClone(node, finalTrans.data));
block.GetStatements().Insert(block.GetStatements().IndexOf(continueStm), stm);
stm.Apply(this);
}
}
return;
}
base.CaseAAssignmentExp(node);
}
public override void CaseAContinueStm(AContinueStm node)
{
AABlock pBlock = (AABlock)node.Parent();
ALocalLvalue replaceVarRef = new ALocalLvalue(new TIdentifier("whileVar"));
ASimpleInvokeExp clone = (ASimpleInvokeExp)Util.MakeClone(this.node, data);
AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), replaceVarRef, clone);
data.LocalLinks[replaceVarRef] = replaceVarDecl;
data.ExpTypes[assignment] = data.LvalueTypes[replaceVarRef] = replaceVarDecl.GetType();
pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(node), new AExpStm(new TSemicolon(";"), assignment));
replacementExpressions.Add(clone);
}
//Remove unnessery blocks
public override void OutABlockStm(ABlockStm node)
{
if (node.Parent() is AABlock)
{
AABlock pBlock = (AABlock)node.Parent();
AABlock cBlock = (AABlock)node.GetBlock();
int index = pBlock.GetStatements().IndexOf(node);
pBlock.RemoveChild(node);
for (int i = cBlock.GetStatements().Count - 1; i >= 0; i--)
{
pBlock.GetStatements().Insert(index, cBlock.GetStatements()[i]);
}
}
}
//Convert struct variables to a collection of local variables
public override void CaseAALocalDecl(AALocalDecl node)
{
if (node.GetType() is ANamedType && data.StructTypeLinks.ContainsKey((ANamedType)node.GetType()) && Util.HasAncestor <PStm>(node))
{
//Can not have init - it would be bulk copy
AStructDecl str = data.StructTypeLinks[(ANamedType)node.GetType()];
Dictionary <AALocalDecl, AALocalDecl> variableMap = new Dictionary <AALocalDecl, AALocalDecl>();
PStm pStm = (PStm)node.Parent();
AABlock pBlock = (AABlock)pStm.Parent();
foreach (AALocalDecl structLocal in str.GetLocals())
{
AALocalDecl replacementLocal = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
Util.MakeClone(structLocal.GetType(), data),
new TIdentifier(node.GetName().Text + "_" +
structLocal.GetName().Text), null);
pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(pStm), new ALocalDeclStm(new TSemicolon(";"), replacementLocal));
AALocalDecl baseLocal = structLocal;
if (data.EnheritanceLocalMap.ContainsKey(baseLocal))
{
baseLocal = data.EnheritanceLocalMap[baseLocal];
}
List <AALocalDecl> localsToAdd = new List <AALocalDecl>();
localsToAdd.AddRange(data.EnheritanceLocalMap.Where(pair => pair.Value == baseLocal).Select(pair => pair.Key));
localsToAdd.Add(baseLocal);
foreach (AALocalDecl localDecl in localsToAdd)
{
variableMap[localDecl] = replacementLocal;
}
}
List <ALocalLvalue> uses = new List <ALocalLvalue>();
uses.AddRange(data.LocalLinks.Where(k => k.Value == node && Util.GetAncestor <AAProgram>(k.Key) != null).Select(k => k.Key));
foreach (ALocalLvalue lvalue in uses)
{
AStructLvalue structLocalRef = (AStructLvalue)lvalue.Parent().Parent();
AALocalDecl replacementLocal = variableMap[data.StructFieldLinks[structLocalRef]];
ALocalLvalue replacementLvalue = new ALocalLvalue(new TIdentifier(replacementLocal.GetName().Text));
data.LocalLinks[replacementLvalue] = replacementLocal;
data.LvalueTypes[replacementLvalue] = replacementLocal.GetType();
structLocalRef.ReplaceBy(replacementLvalue);
}
foreach (AALocalDecl replacementLocal in variableMap.Select(k => k.Value))
{
replacementLocal.Apply(this);
}
}
base.CaseAALocalDecl(node);
}
public override void CaseAABlock(AABlock node)
{
if (node == null)
{
return;
}
//If this is the first block, it marks the end
if (node.Parent() is AMethodDecl || node.Parent() is AInitializerDecl || node.Parent() is ATriggerDecl ||
node.Parent() is APropertyDecl || node.Parent() is AConstructorDecl || node.Parent() is ADeconstructorDecl)
{
End = TextPoint.FromCompilerCoords(node.GetToken().Line, node.GetToken().Pos);
}
base.CaseAABlock(node);
}
private void MakeAssignments(AABlock block, PType type, PLvalue leftSide, bool onEnhritedFields)
{
if (type is ANamedType && data.StructTypeLinks.ContainsKey((ANamedType)type))
{
AStructDecl str = data.StructTypeLinks[(ANamedType)type];
foreach (AALocalDecl field in str.GetLocals().OfType <AALocalDecl>())
{
if (!onEnhritedFields && data.EnheritanceLocalMap.ContainsKey(field))
{
continue;
}
ALvalueExp lvalueExp = new ALvalueExp(Util.MakeClone(leftSide, data));
data.ExpTypes[lvalueExp] = data.LvalueTypes[leftSide];
AStructLvalue newLeftSide = new AStructLvalue(lvalueExp, new ADotDotType(new TDot(".")), new TIdentifier(field.GetName().Text));
data.StructFieldLinks[newLeftSide] = field;
data.LvalueTypes[newLeftSide] = field.GetType();
if (field.GetInit() != null)
{
AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), newLeftSide,
Util.MakeClone(field.GetInit(), data));
data.ExpTypes[assignment] = data.LvalueTypes[newLeftSide];
block.GetStatements().Add(new AExpStm(new TSemicolon(";"),
assignment));
}
else
{
MakeAssignments(block, field.GetType(), newLeftSide, onEnhritedFields);
}
}
}
else if (type is AArrayTempType)
{
AArrayTempType aType = (AArrayTempType)type;
for (int i = 0; i < int.Parse(aType.GetIntDim().Text); i++)
{
AIntConstExp index = new AIntConstExp(new TIntegerLiteral(i.ToString()));
data.ExpTypes[index] = new ANamedType(new TIdentifier("int"), null);
ALvalueExp lvalueExp = new ALvalueExp(Util.MakeClone(leftSide, data));
data.ExpTypes[lvalueExp] = data.LvalueTypes[leftSide];
AArrayLvalue newLeftSide = new AArrayLvalue(new TLBracket("["), lvalueExp, index);
data.LvalueTypes[newLeftSide] = aType.GetType();
MakeAssignments(block, aType.GetType(), newLeftSide, onEnhritedFields);
}
}
}
public override void CaseAContinueStm(AContinueStm node)
{
AForStm forStm = Util.GetAncestor <AForStm>(node);
AABlock pBlock;
if (!(node.Parent() is AABlock))
{
pBlock = new AABlock(new ArrayList(), new TRBrace("}", node.GetToken().Line, node.GetToken().Pos));
ABlockStm blockStm = new ABlockStm(new TLBrace("{", node.GetToken().Line, node.GetToken().Pos), pBlock);
node.ReplaceBy(blockStm);
pBlock.GetStatements().Add(node);
}
pBlock = (AABlock)node.Parent();
pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(node), forStm.GetUpdate().Clone());
}
private static PStm GetNext(PStm stm)
{
while (true)
{
AABlock pBlock = Util.GetAncestor <AABlock>(stm);
if (pBlock == null)
{
return(null);
}
int index = pBlock.GetStatements().IndexOf(stm);
while (index < pBlock.GetStatements().Count - 1)
{
stm = GetFirst((PStm)pBlock.GetStatements()[index + 1]);
if (stm != null)
{
return(stm);
}
index++;
}
ASTNode node = pBlock;
stm = null;
while (true)
{
if (node == null)
{
return(null);
}
node = Util.GetNearestAncestor(node.Parent(), typeof(AABlock), typeof(PStm));
if (node is PStm)
{
stm = (PStm)node;
}
else if (stm == null)
{
continue;
}
else
{
break;
}
}
//stm = Util.GetAncestor<PStm>(pBlock);
if (stm == null)
{
return(null);
}
}
}
public override void OutAALocalDecl(AALocalDecl node)
{
if (!Util.HasAncestor <AABlock>(node) && !Util.HasAncestor <AMethodDecl>(node))
{
//OutStructFieldDecl(node);
return;
}
if (node.GetInit() != null)
{
return;
}
AABlock pBlock;
int insertIndex;
PLvalue lvalue;
if (Util.HasAncestor <AABlock>(node))
{
//A local variable
pBlock = Util.GetAncestor <AABlock>(node);
insertIndex = pBlock.GetStatements().IndexOf(Util.GetAncestor <PStm>(node)) + 1;
lvalue = new ALocalLvalue(new TIdentifier(node.GetName().Text));
data.LocalLinks[(ALocalLvalue)lvalue] = node;
data.LvalueTypes[lvalue] = node.GetType();
}
else
{
//Parameter
//Parameters will be set from the caller
return;
pBlock = (AABlock)Util.GetAncestor <AMethodDecl>(node).GetBlock();
insertIndex = 0;
lvalue = new ALocalLvalue(new TIdentifier(node.GetName().Text));
data.LocalLinks[(ALocalLvalue)lvalue] = node;
data.LvalueTypes[lvalue] = node.GetType();
}
AABlock block = new AABlock(new ArrayList(), new TRBrace("}"));
MakeAssignments(block, node.GetType(), lvalue, true);
if (block.GetStatements().Count != 0)
{
pBlock.GetStatements().Insert(insertIndex, new ABlockStm(new TLBrace("{"), block));
}
}
public override void CaseASwitchCaseStm(ASwitchCaseStm node)
{
AABlock block = (AABlock)node.GetBlock();
Token token;
if (node.GetType() is ACaseSwitchCaseType)
{
token = ((ACaseSwitchCaseType)node.GetType()).GetToken();
}
else
{
token = ((ADefaultSwitchCaseType)node.GetType()).GetToken();
}
block.SetToken(new TRBrace("{", token.Line, token.Pos));
base.CaseASwitchCaseStm(node);
}
private static PStm GetFirst(PStm stm)
{
if (stm is ABlockStm)
{
AABlock block = (AABlock)((ABlockStm)stm).GetBlock();
stm = null;
for (int i = 0; i < block.GetStatements().Count; i++)
{
stm = GetFirst((PStm)block.GetStatements()[i]);
if (stm != null)
{
return(stm);
}
}
}
return(stm);
}
private void MoveOut(PExp exp, PType type)
{
PStm pStm = Util.GetAncestor <PStm>(exp);
AABlock pBlock = (AABlock)pStm.Parent();
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier("gppVar"));
ALvalueExp lvalueExp = new ALvalueExp(lvalue);
exp.ReplaceBy(lvalueExp);
AALocalDecl decl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, Util.MakeClone(type, data), new TIdentifier("gppVar"), exp);
pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(pStm), new ALocalDeclStm(new TSemicolon(";"), decl));
data.LvalueTypes[lvalue] =
data.ExpTypes[lvalueExp] = decl.GetType();
data.LocalLinks[lvalue] = decl;
}
//Returns true if execution cannot continue after the block
private bool removeDeadCode(AABlock block)
{
bool isDead = false;
for (int i = 0; i < block.GetStatements().Count; i++)
{
PStm stm = (PStm)block.GetStatements()[i];
if (isDead)
{
block.GetStatements().RemoveAt(i);
i--;
}
else
{
isDead = removeDeadCode(stm);
}
}
return(isDead);
}
public override void CaseAVoidReturnStm(AVoidReturnStm node)
{
AMethodDecl baseDeconstructor = data.DeconstructorMap[data.StructDeconstructor[baseStruct]];
ALocalLvalue structFormalRef = new ALocalLvalue(new TIdentifier("currentStruct"));
ALvalueExp structFormalRefExp = new ALvalueExp(structFormalRef);
ASimpleInvokeExp invoke = new ASimpleInvokeExp(new TIdentifier("baseDeconstructor"),
new ArrayList()
{
structFormalRefExp
});
AABlock block = (AABlock)node.Parent();
block.GetStatements().Insert(block.GetStatements().IndexOf(node), new AExpStm(new TSemicolon(";"), invoke));
data.LocalLinks[structFormalRef] = structFormal;
data.SimpleMethodLinks[invoke] = baseDeconstructor;
data.LvalueTypes[structFormalRef] = data.ExpTypes[structFormalRefExp] = structFormal.GetType();
data.ExpTypes[invoke] = baseDeconstructor.GetReturnType();
}
public override void CaseAForStm(AForStm node)
{
//Replace with while
node.GetBody().Apply(new ReworkForContinues());
AABlock innerBlock = new AABlock();
innerBlock.SetToken(new TRBrace("{", node.GetToken().Line, node.GetToken().Pos));
innerBlock.GetStatements().Add(node.GetBody());
innerBlock.GetStatements().Add(node.GetUpdate());
ABlockStm innerBlockStm = new ABlockStm(new TLBrace(";"), innerBlock);
AWhileStm whileStm = new AWhileStm(node.GetToken(), node.GetCond(), innerBlockStm);
AABlock block = new AABlock();
block.SetToken(new TRBrace("{", whileStm.GetToken().Line, whileStm.GetToken().Pos));
block.GetStatements().Add(node.GetInit());
block.GetStatements().Add(whileStm);
ABlockStm blockStm = new ABlockStm(null, block);
node.ReplaceBy(blockStm);
blockStm.Apply(this);
}
public override void OutAALocalDecl(AALocalDecl node)
{
//Can have a local as a struct member, a parameter or a local variable
AABlock pBlock = Util.GetAncestor <AABlock>(node);
AMethodDecl pMethod = Util.GetAncestor <AMethodDecl>(node);
AConstructorDecl pConstructor = Util.GetAncestor <AConstructorDecl>(node);
AStructDecl pStruct = Util.GetAncestor <AStructDecl>(node);
if (pBlock != null)
{//We got a local variable
data.Locals[pBlock].Add(node);
data.UserLocals.Add(node);
}
else if (pMethod != null || pConstructor != null)
{//We got a parameter
if (pMethod != null)
{
pBlock = (AABlock)pMethod.GetBlock();
}
else
{
pBlock = (AABlock)pConstructor.GetBlock();
}
if (pBlock != null)
{
if (!data.Locals.ContainsKey(pBlock))
{
data.Locals.Add(pBlock, new List <AALocalDecl>());
}
data.Locals[pBlock].Add(node);
data.UserLocals.Add(node);
}
}
else
{//We got a struct variable
data.StructFields[pStruct].Add(node);
}
base.OutAALocalDecl(node);
}
private static List <PStm> GetLast(PStm stm)
{
List <PStm> returner = new List <PStm>();
if (stm is ABlockStm)
{
AABlock block = (AABlock)((ABlockStm)stm).GetBlock();
stm = null;
for (int i = block.GetStatements().Count - 1; i >= 0; i--)
{
returner.AddRange(GetLast((PStm)block.GetStatements()[i]));
if (returner.Count > 0)
{
return(returner);
}
}
}
else if (stm is AIfThenElseStm)
{
List <PStm> stms = new List <PStm>();
stms.AddRange(GetLast(((AIfThenElseStm)stm).GetThenBody()));
bool zero = stms.Count == 0;
returner.AddRange(stms);
stms.Clear();
stms.AddRange(GetLast(((AIfThenElseStm)stm).GetElseBody()));
zero |= stms.Count == 0;
returner.AddRange(stms);
if (zero)
{
returner.Add(stm);
}
}
else
{
returner.Add(stm);
}
return(returner);
}
