public override void CaseALocalLvalue(ALocalLvalue node) { if (Util.HasAncestor <AMethodDecl>(node) && //Is in a method data.LocalLinks[node].Parent() == Util.GetAncestor <AMethodDecl>(node)) //Is a link to a formal in that method { if (Util.HasAncestor <AAssignmentExp>(node) && //Is in an assignement Util.IsAncestor(node, Util.GetAncestor <AAssignmentExp>(node).GetLvalue())) //Is left side of the assignment { AssignedFormals.Add(data.LocalLinks[node]); } else if (Util.HasAncestor <ASimpleInvokeExp>(node)) { ASimpleInvokeExp invoke = Util.GetAncestor <ASimpleInvokeExp>(node); AMethodDecl method = data.SimpleMethodLinks[invoke]; for (int i = 0; i < invoke.GetArgs().Count; i++) { AALocalDecl formal = (AALocalDecl)method.GetFormals()[i]; if ((formal.GetRef() != null || formal.GetOut() != null) && Util.IsAncestor(node, (Node)invoke.GetArgs()[i])) { AssignedFormals.Add(data.LocalLinks[node]); return; } } } } }
public override void CaseALocalLvalue(ALocalLvalue node) { if (isLeftsideOfAssignment) { assignedToLocals.Add(data.LocalLinks[node]); } }
public override void CaseAAssignmentExp(AAssignmentExp node) { if (!processMethodsOnly && !processStructs) { if (!processFieldsOnly) { if (node.GetLvalue() is ALocalLvalue) { ALocalLvalue lvalue = (ALocalLvalue)node.GetLvalue(); assignedToLocals[finalTrans.data.LocalLinks[lvalue]].Add(node); node.GetExp().Apply(this); return; } } if (node.GetLvalue() is AFieldLvalue) { AFieldLvalue lvalue = (AFieldLvalue)node.GetLvalue(); AFieldDecl decl = finalTrans.data.FieldLinks[lvalue]; if (!assignedToFields[decl].Contains(node)) { assignedToFields[decl].Add(node); } node.GetExp().Apply(this); return; } } base.CaseAAssignmentExp(node); }
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); }
public override void CaseAStructFieldLvalue(AStructFieldLvalue node) { //replace strField1 //with <structFormal>.strField1 AStructDecl str = finalTrans.data.StructTypeLinks[(ANamedType)structFormal.GetType()]; ALocalLvalue parameterRefference = new ALocalLvalue(new TIdentifier("tempName")); finalTrans.data.LocalLinks[parameterRefference] = structFormal; finalTrans.data.LvalueTypes[parameterRefference] = structFormal.GetType(); ALvalueExp exp = new ALvalueExp(parameterRefference); finalTrans.data.ExpTypes[exp] = structFormal.GetType(); AStructLvalue replacer = new AStructLvalue(exp, new ADotDotType(new TDot(".")), node.GetName()); foreach (AALocalDecl structField in finalTrans.data.StructFields[str]) { if (structField.GetName().Text == replacer.GetName().Text) { finalTrans.data.StructFieldLinks[replacer] = structField; finalTrans.data.LvalueTypes[replacer] = structField.GetType(); break; } } foreach (APropertyDecl property in finalTrans.data.StructProperties[str]) { if (property.GetName().Text == replacer.GetName().Text) { finalTrans.data.StructPropertyLinks[replacer] = property; finalTrans.data.LvalueTypes[replacer] = property.GetType(); break; } } node.ReplaceBy(replacer); }
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 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 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; }
private AMethodDecl GetIntPointerMethod() { if (GetIntPointerPartMethod != null) { return(GetIntPointerPartMethod); } /* * int GetIntPointerPart(string delegate) * { * return IntToString(GetPointerPart(delegate)); * } */ AASourceFile sourceFile = Util.GetAncestor <AASourceFile>(finalTrans.mainEntry); AALocalDecl delegateFormal = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, new ANamedType(new TIdentifier("string"), null), new TIdentifier("delegate"), null); ALocalLvalue delegateRef1 = new ALocalLvalue(new TIdentifier("delegate")); ALvalueExp delegateRef1Exp = new ALvalueExp(delegateRef1); ASimpleInvokeExp getPointerPartInvoke = new ASimpleInvokeExp(new TIdentifier("GetPointerPart"), new ArrayList() { delegateRef1Exp }); ASimpleInvokeExp StringToIntInvoke = new ASimpleInvokeExp(new TIdentifier("StringToInt"), new ArrayList() { getPointerPartInvoke }); GetIntPointerPartMethod = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null, new ANamedType(new TIdentifier("int"), null), new TIdentifier("GetPointerPart", finalTrans.data.LineCounts[sourceFile] + 1, 1), new ArrayList() { delegateFormal }, new AABlock( new ArrayList() { new AValueReturnStm(new TReturn("return"), StringToIntInvoke) }, new TRBrace("}"))); sourceFile.GetDecl().Add(GetIntPointerPartMethod); data.Methods.Add(new SharedData.DeclItem <AMethodDecl>(sourceFile, GetIntPointerPartMethod)); finalTrans.data.LocalLinks[delegateRef1] = delegateFormal; finalTrans.data.LvalueTypes[delegateRef1] = finalTrans.data.ExpTypes[delegateRef1Exp] = finalTrans.data.ExpTypes[getPointerPartInvoke] = new ANamedType(new TIdentifier("string"), null); finalTrans.data.ExpTypes[StringToIntInvoke] = new ANamedType(new TIdentifier("int"), null); finalTrans.data.SimpleMethodLinks[getPointerPartInvoke] = GetStringPointerMethod(); finalTrans.data.SimpleMethodLinks[StringToIntInvoke] = finalTrans.data.Libraries.Methods.First(m => m.GetName().Text == StringToIntInvoke.GetName().Text); return(GetIntPointerPartMethod); }
public override void CaseALocalLvalue(ALocalLvalue node) { if (data.LocalLinks[node] == decl) { lvalue = node; count++; } }
public override void OutAValueLvalue(AValueLvalue node) { ALocalLvalue replacer = new ALocalLvalue(new TIdentifier("value")); node.ReplaceBy(replacer); data.LocalLinks[replacer] = valueDecl; data.LvalueTypes[replacer] = valueDecl.GetType(); }
public override void CaseAVoidReturnStm(AVoidReturnStm node) { ALocalLvalue paramRef = new ALocalLvalue(new TIdentifier("paramRef")); ALvalueExp paramRefExp = new ALvalueExp(paramRef); node.ReplaceBy(new AValueReturnStm(node.GetToken(), paramRefExp)); data.LocalLinks[paramRef] = param; data.LvalueTypes[paramRef] = data.ExpTypes[paramRefExp] = param.GetType(); }
public override void CaseALocalLvalue(ALocalLvalue node) { AALocalDecl decl = data.LocalLinks[node]; if (!UsedLocals.Contains(decl)) { UsedLocals.Add(decl); } }
public override void CaseAThisLvalue(AThisLvalue node) { //Replace with <structFormal> ALocalLvalue parameterRefference = new ALocalLvalue(new TIdentifier("tempName")); finalTrans.data.LocalLinks[parameterRefference] = structFormal; finalTrans.data.LvalueTypes[parameterRefference] = structFormal.GetType(); node.ReplaceBy(parameterRefference); base.CaseAThisLvalue(node); }
private int FoldInt(PLvalue lvalue, ref bool valid) { if (!valid) { return(-1); } if (lvalue is ALocalLvalue) { ALocalLvalue aLvalue = (ALocalLvalue)lvalue; AALocalDecl decl = data.LocalLinks[aLvalue]; if (decl.GetConst() == null) { valid = false; return(-1); } return(FoldInt(decl.GetInit(), ref valid)); } if (lvalue is AFieldLvalue) { AFieldLvalue aLvalue = (AFieldLvalue)lvalue; AFieldDecl decl = data.FieldLinks[aLvalue]; if (decl.GetConst() == null) { valid = false; return(-1); } return(FoldInt(decl.GetInit(), ref valid)); } if (lvalue is AStructFieldLvalue) { AStructFieldLvalue aLvalue = (AStructFieldLvalue)lvalue; AALocalDecl decl = data.StructMethodFieldLinks[aLvalue]; if (decl.GetConst() == null) { valid = false; return(-1); } return(FoldInt(decl.GetInit(), ref valid)); } if (lvalue is AStructLvalue) { AStructLvalue aLvalue = (AStructLvalue)lvalue; AALocalDecl decl = data.StructFieldLinks[aLvalue]; if (decl.GetConst() == null) { valid = false; return(-1); } return(FoldInt(decl.GetInit(), ref valid)); } valid = false; return(-1); }
public override void CaseAAssignmentExp(AAssignmentExp node) { currentLocal = null; node.GetLvalue().Apply(this); if (currentLocal != null) { AALocalDecl decl = data.LocalLinks[currentLocal]; NeededRefs[Util.GetAncestor <AMethodDecl>(node)].Add(decl); } node.GetExp().Apply(this); }
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); }
public override void CaseALocalLvalue(ALocalLvalue node) { //Only if it is not what it is assigning to AAssignmentExp exp = Util.GetAncestor <AAssignmentExp>(node); if (exp != null && node == exp.GetLvalue()) { return; } UsedLocals.Add(data.LocalLinks[node]); }
//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 CaseALocalLvalue(ALocalLvalue node) { if (processFieldsOnly || processMethodsOnly || processStructs) { return; } AALocalDecl decl = finalTrans.data.LocalLinks[node]; if (!usedLocals.Contains(decl)) { usedLocals.Add(decl); } base.CaseALocalLvalue(node); }
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 OutALocalLvalue(ALocalLvalue node) { if (currentMethod == null) { return; } AALocalDecl decl = data.LocalLinks[node]; Node n = node; while (true) { n = Util.GetNearestAncestor(n.Parent(), typeof(AMethodDecl), typeof(AAssignmentExp), typeof(AArrayLvalue)); if (n is AMethodDecl) { break; } if (n is AAssignmentExp) { if (Util.IsAncestor(node, ((AAssignmentExp)n).GetLvalue())) { if (!WrittenLocals[currentMethod].Contains(decl)) { WrittenLocals[currentMethod].Add(decl); } return; } break; } if (n is AArrayLvalue) { if (Util.IsAncestor(node, ((AArrayLvalue)n).GetBase())) { continue; } break; } break; } if (!ReadLocals[currentMethod].Contains(decl)) { ReadLocals[currentMethod].Add(decl); } }
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; }
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 CaseASimpleInvokeExp(ASimpleInvokeExp node) { AMethodDecl target = data.SimpleMethodLinks[node]; for (int i = 0; i < node.GetArgs().Count; i++) { PExp arg = (PExp)node.GetArgs()[i]; currentLocal = null; arg.Apply(this); if (currentLocal != null && target.GetFormals().Cast <AALocalDecl>().ToList()[i].GetRef() != null) { ALocalLvalue local = currentLocal; target.Apply(this); if (target.GetFormals().Cast <AALocalDecl>().ToList()[i].GetRef() != null) { AALocalDecl decl = data.LocalLinks[local]; NeededRefs[Util.GetAncestor <AMethodDecl>(node)].Add(decl); } } } }
public override void OutALocalLvalue(ALocalLvalue node) { if (folding) { AALocalDecl local = data.LocalLinks[node]; if (local.GetConst() == null) { if (!isANewExp) { errors.Add( new ErrorCollection.Error(node.GetName(), LocRM.GetString("ErrorText61"), false), true); throw new ParserException(null, null); } } if (local.GetInit() == null)//An error will be given earlier { throw new ParserException(null, null); } local.GetInit().Apply(this); } }
public override void OutALocalLvalue(ALocalLvalue node) { if (folding) { AALocalDecl local = data.LocalLinks[node]; if (local.GetConst() == null) { if (!isANewExp) { errors.Add( new ErrorCollection.Error(node.GetName(), "Dimensions of array types must be constant expressions.", false), true); throw new ParserException(null, null); } } if (local.GetInit() == null)//An error will be given earlier { throw new ParserException(null, null); } local.GetInit().Apply(this); } }
public override void OutAAProgram(AAProgram node) { //Fix types foreach (var pair in data.LocalLinks.Where(pair => Util.HasAncestor <AAProgram>(pair.Key) && !Util.TypesEqual(data.ExpTypes[(PExp)pair.Key.Parent()], pair.Value.GetType(), data))) { ALocalLvalue lvalue = pair.Key; AALocalDecl decl = pair.Value; data.LvalueTypes[lvalue] = decl.GetType(); if (lvalue.Parent() is ALvalueExp) { data.ExpTypes[(PExp)lvalue.Parent()] = decl.GetType(); if (lvalue.Parent().Parent() is APointerLvalue) { data.LvalueTypes[(PLvalue)lvalue.Parent().Parent()] = ((APointerType)decl.GetType()).GetType(); } } } base.OutAAProgram(node); }
public static bool ReturnsTheSame(PLvalue left, PLvalue right, SharedData data) { if (left.GetType() != right.GetType()) { return(false); } if (left is ALocalLvalue) { ALocalLvalue aLeft = (ALocalLvalue)left; ALocalLvalue aRight = (ALocalLvalue)right; return(data.LocalLinks[aLeft] == data.LocalLinks[aRight]); } if (left is AFieldLvalue) { AFieldLvalue aLeft = (AFieldLvalue)left; AFieldLvalue aRight = (AFieldLvalue)right; return(data.FieldLinks[aLeft] == data.FieldLinks[aRight]); } if (left is AStructLvalue) { AStructLvalue aLeft = (AStructLvalue)left; AStructLvalue aRight = (AStructLvalue)right; if (data.StructFieldLinks[aLeft] != data.StructFieldLinks[aRight]) { return(false); } return(ReturnsTheSame(aLeft.GetReceiver(), aRight.GetReceiver(), data)); } if (left is AArrayLvalue) { AArrayLvalue aLeft = (AArrayLvalue)left; AArrayLvalue aRight = (AArrayLvalue)right; return(ReturnsTheSame(aLeft.GetIndex(), aRight.GetIndex(), data) && ReturnsTheSame(aLeft.GetBase(), aRight.GetBase(), data)); } throw new Exception("Util.ReturnsTheSame. Unexpected type, got " + left.GetType()); }