private AMethodDecl GetStringPointerMethod()
        {
            if (GetStringPointerPartMethod != null)
                return GetStringPointerPartMethod;
            /*
             *  string GetPointerPart(string delegate)
             *  {
             *      return StringSub(delegate, StringFind(delegate, ":", false) + 1, StringLength(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"));
            ALocalLvalue delegateRef2 = new ALocalLvalue(new TIdentifier("delegate"));
            ALocalLvalue delegateRef3 = new ALocalLvalue(new TIdentifier("delegate"));
            ALvalueExp delegateRef1Exp = new ALvalueExp(delegateRef1);
            ALvalueExp delegateRef2Exp = new ALvalueExp(delegateRef2);
            ALvalueExp delegateRef3Exp = new ALvalueExp(delegateRef3);

            AStringConstExp stringConst = new AStringConstExp(new TStringLiteral("\":\""));
            ABooleanConstExp booleanConst = new ABooleanConstExp(new AFalseBool());
            ASimpleInvokeExp stringFindInvoke = new ASimpleInvokeExp(new TIdentifier("StringFind"), new ArrayList(){delegateRef2Exp, stringConst, booleanConst});
            AIntConstExp intConst = new AIntConstExp(new TIntegerLiteral("1"));
            ABinopExp binop = new ABinopExp(stringFindInvoke, new APlusBinop(new TPlus("+")), intConst);

            ASimpleInvokeExp stringLengthInvoke = new ASimpleInvokeExp(new TIdentifier("StringLength"), new ArrayList() { delegateRef3Exp });

            ASimpleInvokeExp stringSubInvoke = new ASimpleInvokeExp(new TIdentifier("StringSub"), new ArrayList(){delegateRef1Exp, binop, stringLengthInvoke});

            GetStringPointerPartMethod = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null,
                                                 new ANamedType(new TIdentifier("string"), null),
                                                 new TIdentifier("GetPointerPart", finalTrans.data.LineCounts[sourceFile] + 1, 1), new ArrayList() {delegateFormal},
                                                 new AABlock(
                                                     new ArrayList()
                                                         {new AValueReturnStm(new TReturn("return"), stringSubInvoke)},
                                                     new TRBrace("}")));
            sourceFile.GetDecl().Add(GetStringPointerPartMethod);
            data.Methods.Add(new SharedData.DeclItem<AMethodDecl>(sourceFile, GetStringPointerPartMethod));

            finalTrans.data.LocalLinks[delegateRef1] =
                finalTrans.data.LocalLinks[delegateRef2] =
                finalTrans.data.LocalLinks[delegateRef3] = delegateFormal;
            finalTrans.data.LvalueTypes[delegateRef1] =
                finalTrans.data.LvalueTypes[delegateRef2] =
                finalTrans.data.LvalueTypes[delegateRef3] =
                finalTrans.data.ExpTypes[delegateRef1Exp] =
                finalTrans.data.ExpTypes[delegateRef2Exp] =
                finalTrans.data.ExpTypes[delegateRef3Exp] =
                finalTrans.data.ExpTypes[stringConst] =
                finalTrans.data.ExpTypes[stringSubInvoke] = new ANamedType(new TIdentifier("string"), null);
            finalTrans.data.ExpTypes[booleanConst] = new ANamedType(new TIdentifier("bool"), null);
            finalTrans.data.ExpTypes[intConst] =
                finalTrans.data.ExpTypes[binop] =
                finalTrans.data.ExpTypes[stringFindInvoke] =
                finalTrans.data.ExpTypes[stringLengthInvoke] = new ANamedType(new TIdentifier("int"), null);

            finalTrans.data.SimpleMethodLinks[stringFindInvoke] =
                finalTrans.data.Libraries.Methods.First(m => m.GetName().Text == stringFindInvoke.GetName().Text);
            finalTrans.data.SimpleMethodLinks[stringLengthInvoke] =
                finalTrans.data.Libraries.Methods.First(m => m.GetName().Text == stringLengthInvoke.GetName().Text);
            finalTrans.data.SimpleMethodLinks[stringSubInvoke] =
                finalTrans.data.Libraries.Methods.First(m => m.GetName().Text == stringSubInvoke.GetName().Text);

            return GetStringPointerPartMethod;
        }
 public virtual void OutABooleanConstExp(ABooleanConstExp node)
 {
     DefaultOut(node);
 }
 public override void CaseAVoidReturnStm(AVoidReturnStm node)
 {
     ABooleanConstExp trueBool = new ABooleanConstExp(new ATrueBool());
     AValueReturnStm replacer = new AValueReturnStm(node.GetToken(), trueBool);
     node.ReplaceBy(replacer);
     data.ExpTypes[trueBool] = new ANamedType(new TIdentifier("bool"), null);
 }
        public override void DefaultIn(Node node)
        {
            if (node is PExp)
            {
                PExp exp = (PExp) node;
                if (finalTrans.data.ExpTypes[exp] is ANamedType)
                {
                    ANamedType type = (ANamedType) finalTrans.data.ExpTypes[exp];
                    if (finalTrans.data.StructTypeLinks.ContainsKey(type))
                    {
                        AStructDecl strDecl = finalTrans.data.StructTypeLinks[type];
                        if (strDecl.GetLocals().Cast<PLocalDecl>().Select(decl => decl is AALocalDecl).Count() == 0)
                        {
                            if (node.Parent() is AAssignmentExp)
                                node = node.Parent().Parent();
                            MoveMethodDeclsOut mover = new MoveMethodDeclsOut("removedStructVar", finalTrans.data);
                            node.Apply(mover);
                            foreach (PStm pStm in mover.NewStatements)
                            {
                                pStm.Apply(this);
                            }
                            node.Parent().RemoveChild(node);

                            if (node.Parent() is ABinopExp)
                            {
                                ABinopExp parent = (ABinopExp) node.Parent();
                                ABooleanConstExp replacer;
                                if (parent.GetBinop() is ANeBinop || parent.GetBinop() is AGtBinop || parent.GetBinop() is ALtBinop)
                                    replacer = new ABooleanConstExp(new AFalseBool());
                                else
                                    replacer = new ABooleanConstExp(new ATrueBool());
                                finalTrans.data.ExpTypes[replacer] = new ANamedType(new TIdentifier("bool"), null);
                                parent.ReplaceBy(replacer);
                            }
                        }
                    }
                }
            }
        }
 public virtual void CaseABooleanConstExp(ABooleanConstExp node)
 {
     DefaultCase(node);
 }
        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);
            }
        }
        private void TransformBreaks(PStm stm, SwitchCaseData switchCase, AALocalDecl continueDecl, AALocalDecl fallthroughDecl, ref int currI)
        {
            if (stm is ABreakStm)
            {
                AABlock pBlock = (AABlock) stm.Parent();
                if (!switchCase.IsLast && (switchCase.RequiresContinue || switchCase.ContainsFallthrough))
                {
                    //Add continue = false;
                    ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(continueDecl.GetName().Text));
                    ABooleanConstExp rightSide = new ABooleanConstExp(new AFalseBool());
                    AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), lvalue, rightSide);
                    pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(stm), new AExpStm(new TSemicolon(";"), assignment));

                    data.LocalLinks[lvalue] = continueDecl;
                    data.LvalueTypes[lvalue] = data.ExpTypes[rightSide] = data.ExpTypes[assignment] = continueDecl.GetType();
                    currI++;
                }
                if (!switchCase.IsLast && switchCase.TargetForFallThrough)
                {
                    //Add fallthrough = false;
                    ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(fallthroughDecl.GetName().Text));
                    ABooleanConstExp rightSide = new ABooleanConstExp(new AFalseBool());
                    AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), lvalue, rightSide);
                    pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(stm), new AExpStm(new TSemicolon(";"), assignment));

                    data.LocalLinks[lvalue] = fallthroughDecl;
                    data.LvalueTypes[lvalue] = data.ExpTypes[rightSide] = data.ExpTypes[assignment] = fallthroughDecl.GetType();
                    currI++;
                }
                if (!switchCase.RequiresWhile)
                {//Remove break
                    stm.Parent().RemoveChild(stm);
                    currI--;
                }
            }
            if (stm is ABlockStm)
                TransformBreaks((AABlock)((ABlockStm)stm).GetBlock(), switchCase, continueDecl, fallthroughDecl);
            if (stm is AIfThenStm)
                TransformBreaks(((AIfThenStm)stm).GetBody(), switchCase, continueDecl, fallthroughDecl, ref currI);
            if (stm is AIfThenElseStm)
            {
                TransformBreaks(((AIfThenElseStm)stm).GetThenBody(), switchCase, continueDecl, fallthroughDecl, ref currI);
                TransformBreaks(((AIfThenElseStm)stm).GetElseBody(), switchCase, continueDecl, fallthroughDecl, ref currI);
            }
        }
            public static AMethodDecl CreateNewObjectMethod(Node node, SharedData data)
            {
                if (newObjectMethod != null)
                    return newObjectMethod;
                /*  Insert
                        string CreateNewObject()
                        {
                            //Get next item nr
                            int itemNr = DataTableGetInt(true, "Objects\\Count");
                            itemNr = itemNr + 1;
                            DataTableSetInt(true, "Objects\\Count", itemNr);

                            DataTableSetBool(true, "Objects\\" + IntToString(itemNr) + "\\Exists", true);
                            return "Objects\\" + IntToString(itemNr);
                        }
                     */
                AABlock methodBlock = new AABlock();
                AMethodDecl method = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null,
                                                     new ANamedType(new TIdentifier("string"), null),
                                                     new TIdentifier("CreateNewObject"), new ArrayList(),
                                                     methodBlock);

                ASimpleInvokeExp dataTableGetIntInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableGetInt"), new ArrayList());
                ABooleanConstExp trueConst1 = new ABooleanConstExp(new ATrueBool());
                dataTableGetIntInvoke.GetArgs().Add(trueConst1);
                AStringConstExp stringConst1 = new AStringConstExp(new TStringLiteral("\"Objects\\\\Count\""));
                dataTableGetIntInvoke.GetArgs().Add(stringConst1);
                AALocalDecl itemNrDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, new ANamedType(new TIdentifier("int"), null), new TIdentifier("itemNr"), dataTableGetIntInvoke);
                methodBlock.GetStatements().Add(new ALocalDeclStm(new TSemicolon(";"), itemNrDecl));

                ALocalLvalue itemNrLink1 = new ALocalLvalue(new TIdentifier("itemNr"));
                ALocalLvalue itemNrLink2 = new ALocalLvalue(new TIdentifier("itemNr"));
                ALvalueExp itemNrLink2Exp = new ALvalueExp(itemNrLink2);
                AIntConstExp intConst = new AIntConstExp(new TIntegerLiteral("1"));
                ABinopExp binop1 = new ABinopExp(itemNrLink2Exp, new APlusBinop(new TPlus("+")), intConst);
                AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), itemNrLink1, binop1);
                methodBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment));

                ASimpleInvokeExp dataTableSetIntInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableSetInt"), new ArrayList());
                ABooleanConstExp trueConst2 = new ABooleanConstExp(new ATrueBool());
                dataTableSetIntInvoke.GetArgs().Add(trueConst2);
                AStringConstExp stringConst2 = new AStringConstExp(new TStringLiteral("\"Objects\\\\Count\""));
                dataTableSetIntInvoke.GetArgs().Add(stringConst2);
                ALocalLvalue itemNrLink3 = new ALocalLvalue(new TIdentifier("itemNr"));
                ALvalueExp itemNrLink3Exp = new ALvalueExp(itemNrLink3);
                dataTableSetIntInvoke.GetArgs().Add(itemNrLink3Exp);
                methodBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), dataTableSetIntInvoke));

                ASimpleInvokeExp dataTableSetBoolInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableSetBool"), new ArrayList());
                ABooleanConstExp trueConst3 = new ABooleanConstExp(new ATrueBool());
                dataTableSetBoolInvoke.GetArgs().Add(trueConst3);
                AStringConstExp stringConst3 = new AStringConstExp(new TStringLiteral("\"Objects\\\\\""));
                ASimpleInvokeExp intToStringInvoke1 = new ASimpleInvokeExp(new TIdentifier("IntToString"), new ArrayList());
                ALocalLvalue itemNrLink4 = new ALocalLvalue(new TIdentifier("itemNr"));
                ALvalueExp itemNrLink4Exp = new ALvalueExp(itemNrLink4);
                intToStringInvoke1.GetArgs().Add(itemNrLink4Exp);
                ABinopExp binop2 = new ABinopExp(stringConst3, new APlusBinop(new TPlus("+")), intToStringInvoke1);
                AStringConstExp stringConst4 = new AStringConstExp(new TStringLiteral("\"\\\\Exists\""));
                ABinopExp binop3 = new ABinopExp(binop2, new APlusBinop(new TPlus("+")), stringConst4);
                dataTableSetBoolInvoke.GetArgs().Add(binop3);
                ABooleanConstExp trueConst4 = new ABooleanConstExp(new ATrueBool());
                dataTableSetBoolInvoke.GetArgs().Add(trueConst4);
                methodBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), dataTableSetBoolInvoke));

                AStringConstExp stringConst5 = new AStringConstExp(new TStringLiteral("\"Objects\\\\\""));
                ASimpleInvokeExp intToStringInvoke2 = new ASimpleInvokeExp(new TIdentifier("IntToString"), new ArrayList());
                ALocalLvalue itemNrLink5 = new ALocalLvalue(new TIdentifier("itemNr"));
                ALvalueExp itemNrLink5Exp = new ALvalueExp(itemNrLink5);
                intToStringInvoke2.GetArgs().Add(itemNrLink5Exp);
                ABinopExp binop4 = new ABinopExp(stringConst5, new APlusBinop(new TPlus("+")), intToStringInvoke2);
                methodBlock.GetStatements().Add(new AValueReturnStm(new TReturn("return"), binop4));

                AASourceFile sourceFile = Util.GetAncestor<AASourceFile>(node);
                sourceFile.GetDecl().Add(method);

                data.Locals[methodBlock] = new List<AALocalDecl>() { itemNrDecl };
                data.LocalLinks[itemNrLink1] =
                    data.LocalLinks[itemNrLink2] =
                    data.LocalLinks[itemNrLink3] =
                    data.LocalLinks[itemNrLink4] =
                    data.LocalLinks[itemNrLink5] = itemNrDecl;

                data.SimpleMethodLinks[dataTableSetIntInvoke] =
                    data.Libraries.Methods.First(m => m.GetName().Text == dataTableSetIntInvoke.GetName().Text);
                data.SimpleMethodLinks[dataTableGetIntInvoke] =
                    data.Libraries.Methods.First(m => m.GetName().Text == dataTableGetIntInvoke.GetName().Text);
                data.SimpleMethodLinks[dataTableSetBoolInvoke] =
                    data.Libraries.Methods.First(m => m.GetName().Text == dataTableSetBoolInvoke.GetName().Text);
                data.SimpleMethodLinks[intToStringInvoke1] =
                    data.SimpleMethodLinks[intToStringInvoke2] =
                    data.Libraries.Methods.First(m => m.GetName().Text == intToStringInvoke1.GetName().Text);

                data.ExpTypes[stringConst1] =
                    data.ExpTypes[stringConst2] =
                    data.ExpTypes[stringConst3] =
                    data.ExpTypes[stringConst4] =
                    data.ExpTypes[stringConst5] =
                    data.ExpTypes[binop2] =
                    data.ExpTypes[binop3] =
                    data.ExpTypes[binop4] =
                    data.ExpTypes[intToStringInvoke1] =
                    data.ExpTypes[intToStringInvoke2] = new ANamedType(new TIdentifier("string"), null);

                data.ExpTypes[trueConst1] =
                    data.ExpTypes[trueConst2] =
                    data.ExpTypes[trueConst3] =
                    data.ExpTypes[trueConst4] = new ANamedType(new TIdentifier("bool"), null);

                data.LvalueTypes[itemNrLink1] =
                    data.LvalueTypes[itemNrLink2] =
                    data.LvalueTypes[itemNrLink3] =
                    data.LvalueTypes[itemNrLink4] =
                    data.LvalueTypes[itemNrLink5] =
                    data.ExpTypes[itemNrLink2Exp] =
                    data.ExpTypes[itemNrLink3Exp] =
                    data.ExpTypes[itemNrLink4Exp] =
                    data.ExpTypes[itemNrLink5Exp] =
                    data.ExpTypes[binop1] =
                    data.ExpTypes[assignment] =
                    data.ExpTypes[dataTableGetIntInvoke] = new ANamedType(new TIdentifier("int"), null);

                data.ExpTypes[dataTableSetBoolInvoke] =
                    data.ExpTypes[dataTableSetIntInvoke] = new AVoidType(new TVoid("void"));

                newObjectMethod = method;
                return newObjectMethod;
            }
            public static AMethodDecl CreateResizeArrayMethod(Node node, PType baseType, SharedData data)
            {
                //Search already created stuff, and return that if present.
                //All non struct baseTypes get the simple version

                ANamedType aBaseType = null;
                AStructDecl structDecl = null;
                if (Util.IsBulkCopy(baseType))
                {
                    aBaseType = (ANamedType)baseType;
                    structDecl = data.StructTypeLinks[aBaseType];

                    if (resizeArrayMethods.ContainsKey(structDecl))
                        return resizeArrayMethods[structDecl];
                }
                else
                    if (simpleResizeArrayMethod != null)
                        return simpleResizeArrayMethod;

                //Create
                /*
                    void Resize(int newSize, string id)
                    {
                        int oldSize = DataTableGetInt(true, id + "\\Length");
                        while (oldSize > newSize)
                        {
                            //Delete everything up to now
                            oldSize = oldSize - 1;
                            DeleteStruct<name>(id + "[" + IntToString(oldSize) + "]");//If struct type
                            DataTableValueRemove(true, id + "[" + IntToString(oldSize) + "]");
                        }
                        DataTableSetInt(true, id + "\\Length", newSize);
                    }
                 */
                AALocalDecl newSizeFormal = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                            new ANamedType(new TIdentifier("int"), null),
                                                            new TIdentifier("newSize"), null);
                AALocalDecl idFormal = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                            new ANamedType(new TIdentifier("string"), null),
                                                            new TIdentifier("id"), null);

                AABlock methodBlock = new AABlock(new ArrayList(), new TRBrace("}"));

                //int oldSize = DataTableGetInt(true, id + "\\Length");
                ABooleanConstExp boolConstExp1 = new ABooleanConstExp(new ATrueBool());
                AStringConstExp stringConstExp1 = new AStringConstExp(new TStringLiteral("\"\\\\Length\""));
                ALocalLvalue idRef1 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idRef1Exp = new ALvalueExp(idRef1);
                ABinopExp binop1 = new ABinopExp(idRef1Exp, new APlusBinop(new TPlus("+")), stringConstExp1);
                ASimpleInvokeExp getSizeInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableGetInt"), new ArrayList(){boolConstExp1, binop1});
                AALocalDecl oldSizeDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                            new ANamedType(new TIdentifier("int"), null),
                                                            new TIdentifier("oldSize"), getSizeInvoke);
                methodBlock.GetStatements().Add(new ALocalDeclStm(new TSemicolon(";"), oldSizeDecl));

                //while (oldSize > newSize)
                ALocalLvalue oldSizeRef1 = new ALocalLvalue(new TIdentifier("oldSize"));
                ALvalueExp oldSizeRef1Exp = new ALvalueExp(oldSizeRef1);
                ALocalLvalue newSizeRef1 = new ALocalLvalue(new TIdentifier("newSize"));
                ALvalueExp newSizeRef1Exp = new ALvalueExp(newSizeRef1);
                ABinopExp binop2 = new ABinopExp(oldSizeRef1Exp, new AGtBinop(new TGt(">")), newSizeRef1Exp);
                AABlock whileBlock = new AABlock(new ArrayList(), new TRBrace("}"));
                methodBlock.GetStatements().Add(new AWhileStm(new TLParen("("), binop2,
                                                               new ABlockStm(new TLBrace("{"), whileBlock)));

                //oldSize = oldSize - 1;
                ALocalLvalue oldSizeRef2 = new ALocalLvalue(new TIdentifier("oldSize"));
                ALocalLvalue oldSizeRef3 = new ALocalLvalue(new TIdentifier("oldSize"));
                ALvalueExp oldSizeRef3Exp = new ALvalueExp(oldSizeRef3);
                AIntConstExp intConst1 = new AIntConstExp(new TIntegerLiteral("1"));
                ABinopExp binop3 = new ABinopExp(oldSizeRef3Exp, new AMinusBinop(new TMinus("-")), intConst1);
                AAssignmentExp assignment1 = new AAssignmentExp(new TAssign("="), oldSizeRef2, binop3);
                whileBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment1));

                //DeleteStruct<name>(id + "[" + IntToString(oldSize) + "]");//If struct type
                ALocalLvalue idRef2 = null;
                ALvalueExp idRef2Exp = null;
                AStringConstExp stringConstExp2 = null;
                AStringConstExp stringConstExp3 = null;
                ALocalLvalue oldSizeRef4 = null;
                ALvalueExp oldSizeRef4Exp = null;
                ASimpleInvokeExp intToString1 = null;
                ABinopExp binop4 = null;
                ABinopExp binop5 = null;
                ABinopExp binop6 = null;
                ASimpleInvokeExp deleteStructInvoke = null;
                if (aBaseType != null)
                {
                    idRef2 = new ALocalLvalue(new TIdentifier("id"));
                    idRef2Exp = new ALvalueExp(idRef2);
                    stringConstExp2 = new AStringConstExp(new TStringLiteral("\"[\""));
                    stringConstExp3 = new AStringConstExp(new TStringLiteral("\"]\""));
                    oldSizeRef4 = new ALocalLvalue(new TIdentifier("oldSize"));
                    oldSizeRef4Exp = new ALvalueExp(oldSizeRef4);
                    intToString1 = new ASimpleInvokeExp(new TIdentifier("IntToString"), new ArrayList() { oldSizeRef4Exp });
                    binop4 = new ABinopExp(intToString1, new APlusBinop(new TPlus("+")), stringConstExp3);
                    binop5 = new ABinopExp(stringConstExp2, new APlusBinop(new TPlus("+")), binop4);
                    binop6 = new ABinopExp(idRef2Exp, new APlusBinop(new TPlus("+")), binop5);
                    deleteStructInvoke =
                        new ASimpleInvokeExp(new TIdentifier("DeleteStruct" + aBaseType.AsIdentifierString()),
                                             new ArrayList() { binop6 });
                    whileBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), deleteStructInvoke));
                }

                //DataTableValueRemove(true, id + "[" + IntToString(oldSize) + "]");
                ABooleanConstExp boolConstExp2 = new ABooleanConstExp(new ATrueBool());
                ALocalLvalue idRef3 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idRef3Exp = new ALvalueExp(idRef3);
                AStringConstExp stringConstExp4 = new AStringConstExp(new TStringLiteral("\"[\""));
                AStringConstExp stringConstExp5 = new AStringConstExp(new TStringLiteral("\"]\""));
                ALocalLvalue oldSizeRef5 = new ALocalLvalue(new TIdentifier("oldSize"));
                ALvalueExp oldSizeRef5Exp = new ALvalueExp(oldSizeRef5);
                ASimpleInvokeExp intToString2 = new ASimpleInvokeExp(new TIdentifier("IntToString"), new ArrayList(){oldSizeRef5Exp});
                ABinopExp binop7 = new ABinopExp(intToString2, new APlusBinop(new TPlus("+")), stringConstExp5);
                ABinopExp binop8 = new ABinopExp(stringConstExp4, new APlusBinop(new TPlus("+")), binop7);
                ABinopExp binop9 = new ABinopExp(idRef3Exp, new APlusBinop(new TPlus("+")), binop8);
                ASimpleInvokeExp dataTableRemove = new ASimpleInvokeExp(new TIdentifier("DataTableValueRemove"),
                                                                        new ArrayList() {boolConstExp2, binop9});
                whileBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), dataTableRemove));

                //DataTableSetInt(true, id + "\\Length", newSize);
                ABooleanConstExp boolConstExp3 = new ABooleanConstExp(new ATrueBool());
                AStringConstExp stringConstExp6 = new AStringConstExp(new TStringLiteral("\"\\\\Length\""));
                ALocalLvalue idRef4 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idRef4Exp = new ALvalueExp(idRef4);
                ABinopExp binop10 = new ABinopExp(idRef4Exp, new APlusBinop(new TPlus("+")), stringConstExp6);
                ALocalLvalue newSizeRef2 = new ALocalLvalue(new TIdentifier("newSize"));
                ALvalueExp newSizeRef2Exp = new ALvalueExp(newSizeRef2);
                ASimpleInvokeExp setSizeInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableSetInt"),
                                                                      new ArrayList()
                                                                          {boolConstExp3, binop10, newSizeRef2Exp});
                methodBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), setSizeInvoke));

                AMethodDecl method = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null,
                                                         new AVoidType(new TVoid("void")),
                                                         new TIdentifier("ResizeArray"),
                                                         new ArrayList() { newSizeFormal, idFormal }, methodBlock);
                AASourceFile sourceFile = Util.GetAncestor<AASourceFile>(node);
                sourceFile.GetDecl().Add(method);
                data.Methods.Add(new SharedData.DeclItem<AMethodDecl>(sourceFile, method));

                data.LvalueTypes[oldSizeRef1] =
                    data.LvalueTypes[oldSizeRef2] =
                    data.LvalueTypes[oldSizeRef3] =
                    //data.LvalueTypes[oldSizeRef4] =
                    data.LvalueTypes[oldSizeRef5] =
                    data.ExpTypes[oldSizeRef1Exp] =
                    data.ExpTypes[oldSizeRef3Exp] =
                    //data.ExpTypes[oldSizeRef4Exp] =
                    data.ExpTypes[oldSizeRef5Exp] =
                    data.LvalueTypes[newSizeRef1] =
                    data.LvalueTypes[newSizeRef2] =
                    data.ExpTypes[newSizeRef1Exp] =
                    data.ExpTypes[newSizeRef2Exp] =
                    data.ExpTypes[binop3] =
                    data.ExpTypes[assignment1] =
                    data.ExpTypes[getSizeInvoke] = new ANamedType(new TIdentifier("int"), null);
                data.LvalueTypes[idRef1] =
                    //data.LvalueTypes[idRef2] =
                    data.LvalueTypes[idRef3] =
                    data.LvalueTypes[idRef4] =
                    data.ExpTypes[idRef1Exp] =
                    //data.ExpTypes[idRef2Exp] =
                    data.ExpTypes[idRef3Exp] =
                    data.ExpTypes[idRef4Exp] =
                    data.ExpTypes[stringConstExp1] =
                    //data.ExpTypes[stringConstExp2] =
                    //data.ExpTypes[stringConstExp3] =
                    data.ExpTypes[stringConstExp4] =
                    data.ExpTypes[stringConstExp5] =
                    data.ExpTypes[stringConstExp6] =
                    data.ExpTypes[binop1] =
                    //data.ExpTypes[binop4] =
                    //data.ExpTypes[binop5] =
                    //data.ExpTypes[binop6] =
                    data.ExpTypes[binop7] =
                    data.ExpTypes[binop8] =
                    data.ExpTypes[binop9] =
                    data.ExpTypes[binop10] =
                    //data.ExpTypes[intToString1] =
                    data.ExpTypes[intToString2] = new ANamedType(new TIdentifier("string"), null);
                data.ExpTypes[dataTableRemove] =
                    //data.ExpTypes[deleteStructInvoke] =
                    data.ExpTypes[setSizeInvoke] = new AVoidType(new TVoid("void"));
                data.ExpTypes[boolConstExp1] =
                    data.ExpTypes[boolConstExp2] =
                    data.ExpTypes[boolConstExp3] =
                    data.ExpTypes[binop2] = new ANamedType(new TIdentifier("bool"), null);

                data.LocalLinks[oldSizeRef1] =
                    data.LocalLinks[oldSizeRef2] =
                    data.LocalLinks[oldSizeRef3] =
                    data.LocalLinks[oldSizeRef5] = oldSizeDecl;
                data.LocalLinks[newSizeRef1] =
                    data.LocalLinks[newSizeRef2] = newSizeFormal;
                data.LocalLinks[idRef1] =
                    data.LocalLinks[idRef3] =
                    data.LocalLinks[idRef4] = idFormal;

                data.SimpleMethodLinks[getSizeInvoke] =
                    data.Libraries.Methods.First(m => m.GetName().Text == getSizeInvoke.GetName().Text);
                data.SimpleMethodLinks[setSizeInvoke] =
                    data.Libraries.Methods.First(m => m.GetName().Text == setSizeInvoke.GetName().Text);
                data.SimpleMethodLinks[dataTableRemove] =
                    data.Libraries.Methods.First(m => m.GetName().Text == dataTableRemove.GetName().Text);
                data.SimpleMethodLinks[intToString2] =
                    data.Libraries.Methods.First(m => m.GetName().Text == intToString2.GetName().Text);

                if (aBaseType == null)
                    return simpleResizeArrayMethod = method;

                data.LvalueTypes[oldSizeRef4] =
                    data.ExpTypes[oldSizeRef4Exp] = new ANamedType(new TIdentifier("int"), null);
                data.LvalueTypes[idRef2] =
                    data.ExpTypes[idRef2Exp] =
                    data.ExpTypes[stringConstExp2] =
                    data.ExpTypes[stringConstExp3] =
                    data.ExpTypes[binop4] =
                    data.ExpTypes[binop5] =
                    data.ExpTypes[binop6] =
                    data.ExpTypes[intToString1] = new ANamedType(new TIdentifier("string"), null);
                data.ExpTypes[deleteStructInvoke] = new AVoidType(new TVoid("void"));

                data.LocalLinks[oldSizeRef4] = oldSizeDecl;
                data.LocalLinks[idRef2] = idFormal;

                data.SimpleMethodLinks[deleteStructInvoke] = CreateDeleteStructMethod(node, structDecl, data);
                data.SimpleMethodLinks[intToString1] = data.SimpleMethodLinks[intToString2];
                method.SetName(new TIdentifier("Resize" + aBaseType.AsIdentifierString() + "Array"));
                resizeArrayMethods.Add(structDecl, method);
                return method;
            }
Esempio n. 10
0
            public static AMethodDecl CreateDeleteObjectMethod(Node node, SharedData data)
            {
                if (deleteObjectMethod != null)
                    return deleteObjectMethod;
                /*Insert
                 *  void DeleteObject(string id)
                    {
                        DataTableValueRemove(true, id + "\\Exists");
                        DataTableValueRemove(true, id);
                    }
                 */

                AALocalDecl idDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, new ANamedType(new TIdentifier("string"), null), new TIdentifier("id"), null);
                AABlock block = new AABlock();
                AMethodDecl method = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null, new AVoidType(new TVoid("void")),
                                                     new TIdentifier("DeleteObject"), new ArrayList() {idDecl}, block);

                ABooleanConstExp trueConst1 = new ABooleanConstExp(new ATrueBool());
                ALocalLvalue idLink1 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idLink1Exp = new ALvalueExp(idLink1);
                AStringConstExp stringConst = new AStringConstExp(new TStringLiteral("\"\\\\Exists\""));
                ABinopExp binop = new ABinopExp(idLink1Exp, new APlusBinop(new TPlus("+")), stringConst);
                ASimpleInvokeExp dataTableValueRemove1 = new ASimpleInvokeExp(new TIdentifier("DataTableValueRemove"), new ArrayList() { trueConst1, binop });
                block.GetStatements().Add(new AExpStm(new TSemicolon(";"), dataTableValueRemove1));

                ABooleanConstExp trueConst2 = new ABooleanConstExp(new ATrueBool());
                ALocalLvalue idLink2 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idLink2Exp = new ALvalueExp(idLink2);
                ASimpleInvokeExp dataTableValueRemove2 = new ASimpleInvokeExp(new TIdentifier("DataTableValueRemove"), new ArrayList() { trueConst2, idLink2Exp });
                block.GetStatements().Add(new AExpStm(new TSemicolon(";"), dataTableValueRemove2));

                AASourceFile sourceFile = Util.GetAncestor<AASourceFile>(node);
                sourceFile.GetDecl().Add(method);
                data.Methods.Add(new SharedData.DeclItem<AMethodDecl>(sourceFile, method));

                data.Locals[block] = new List<AALocalDecl> { idDecl };
                data.LocalLinks[idLink1] = idDecl;
                data.LocalLinks[idLink2] = idDecl;

                data.SimpleMethodLinks[dataTableValueRemove1] =
                data.SimpleMethodLinks[dataTableValueRemove2] =
                    data.Libraries.Methods.First(m => m.GetName().Text == dataTableValueRemove1.GetName().Text);

                data.ExpTypes[stringConst] =
                    data.LvalueTypes[idLink1] =
                    data.LvalueTypes[idLink2] =
                    data.ExpTypes[idLink1Exp] =
                    data.ExpTypes[idLink2Exp] =
                    data.ExpTypes[binop] = new ANamedType(new TIdentifier("string"), null);

                data.ExpTypes[trueConst1] =
                    data.ExpTypes[trueConst2] = new ANamedType(new TIdentifier("bool"), null);

                data.ExpTypes[dataTableValueRemove1] =
                    data.ExpTypes[dataTableValueRemove2] = new AVoidType(new TVoid("void"));

                deleteObjectMethod = method;
                return deleteObjectMethod;
            }
Esempio n. 11
0
            public static AMethodDecl CreateNewArrayMethod(Node node, SharedData data)
            {
                if (newArrayMethod != null)
                    return newArrayMethod;
                if (newObjectMethod == null)
                    CreateNewObjectMethod(node, data);
                /* Insert
                     *  string CreateNewArray(int length)
                        {
                            string id = CreateNewObject();

                            DataTableSetInt(true, id + "\\Length", length);
                            return id;
                        }
                     */
                AALocalDecl lengthDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, new ANamedType(new TIdentifier("int"), null), new TIdentifier("length"), null);
                AABlock methodBlock = new AABlock();
                AMethodDecl method = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null,
                                                     new ANamedType(new TIdentifier("string"), null),
                                                     new TIdentifier("CreateNewArray"), new ArrayList() { lengthDecl },
                                                     methodBlock);

                ASimpleInvokeExp createNewObjectInvoke = new ASimpleInvokeExp(new TIdentifier("CreateNewObject"), new ArrayList());
                AALocalDecl idDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, new ANamedType(new TIdentifier("string"), null), new TIdentifier("id"), createNewObjectInvoke);
                methodBlock.GetStatements().Add(new ALocalDeclStm(new TSemicolon(";"), idDecl));

                ASimpleInvokeExp dataTableSetIntInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableSetInt"), new ArrayList());
                ABooleanConstExp trueConst = new ABooleanConstExp(new ATrueBool());
                dataTableSetIntInvoke.GetArgs().Add(trueConst);
                ALocalLvalue idLink1 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idLink1Exp = new ALvalueExp(idLink1);
                AStringConstExp lengthText = new AStringConstExp(new TStringLiteral("\"\\\\Length\""));
                ABinopExp binopExp = new ABinopExp(idLink1Exp, new APlusBinop(new TPlus("+")), lengthText);
                dataTableSetIntInvoke.GetArgs().Add(binopExp);
                ALocalLvalue lenghtLink = new ALocalLvalue(new TIdentifier("length"));
                ALvalueExp lengthLinkExp = new ALvalueExp(lenghtLink);
                dataTableSetIntInvoke.GetArgs().Add(lengthLinkExp);
                methodBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), dataTableSetIntInvoke));

                ALocalLvalue idLink2 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idLink2Exp = new ALvalueExp(idLink2);
                methodBlock.GetStatements().Add(new AValueReturnStm(new TReturn("return"), idLink2Exp));

                AASourceFile sourceFile = Util.GetAncestor<AASourceFile>(node);
                sourceFile.GetDecl().Add(method);
                data.Methods.Add(new SharedData.DeclItem<AMethodDecl>(sourceFile, method));

                data.Locals[methodBlock] = new List<AALocalDecl> { lengthDecl, idDecl };
                data.LocalLinks[lenghtLink] = lengthDecl;
                data.LocalLinks[idLink1] = idDecl;
                data.LocalLinks[idLink2] = idDecl;

                data.SimpleMethodLinks[dataTableSetIntInvoke] =
                    data.Libraries.Methods.First(m => m.GetName().Text == dataTableSetIntInvoke.GetName().Text);

                data.ExpTypes[createNewObjectInvoke] =
                    data.ExpTypes[lengthText] =
                    data.LvalueTypes[idLink1] =
                    data.LvalueTypes[idLink2] =
                    data.ExpTypes[idLink1Exp] =
                    data.ExpTypes[idLink2Exp] =
                    data.ExpTypes[binopExp] = new ANamedType(new TIdentifier("string"), null);

                data.ExpTypes[trueConst] = new ANamedType(new TIdentifier("bool"), null);

                data.LvalueTypes[lenghtLink] = data.ExpTypes[lengthLinkExp] = new ANamedType(new TIdentifier("int"), null);

                data.ExpTypes[dataTableSetIntInvoke] = new AVoidType(new TVoid("void"));

                data.SimpleMethodLinks[createNewObjectInvoke] = newObjectMethod;

                newArrayMethod = method;
                return newArrayMethod;
            }
Esempio n. 12
0
            public static AMethodDecl CreateDeleteArrayMethod(Node node, SharedData data)
            {
                if (deleteArrayMethod != null)
                    return deleteArrayMethod;
                /*  void DeleteArray(string id)
                    {
                        int length = DataTableGetInt(true, id + "\\Length");
                        while (length > 0)
                        {
                            length = length - 1;
                            DataTableValueRemove(true, id + "[" + IntToString(length) + "]");
                        }
                        DataTableValueRemove(true, id + "\\Length");
                        DataTableValueRemove(true, id + "\\Exists");
                    }
                 */

                AALocalDecl idDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, new ANamedType(new TIdentifier("string"), null), new TIdentifier("id"), null);
                AABlock block = new AABlock();
                AMethodDecl method = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null, new AVoidType(new TVoid("void")),
                                                     new TIdentifier("DeleteArray"), new ArrayList() { idDecl }, block);

                ALocalLvalue idLink1 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idLink1Exp = new ALvalueExp(idLink1);
                ABinopExp binopExp1 = new ABinopExp(idLink1Exp, new APlusBinop(new TPlus("+")), new AStringConstExp(new TStringLiteral("\"\\\\Length\"")));
                ABooleanConstExp trueConst1 = new ABooleanConstExp(new ATrueBool());
                ASimpleInvokeExp dataTableGetIntInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableGetInt"), new ArrayList{trueConst1, binopExp1});
                AALocalDecl lengthDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, new ANamedType(new TIdentifier("int"), null), new TIdentifier("length"), dataTableGetIntInvoke);
                block.GetStatements().Add(new ALocalDeclStm(new TSemicolon(";"), lengthDecl));

                ALocalLvalue lengthLink1 = new ALocalLvalue(new TIdentifier("length"));
                ALvalueExp lengthLink1Exp = new ALvalueExp(lengthLink1);
                ABinopExp binopExp2 = new ABinopExp(lengthLink1Exp, new AGtBinop(new TGt(">")), new AIntConstExp(new TIntegerLiteral("0")));
                AABlock whileBlock = new AABlock();
                block.GetStatements().Add(new AWhileStm(new TLParen("("), binopExp2,
                                                        new ABlockStm(new TLBrace("{"), whileBlock)));

                ALocalLvalue lengthLink2 = new ALocalLvalue(new TIdentifier("length"));
                ALvalueExp lengthLink2Exp = new ALvalueExp(lengthLink2);
                ALocalLvalue lengthLink3 = new ALocalLvalue(new TIdentifier("length"));
                ABinopExp binopExp3 = new ABinopExp(lengthLink2Exp, new AMinusBinop(new TMinus("-")), new AIntConstExp(new TIntegerLiteral("1")));
                AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), lengthLink3, binopExp3);
                whileBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment));

                ABooleanConstExp trueConst2 = new ABooleanConstExp(new ATrueBool());
                ALocalLvalue idLink2 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idLink2Exp = new ALvalueExp(idLink2);
                ALocalLvalue lengthLink4 = new ALocalLvalue(new TIdentifier("length"));
                ALvalueExp lengthLink4Exp = new ALvalueExp(lengthLink4);
                ASimpleInvokeExp intToStringInvoke = new ASimpleInvokeExp(new TIdentifier("IntToString"), new ArrayList(){lengthLink4Exp});
                ABinopExp binopExp4 = new ABinopExp(idLink2Exp, new APlusBinop(new TPlus("+")), new AStringConstExp(new TStringLiteral("\"[\"")));
                ABinopExp binopExp5 = new ABinopExp(binopExp4, new APlusBinop(new TPlus("+")), intToStringInvoke);
                ABinopExp binopExp6 = new ABinopExp(binopExp5, new APlusBinop(new TPlus("+")), new AStringConstExp(new TStringLiteral("\"]\"")));
                ASimpleInvokeExp dataTableRemoveInvoke1 = new ASimpleInvokeExp(new TIdentifier("DataTableValueRemove"), new ArrayList(){trueConst2, binopExp6});
                whileBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), dataTableRemoveInvoke1));

                ABooleanConstExp trueConst3 = new ABooleanConstExp(new ATrueBool());
                ALocalLvalue idLink3 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idLink3Exp = new ALvalueExp(idLink3);
                ABinopExp binopExp7 = new ABinopExp(idLink3Exp, new APlusBinop(new TPlus("+")), new AStringConstExp(new TStringLiteral("\"\\\\Length\"")));
                ASimpleInvokeExp dataTableRemoveInvoke2 = new ASimpleInvokeExp(new TIdentifier("DataTableValueRemove"), new ArrayList() { trueConst3, binopExp7 });
                block.GetStatements().Add(new AExpStm(new TSemicolon(";"), dataTableRemoveInvoke2));

                ABooleanConstExp trueConst4 = new ABooleanConstExp(new ATrueBool());
                ALocalLvalue idLink4 = new ALocalLvalue(new TIdentifier("id"));
                ALvalueExp idLink4Exp = new ALvalueExp(idLink4);
                ABinopExp binopExp8 = new ABinopExp(idLink4Exp, new APlusBinop(new TPlus("+")), new AStringConstExp(new TStringLiteral("\"\\\\Exists\"")));
                ASimpleInvokeExp dataTableRemoveInvoke3 = new ASimpleInvokeExp(new TIdentifier("DataTableValueRemove"), new ArrayList() { trueConst4, binopExp8 });
                block.GetStatements().Add(new AExpStm(new TSemicolon(";"), dataTableRemoveInvoke3));

                AASourceFile sourceFile = Util.GetAncestor<AASourceFile>(node);
                sourceFile.GetDecl().Add(method);
                data.Methods.Add(new SharedData.DeclItem<AMethodDecl>(sourceFile, method));

                data.Locals[block] = new List<AALocalDecl> { idDecl, lengthDecl };
                data.LocalLinks[idLink1] =
                    data.LocalLinks[idLink2] =
                    data.LocalLinks[idLink3] =
                    data.LocalLinks[idLink4] = idDecl;
                data.LocalLinks[lengthLink1] =
                    data.LocalLinks[lengthLink2] =
                    data.LocalLinks[lengthLink3] =
                    data.LocalLinks[lengthLink4] = lengthDecl;

                data.SimpleMethodLinks[dataTableRemoveInvoke1] =
                data.SimpleMethodLinks[dataTableRemoveInvoke2] =
                data.SimpleMethodLinks[dataTableRemoveInvoke3] =
                    data.Libraries.Methods.First(m => m.GetName().Text == dataTableRemoveInvoke1.GetName().Text);
                data.SimpleMethodLinks[dataTableGetIntInvoke] =
                    data.Libraries.Methods.First(m => m.GetName().Text == dataTableGetIntInvoke.GetName().Text);
                data.SimpleMethodLinks[intToStringInvoke] =
                    data.Libraries.Methods.First(m => m.GetName().Text == intToStringInvoke.GetName().Text);

                data.LvalueTypes[idLink1] =
                    data.LvalueTypes[idLink2] =
                    data.LvalueTypes[idLink3] =
                    data.LvalueTypes[idLink4] =
                    data.ExpTypes[idLink1Exp] =
                    data.ExpTypes[idLink2Exp] =
                    data.ExpTypes[idLink3Exp] =
                    data.ExpTypes[idLink4Exp] =
                    data.ExpTypes[binopExp1] =
                    data.ExpTypes[binopExp4] =
                    data.ExpTypes[binopExp5] =
                    data.ExpTypes[binopExp6] =
                    data.ExpTypes[binopExp7] =
                    data.ExpTypes[binopExp8] =
                    data.ExpTypes[binopExp1.GetRight()] =
                    data.ExpTypes[binopExp4.GetRight()] =
                    data.ExpTypes[binopExp6.GetRight()] =
                    data.ExpTypes[binopExp7.GetRight()] =
                    data.ExpTypes[binopExp8.GetRight()] =
                    data.ExpTypes[intToStringInvoke] = new ANamedType(new TIdentifier("string"), null);

                data.ExpTypes[trueConst1] =
                    data.ExpTypes[trueConst2] =
                    data.ExpTypes[trueConst3] =
                    data.ExpTypes[trueConst4] =
                    data.ExpTypes[binopExp2] = new ANamedType(new TIdentifier("bool"), null);

                data.LvalueTypes[lengthLink1] =
                    data.LvalueTypes[lengthLink2] =
                    data.LvalueTypes[lengthLink3] =
                    data.LvalueTypes[lengthLink4] =
                    data.ExpTypes[lengthLink1Exp] =
                    data.ExpTypes[lengthLink2Exp] =
                    data.ExpTypes[lengthLink4Exp] =
                    data.ExpTypes[binopExp3] =
                    data.ExpTypes[binopExp2.GetRight()] =
                    data.ExpTypes[binopExp3.GetRight()] =
                    data.ExpTypes[dataTableGetIntInvoke] =
                    data.ExpTypes[assignment] = new ANamedType(new TIdentifier("int"), null);

                data.ExpTypes[dataTableRemoveInvoke1] =
                    data.ExpTypes[dataTableRemoveInvoke2] =
                    data.ExpTypes[dataTableRemoveInvoke3] = new AVoidType(new TVoid("void"));

                deleteArrayMethod = method;
                return deleteArrayMethod;
            }
            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 static List<AABlock> Inline(ASimpleInvokeExp node, FinalTransformations finalTrans)
        {
            /*if (Util.GetAncestor<AMethodDecl>(node) != null && Util.GetAncestor<AMethodDecl>(node).GetName().Text == "UIChatFrame_LeaveChannel")
                node = node;*/

            SharedData data = finalTrans.data;
            //If this node is inside the condition of a while, replace it with a new local var,
            //make a clone before the while, one before each continue in the while, and one at the end of the while
            //(unless the end is a return or break)
            AABlock pBlock;
            if (Util.HasAncestor<AWhileStm>(node))
            {
                AWhileStm whileStm = Util.GetAncestor<AWhileStm>(node);
                if (Util.IsAncestor(node, whileStm.GetCondition()))
                {
                    List<ASimpleInvokeExp> toInline = new List<ASimpleInvokeExp>();
                    //Above while
                    AALocalDecl replaceVarDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                                 Util.MakeClone(data.ExpTypes[node], data),
                                                                 new TIdentifier("whileVar"), null);
                    ALocalLvalue replaceVarRef = new ALocalLvalue(new TIdentifier("whileVar"));
                    ALvalueExp replaceVarRefExp = new ALvalueExp(replaceVarRef);
                    data.LocalLinks[replaceVarRef] = replaceVarDecl;
                    data.ExpTypes[replaceVarRefExp] = data.LvalueTypes[replaceVarRef] = replaceVarDecl.GetType();
                    node.ReplaceBy(replaceVarRefExp);
                    replaceVarDecl.SetInit(node);
                    pBlock = (AABlock) whileStm.Parent();
                    pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(whileStm), new ALocalDeclStm(new TSemicolon(";"), replaceVarDecl));
                    toInline.Add(node);

                    //In the end of the while
                    PStm lastStm = whileStm.GetBody();
                    while (lastStm is ABlockStm)
                    {
                        AABlock block = (AABlock) ((ABlockStm) lastStm).GetBlock();
                        if (block.GetStatements().Count == 0)
                        {
                            lastStm = null;
                            break;
                        }
                        lastStm = (PStm) block.GetStatements()[block.GetStatements().Count - 1];
                    }
                    if (lastStm == null || !(lastStm is AValueReturnStm || lastStm is AVoidReturnStm || lastStm is ABreakStm))
                    {
                        lastStm = whileStm.GetBody();
                        AABlock block;
                        if (lastStm is ABlockStm)
                        {
                            block = (AABlock)((ABlockStm)lastStm).GetBlock();
                        }
                        else
                        {
                            block = new AABlock(new ArrayList(), new TRBrace("}"));
                            block.GetStatements().Add(lastStm);
                            whileStm.SetBody(new ABlockStm(new TLBrace("{"), block));
                        }

                        replaceVarRef = new ALocalLvalue(new TIdentifier("whileVar"));
                        ASimpleInvokeExp clone = (ASimpleInvokeExp)Util.MakeClone(node, data);
                        toInline.Add(clone);
                        AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), replaceVarRef, clone);
                        data.LocalLinks[replaceVarRef] = replaceVarDecl;
                        data.ExpTypes[assignment] = data.LvalueTypes[replaceVarRef] = replaceVarDecl.GetType();
                        block.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment));
                    }

                    //After each continue
                    CloneBeforeContinue cloner = new CloneBeforeContinue(node, replaceVarDecl, data);
                    whileStm.GetBody().Apply(cloner);
                    toInline.AddRange(cloner.replacementExpressions);
                    List<AABlock> visitBlocks = new List<AABlock>();
                    foreach (ASimpleInvokeExp invoke in toInline)
                    {
                        visitBlocks.AddRange(Inline(invoke, finalTrans));
                    }
                    return visitBlocks;
                }
            }

            AMethodDecl decl = finalTrans.data.SimpleMethodLinks[node];
            FindAssignedToFormals assignedToFormalsFinder = new FindAssignedToFormals(finalTrans.data);
            decl.Apply(assignedToFormalsFinder);
            List<AALocalDecl> assignedToFormals = assignedToFormalsFinder.AssignedFormals;

            /*
                 * inline int foo(int a)
                 * {
                 *      int b = 2;
                 *      int c;
                 *      ...
                 *      while(...)
                 *      {
                 *          ...
                 *          break;
                 *          ...
                 *          return c;
                 *      }
                 *      ...
                 *      return 2;
                 * }
                 *
                 * bar(foo(<arg for a>));
                 * ->
                 *
                 * {
                 *      bool inlineMethodReturned = false;
                 *      int inlineReturner;
                 *      int a = <arg for a>;
                 *      while (!inlineMethodReturned)
                 *      {
                 *          int b = 2;
                 *          int c;
                 *          ...
                 *          while(...)
                 *          {
                 *              ...
                 *              break
                 *              ...
                 *              inlineReturner = c;
                 *              inlineMethodReturned = true;
                 *              break;
                 *          }
                 *          if (inlineMethodReturned)
                 *          {
                 *              break;
                 *          }
                 *          ...
                 *          inlineReturner = 2;
                 *          inlineMethodReturned = true;
                 *          break;
                 *          break;
                 *      }
                 *      bar(inlineReturner);
                 * }
                 *
                 *
                 */

            AABlock outerBlock = new AABlock();
            PExp exp = new ABooleanConstExp(new AFalseBool());
            finalTrans.data.ExpTypes[exp] = new ANamedType(new TIdentifier("bool"), null);
            AALocalDecl hasMethodReturnedVar = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, new ANamedType(new TIdentifier("bool"), null),
                                                               new TIdentifier("hasInlineReturned"), exp);
            finalTrans.data.GeneratedVariables.Add(hasMethodReturnedVar);
            PStm stm = new ALocalDeclStm(new TSemicolon(";"), hasMethodReturnedVar);
            outerBlock.GetStatements().Add(stm);

            AALocalDecl methodReturnerVar = null;
            if (!(decl.GetReturnType() is AVoidType))
            {
                methodReturnerVar = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, Util.MakeClone(decl.GetReturnType(), finalTrans.data),
                                                       new TIdentifier("inlineReturner"), null);
                stm = new ALocalDeclStm(new TSemicolon(";"), methodReturnerVar);
                outerBlock.GetStatements().Add(stm);
            }

            AABlock afterBlock = new AABlock();

            //A dictionary from the formals of the inline method to a cloneable replacement lvalue
            Dictionary<AALocalDecl, PLvalue> Parameters = new Dictionary<AALocalDecl, PLvalue>();
            Dictionary<AALocalDecl, PExp> ParameterExps = new Dictionary<AALocalDecl, PExp>();
            for (int i = 0; i < decl.GetFormals().Count; i++)
            {
                AALocalDecl formal = (AALocalDecl)decl.GetFormals()[i];
                PExp arg = (PExp)node.GetArgs()[0];
                PLvalue lvalue;
                //if ref, dont make a new var
                if (formal.GetRef() != null && arg is ALvalueExp)
                {
                    arg.Apply(new MoveMethodDeclsOut("inlineVar", finalTrans.data));
                    arg.Parent().RemoveChild(arg);
                    lvalue = ((ALvalueExp) arg).GetLvalue();

                }
                else if (!assignedToFormals.Contains(formal) && Util.IsLocal(arg, finalTrans.data))
                {
                    lvalue = new ALocalLvalue(new TIdentifier("I hope I dont make it"));
                    finalTrans.data.LvalueTypes[lvalue] = formal.GetType();
                    finalTrans.data.LocalLinks[(ALocalLvalue) lvalue] = formal;
                    ParameterExps[formal] = arg;
                    arg.Parent().RemoveChild(arg);
                }
                else
                {
                    AAssignmentExp assExp = null;
                    if (formal.GetOut() != null)
                    {
                        //Dont initialize with arg, but assign arg after
                        arg.Apply(new MoveMethodDeclsOut("inlineVar", finalTrans.data));
                        lvalue = ((ALvalueExp)arg).GetLvalue();
                        assExp = new AAssignmentExp(new TAssign("="), lvalue, null);
                        finalTrans.data.ExpTypes[assExp] = finalTrans.data.LvalueTypes[lvalue];
                        arg.Parent().RemoveChild(arg);
                        arg = null;
                    }
                    AALocalDecl parameter = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, Util.MakeClone(formal.GetType(), finalTrans.data),
                                                            new TIdentifier(formal.GetName().Text),
                                                            arg);
                    stm = new ALocalDeclStm(new TSemicolon(";"), parameter);
                    outerBlock.GetStatements().Add(stm);

                    lvalue = new ALocalLvalue(new TIdentifier(parameter.GetName().Text));
                    finalTrans.data.LvalueTypes[lvalue] = parameter.GetType();
                    finalTrans.data.LocalLinks[(ALocalLvalue)lvalue] = parameter;

                    if (formal.GetOut() != null)
                    {
                        //Dont initialize with arg, but assign arg after
                        ALvalueExp lvalueExp = new ALvalueExp(Util.MakeClone(lvalue, finalTrans.data));
                        finalTrans.data.ExpTypes[lvalueExp] = finalTrans.data.LvalueTypes[lvalue];
                        assExp.SetExp(lvalueExp);
                        afterBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assExp));
                    }
                }
                Parameters.Add(formal, lvalue);
            }

            AABlock innerBlock = (AABlock)decl.GetBlock().Clone();
            exp = new ABooleanConstExp(new ATrueBool());
            finalTrans.data.ExpTypes[exp] = new ANamedType(new TIdentifier("bool"), null);
            ABlockStm innerBlockStm = new ABlockStm(new TLBrace("{"), innerBlock);

            bool needWhile = CheckIfWhilesIsNeeded.IsWhileNeeded(decl.GetBlock());
            if (needWhile)
                stm = new AWhileStm(new TLParen("("), exp, innerBlockStm);
            else
                stm = innerBlockStm;
            outerBlock.GetStatements().Add(stm);

            outerBlock.GetStatements().Add(new ABlockStm(new TLBrace("{"), afterBlock));

            //Clone method contents to inner block.
            CloneMethod cloneFixer = new CloneMethod(finalTrans, Parameters, ParameterExps, innerBlockStm);
            decl.GetBlock().Apply(cloneFixer);
            foreach (KeyValuePair<PLvalue, PExp> pair in cloneFixer.ReplaceUsAfter)
            {
                PLvalue lvalue = pair.Key;
                PExp replacement =  Util.MakeClone(pair.Value, finalTrans.data);
                ALvalueExp lvalueParent = (ALvalueExp) lvalue.Parent();
                lvalueParent.ReplaceBy(replacement);
            }
            innerBlockStm.Apply(new FixTypes(finalTrans.data));

            innerBlock.Apply(new FixReturnsAndWhiles(hasMethodReturnedVar, methodReturnerVar, finalTrans.data, needWhile));

            GetNonBlockStm stmFinder = new GetNonBlockStm(false);
            innerBlock.Apply(stmFinder);
            if (needWhile && (stmFinder.Stm == null || !(stmFinder.Stm is ABreakStm)))
                innerBlock.GetStatements().Add(new ABreakStm(new TBreak("break")));

            //Insert before current statement
            ABlockStm outerBlockStm = new ABlockStm(new TLBrace("{"), outerBlock);

            PStm pStm = Util.GetAncestor<PStm>(node);

            pBlock = (AABlock)pStm.Parent();

            pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(pStm), outerBlockStm);

            if (node.Parent() == pStm && pStm is AExpStm)
            {
                pBlock.RemoveChild(pStm);
            }
            else
            {
                PLvalue lvalue = new ALocalLvalue(new TIdentifier(methodReturnerVar.GetName().Text));
                finalTrans.data.LvalueTypes[lvalue] = methodReturnerVar.GetType();
                finalTrans.data.LocalLinks[(ALocalLvalue)lvalue] = methodReturnerVar;
                exp = new ALvalueExp(lvalue);
                finalTrans.data.ExpTypes[exp] = methodReturnerVar.GetType();

                node.ReplaceBy(exp);
            }
            return new List<AABlock>() { outerBlock };
        }
Esempio n. 15
0
 ArrayList New323()
 {
     ArrayList nodeList = new ArrayList();
     ArrayList nodeArrayList1 = (ArrayList) Pop();
     PBool pboolNode2 = (PBool)nodeArrayList1[0];
     ABooleanConstExp pexpNode1 = new ABooleanConstExp (
       pboolNode2
     );
     nodeList.Add(pexpNode1);
     return nodeList;
 }
Esempio n. 16
0
            public override void CaseAPArrayLengthLvalue(APArrayLengthLvalue node)
            {
                base.CaseAPArrayLengthLvalue(node);
                ABinopExp binopExp = new ABinopExp(nameExp, new APlusBinop(new TPlus("+")), new AStringConstExp(new TStringLiteral("\"\\\\Length\"")));
                ABooleanConstExp trueConst = new ABooleanConstExp(new ATrueBool());
                ASimpleInvokeExp invoke = new ASimpleInvokeExp(new TIdentifier("DataTableGetInt"), new ArrayList(){trueConst, binopExp});
                ALvalueExp parent = (ALvalueExp) node.Parent();
                parent.ReplaceBy(invoke);

                data.ExpTypes[binopExp] =
                    data.ExpTypes[binopExp.GetRight()] = new ANamedType(new TIdentifier("string"), null);

                data.ExpTypes[trueConst] = new ANamedType(new TIdentifier("bool"), null);

                data.ExpTypes[invoke] = new ANamedType(new TIdentifier("int"), null);

                data.SimpleMethodLinks[invoke] =
                    data.Libraries.Methods.First(m => m.GetName().Text == invoke.GetName().Text);

                nameExp = null;
                hadPointer = false;
            }
 public override void CaseABooleanConstExp(ABooleanConstExp node)
 {
     Write(node.GetBool() is ATrueBool ? "true" : "false");
 }
Esempio n. 18
0
            private static void AddRemoves(PExp exp, PType type, AABlock block, SharedData data)
            {
                if (Util.IsBulkCopy(type))
                {
                    if (type is ANamedType)
                    {
                        ANamedType aType = (ANamedType)type;
                        AStructDecl structDecl = data.StructTypeLinks[aType];
                        foreach (AALocalDecl localDecl in structDecl.GetLocals())
                        {
                            ABinopExp newExp = new ABinopExp(exp, new APlusBinop(new TPlus("+")),
                                                     new AStringConstExp(
                                                         new TStringLiteral("\"." + localDecl.GetName().Text + "\"")));
                            data.ExpTypes[newExp] =
                                data.ExpTypes[newExp.GetRight()] =
                                new ANamedType(new TIdentifier("string"), null);

                            AddRemoves(newExp, localDecl.GetType(), block, data);
                        }
                    }
                    else
                    {//Is array type. Can Only be a constant array type
                        AArrayTempType aType = (AArrayTempType)type;
                        for (int i = 0; i < int.Parse(aType.GetIntDim().Text); i++)
                        {
                            ABinopExp newExp = new ABinopExp(exp, new APlusBinop(new TPlus("+")),
                                                     new AStringConstExp(
                                                         new TStringLiteral("\"[" + i + "]\"")));
                            data.ExpTypes[newExp] =
                                data.ExpTypes[newExp.GetRight()] =
                                new ANamedType(new TIdentifier("string"), null);

                            AddRemoves(newExp, aType.GetType(), block, data);
                        }

                    }
                }
                else
                {
                    exp = Util.MakeClone(exp, data);

                    ABooleanConstExp trueConst1 = new ABooleanConstExp(new ATrueBool());
                    ASimpleInvokeExp removeInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableValueRemove"), new ArrayList() { trueConst1, exp });
                    block.GetStatements().Add(new AExpStm(new TSemicolon(";"), removeInvoke));

                    data.ExpTypes[trueConst1] = new ANamedType(new TIdentifier("bool"), null);

                    data.ExpTypes[removeInvoke] = new AVoidType(new TVoid("void"));

                    data.SimpleMethodLinks[removeInvoke] =
                        data.Libraries.Methods.First(m => m.GetName().Text == removeInvoke.GetName().Text);
                }
            }
 public override void OutABooleanConstExp(ABooleanConstExp node)
 {
     data.ExpTypes[node] = new ANamedType(new TIdentifier("bool"), null);
     base.OutABooleanConstExp(node);
 }
Esempio n. 20
0
            private static AMethodDecl CreateGeneralNullCheckMethod(Node node, SharedData data)
            {
                if (generalCompareNullMethod != null)
                    return generalCompareNullMethod;

                /*
                 *  bool IsNull(string pointer)
                 *  {
                 *      if (pointer == null)
                 *      {
                 *          return true;
                 *      }
                 *      return !DataTableGetBool(true, pointer + "\\Exists");
                 *  }
                 */

                AALocalDecl pointerDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                          new ANamedType(new TIdentifier("string"), null),
                                                          new TIdentifier("pointer"), null);

                ALocalLvalue pointerRef1 = new ALocalLvalue(new TIdentifier("pointer"));
                ALocalLvalue pointerRef2 = new ALocalLvalue(new TIdentifier("pointer"));
                ALvalueExp pointerRef1Exp = new ALvalueExp(pointerRef1);
                ALvalueExp pointerRef2Exp = new ALvalueExp(pointerRef2);

                ANullExp nullExp = new ANullExp();

                ABooleanConstExp boolConst1 = new ABooleanConstExp(new ATrueBool());
                ABooleanConstExp boolConst2 = new ABooleanConstExp(new ATrueBool());

                AStringConstExp stringConst = new AStringConstExp(new TStringLiteral("\"\\\\Exists\""));

                ABinopExp binop1 = new ABinopExp(pointerRef1Exp, new AEqBinop(new TEq("==")), nullExp);
                ABinopExp binop2 = new ABinopExp(pointerRef2Exp, new APlusBinop(new TPlus("+")), stringConst);

                ASimpleInvokeExp dataTableGetBoolCall = new ASimpleInvokeExp(new TIdentifier("DataTableGetBool"), new ArrayList(){boolConst2, binop2});
                AUnopExp unopExp = new AUnopExp(new AComplementUnop(new TComplement("!")), dataTableGetBoolCall);

                generalCompareNullMethod = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null,
                                                           new ANamedType(new TIdentifier("bool"), null),
                                                           new TIdentifier("IsNull"), new ArrayList() {pointerDecl},
                                                           new AABlock(
                                                               new ArrayList()
                                                                   {
                                                                       new AIfThenStm(new TLParen("("), binop1,
                                                                                      new ABlockStm(new TLBrace("{"),
                                                                                                    new AABlock(
                                                                                                        new ArrayList()
                                                                                                            {
                                                                                                                new AValueReturnStm
                                                                                                                    (new TReturn
                                                                                                                         ("return"),
                                                                                                                     boolConst1)
                                                                                                            },
                                                                                                        new TRBrace("}")))),
                                                                       new AValueReturnStm(new TReturn("return"),
                                                                                           unopExp)
                                                                   }, new TRBrace("}")));

                AASourceFile sourceFile = Util.GetAncestor<AASourceFile>(node);
                sourceFile.GetDecl().Add(generalCompareNullMethod);

                data.LocalLinks[pointerRef1] =
                    data.LocalLinks[pointerRef2] = pointerDecl;

                data.LvalueTypes[pointerRef1] =
                    data.LvalueTypes[pointerRef2] =
                    data.ExpTypes[pointerRef1Exp] =
                    data.ExpTypes[pointerRef2Exp] =
                    data.ExpTypes[stringConst] =
                    data.ExpTypes[binop2] = new ANamedType(new TIdentifier("string"), null);

                data.ExpTypes[binop1] =
                    data.ExpTypes[boolConst1] =
                    data.ExpTypes[boolConst2] =
                    data.ExpTypes[dataTableGetBoolCall] =
                    data.ExpTypes[unopExp] = new ANamedType(new TIdentifier("string"), null);

                foreach (AMethodDecl methodDecl in data.Libraries.Methods)
                {
                    if (methodDecl.GetName().Text == dataTableGetBoolCall.GetName().Text)
                    {
                        data.SimpleMethodLinks[dataTableGetBoolCall] = methodDecl;
                        break;
                    }
                }
                return generalCompareNullMethod;
            }
        private List<PStm> AssignDefault(PLvalue lvalue)
        {
            List<PStm> returner = new List<PStm>();
            PType type = data.LvalueTypes[lvalue];
            PExp rightSide = null;
            if (type is ANamedType)
            {
                ANamedType aType = (ANamedType)type;
                if (aType.IsPrimitive("string"))//aType.GetName().Text == "string")
                {
                    rightSide = new AStringConstExp(new TStringLiteral("\"\""));
                    data.ExpTypes[rightSide] = new ANamedType(new TIdentifier("string"), null);
                }
                else if (aType.IsPrimitive(GalaxyKeywords.NullablePrimitives.words)) //GalaxyKeywords.NullablePrimitives.words.Contains(aType.GetName().Text))
                {
                    rightSide = new ANullExp();
                    data.ExpTypes[rightSide] = new ANamedType(new TIdentifier("null"), null);
                }
                else if (aType.IsPrimitive(new []{"int", "byte", "fixed"}))
                    /*aType.GetName().Text == "int" ||
                    aType.GetName().Text == "byte" ||
                    aType.GetName().Text == "fixed")*/
                {
                    rightSide = new AIntConstExp(new TIntegerLiteral("0"));
                    data.ExpTypes[rightSide] = type;
                }
                else if (aType.IsPrimitive("bool"))//aType.GetName().Text == "bool")
                {
                    rightSide = new ABooleanConstExp(new AFalseBool());
                    data.ExpTypes[rightSide] = type;
                }
                else if (aType.IsPrimitive("color"))//aType.GetName().Text == "color")
                {
                    PExp arg1 = new AIntConstExp(new TIntegerLiteral("0"));
                    PExp arg2 = new AIntConstExp(new TIntegerLiteral("0"));
                    PExp arg3 = new AIntConstExp(new TIntegerLiteral("0"));
                    ASimpleInvokeExp invoke = new ASimpleInvokeExp(new TIdentifier("Color"), new ArrayList() { arg1, arg2, arg3 });
                    rightSide = invoke;
                    data.ExpTypes[rightSide] = type;
                    data.ExpTypes[arg1] =
                        data.ExpTypes[arg2] =
                        data.ExpTypes[arg3] = new ANamedType(new TIdentifier("int"), null);
                    data.SimpleMethodLinks[invoke] =
                        data.Libraries.Methods.First(func => func.GetName().Text == invoke.GetName().Text);
                }
                else if (aType.IsPrimitive("char"))//aType.GetName().Text == "char")
                {
                    //Dunno?!
                    rightSide = new ACharConstExp(new TCharLiteral("'\0'"));
                    data.ExpTypes[rightSide] = type;
                }
                else //Struct
                {
                    AStructDecl str = data.StructTypeLinks[aType];
                    foreach (AALocalDecl localDecl in str.GetLocals())
                    {
                        ALvalueExp reciever = new ALvalueExp(Util.MakeClone(lvalue, data));
                        AStructLvalue newLvalue = new AStructLvalue(reciever, new ADotDotType(new TDot(".")), new TIdentifier(localDecl.GetName().Text));
                        data.StructFieldLinks[newLvalue] = localDecl;
                        data.ExpTypes[reciever] = type;
                        data.LvalueTypes[newLvalue] = localDecl.GetType();
                        returner.AddRange(AssignDefault(newLvalue));
                    }
                    return returner;
                }
                AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), Util.MakeClone(lvalue, data), rightSide);
                data.ExpTypes[assignment] = type;
                return new List<PStm>() { new AExpStm(new TSemicolon(";"), assignment) };
            }
            if (type is AArrayTempType)
            {
                AArrayTempType aType = (AArrayTempType)type;
                for (int i = 0; i < int.Parse(aType.GetIntDim().Text); i++)
                {
                    ALvalueExp reciever = new ALvalueExp(Util.MakeClone(lvalue, data));
                    AArrayLvalue newLvalue = new AArrayLvalue(new TLBracket("["), reciever, new AIntConstExp(new TIntegerLiteral(i.ToString())));
                    data.ExpTypes[reciever] = type;
                    data.LvalueTypes[newLvalue] = aType.GetType();
                    data.ExpTypes[newLvalue.GetIndex()] = new ANamedType(new TIdentifier("int"), null);
                    returner.AddRange(AssignDefault(newLvalue));
                }
                return returner;
            }

            throw new Exception("Unexpected type. (LivenessAnalasys.AssignDefault), got " + type);
        }
Esempio n. 22
0
            private static AMethodDecl CreateNullCheckMethodP(Node node, TIntegerLiteral intLiteral, string prefix, GlobalStructVars vars, SharedData data)
            {
                /*
                 *
                            <<usedBits := floor(log2(42))+1>>
                            <<bitsLeft := 31 - usedBits>>
                            <<biggestIdentifier := 2^(bitsLeft + 1) - 1>>
                 *
                 *  bool prefix_IsNull(int pointer)
                 *  {
                 *      int identifier;
                 *      if (pointer == 0)
                 *      {
                 *          return true;
                 *      }
                 *      identifier = pointer & biggestIdentifier;
                 *      pointer = pointer >> bitsLeft;
                 *      return (Str_used[pointer / 31] & (1 << (pointer % 31))) == 0 || identifierArray[pointer] != identifier;
                 *  }
                 */
                int usedLimit = int.Parse(intLiteral.Text);
                int usedBits = usedLimit == 0 ? 0 : ((int)Math.Floor(Math.Log(usedLimit, 2)) + 1);
                int bitsLeft = 31 - usedBits;
                int biggestIdentifier = (1 << (bitsLeft + 1)) - 1;

                AALocalDecl pointerDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                          new ANamedType(new TIdentifier("int"), null),
                                                          new TIdentifier("pointer"), null);
                AALocalDecl identifierDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                             new ANamedType(new TIdentifier("int"), null),
                                                             new TIdentifier("identifier"), null);

                ALocalLvalue pointerRef1 = new ALocalLvalue(new TIdentifier("pointer"));
                ALocalLvalue pointerRef2 = new ALocalLvalue(new TIdentifier("pointer"));
                ALocalLvalue pointerRef3 = new ALocalLvalue(new TIdentifier("pointer"));
                ALocalLvalue pointerRef4 = new ALocalLvalue(new TIdentifier("pointer"));
                ALocalLvalue pointerRef5 = new ALocalLvalue(new TIdentifier("pointer"));
                ALocalLvalue pointerRef6 = new ALocalLvalue(new TIdentifier("pointer"));
                ALocalLvalue pointerRef7 = new ALocalLvalue(new TIdentifier("pointer"));
                ALvalueExp pointerRef1Exp = new ALvalueExp(pointerRef1);
                ALvalueExp pointerRef2Exp = new ALvalueExp(pointerRef2);
                ALvalueExp pointerRef4Exp = new ALvalueExp(pointerRef4);
                ALvalueExp pointerRef5Exp = new ALvalueExp(pointerRef5);
                ALvalueExp pointerRef6Exp = new ALvalueExp(pointerRef6);
                ALvalueExp pointerRef7Exp = new ALvalueExp(pointerRef7);

                ALocalLvalue identifierRef1 = new ALocalLvalue(new TIdentifier("identifier"));
                ALocalLvalue identifierRef2 = new ALocalLvalue(new TIdentifier("identifier"));
                ALvalueExp identifierRef2Exp = new ALvalueExp(identifierRef2);

                AFieldLvalue usedRef = new AFieldLvalue(new TIdentifier("used"));
                ALvalueExp usedRefExp = new ALvalueExp(usedRef);

                AFieldLvalue identifierArrayRef = new AFieldLvalue(new TIdentifier("identifierArray"));
                ALvalueExp identifierArrayRefExp = new ALvalueExp(identifierArrayRef);

                AIntConstExp intConst1 = new AIntConstExp(new TIntegerLiteral("0"));
                AIntConstExp intConst2 = new AIntConstExp(new TIntegerLiteral(biggestIdentifier.ToString()));
                AIntConstExp intConst3 = new AIntConstExp(new TIntegerLiteral(bitsLeft.ToString()));
                AIntConstExp intConst4 = new AIntConstExp(new TIntegerLiteral("31"));
                AIntConstExp intConst5 = new AIntConstExp(new TIntegerLiteral("1"));
                AIntConstExp intConst6 = new AIntConstExp(new TIntegerLiteral("31"));
                AIntConstExp intConst7 = new AIntConstExp(new TIntegerLiteral("0"));

                ABinopExp binop4 = new ABinopExp(pointerRef5Exp, new ADivideBinop(new TDiv("/")), intConst4);

                AArrayLvalue arrayLvalue1 = new AArrayLvalue(new TLBracket("["), usedRefExp, binop4);
                AArrayLvalue arrayLvalue2 = new AArrayLvalue(new TLBracket("["), identifierArrayRefExp, pointerRef7Exp);
                ALvalueExp arrayLvalue1Exp = new ALvalueExp(arrayLvalue1);
                ALvalueExp arrayLvalue2Exp = new ALvalueExp(arrayLvalue2);

                ABinopExp binop1 = new ABinopExp(pointerRef1Exp, new AEqBinop(new TEq("==")), intConst1);
                ABinopExp binop2 = new ABinopExp(pointerRef2Exp, new AAndBinop(new TAnd("&")), intConst2);
                ABinopExp binop3 = new ABinopExp(pointerRef4Exp, new ARBitShiftBinop(new TRBitShift(">>")), intConst3);
                ABinopExp binop5 = new ABinopExp(pointerRef6Exp, new AModuloBinop(new TMod("%")), intConst6);
                ABinopExp binop6 = new ABinopExp(intConst5, new ALBitShiftBinop(new TLBitShift("<<")), binop5);
                ABinopExp binop7 = new ABinopExp(arrayLvalue1Exp, new AAndBinop(new TAnd("&")), binop6);
                ABinopExp binop8 = new ABinopExp(binop7, new AEqBinop(new TEq("==")), intConst7);
                ABinopExp binop9 = new ABinopExp(arrayLvalue2Exp, new ANeBinop(new TNeq("!=")), identifierRef2Exp);
                ABinopExp binop10 = new ABinopExp(binop8, new ALazyOrBinop(new TOrOr("||")), binop9);

                AAssignmentExp assignment1 = new AAssignmentExp(new TAssign("="), identifierRef1, binop2);
                AAssignmentExp assignment2 = new AAssignmentExp(new TAssign("="), pointerRef3, binop3);

                ABooleanConstExp boolConst = new ABooleanConstExp(new ATrueBool());

                AMethodDecl method = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null,
                                                     new ANamedType(new TIdentifier("bool"), null),
                                                     new TIdentifier(prefix + "_IsNull"), new ArrayList() {pointerDecl},
                                                     new AABlock(
                                                         new ArrayList()
                                                             {
                                                                 new ALocalDeclStm(new TSemicolon(";"), identifierDecl),
                                                                 new AIfThenStm(new TLParen("("), binop1,
                                                                                new ABlockStm(new TLBrace("{"),
                                                                                              new AABlock(
                                                                                                  new ArrayList()
                                                                                                      {
                                                                                                          new AValueReturnStm
                                                                                                              (new TReturn(
                                                                                                                   "return"),
                                                                                                               boolConst)
                                                                                                      },
                                                                                                  new TRBrace("}")))),
                                                                 new AExpStm(new TSemicolon(";"), assignment1),
                                                                 new AExpStm(new TSemicolon(";"), assignment2),
                                                                 new AValueReturnStm(new TReturn("return"), binop10)
                                                             },
                                                         new TRBrace("}")));

                AASourceFile sourceFile = Util.GetAncestor<AASourceFile>(node);
                sourceFile.GetDecl().Add(method);

                data.LocalLinks[pointerRef1] =
                    data.LocalLinks[pointerRef2] =
                    data.LocalLinks[pointerRef3] =
                    data.LocalLinks[pointerRef4] =
                    data.LocalLinks[pointerRef5] =
                    data.LocalLinks[pointerRef6] =
                    data.LocalLinks[pointerRef7] = pointerDecl;

                data.LocalLinks[identifierRef1] =
                    data.LocalLinks[identifierRef2] = identifierDecl;

                data.FieldLinks[usedRef] = vars.Used;
                data.FieldLinks[identifierArrayRef] = vars.IdentifierArray;

                data.LvalueTypes[pointerRef1] =
                    data.LvalueTypes[pointerRef2] =
                    data.LvalueTypes[pointerRef3] =
                    data.LvalueTypes[pointerRef4] =
                    data.LvalueTypes[pointerRef5] =
                    data.LvalueTypes[pointerRef6] =
                    data.LvalueTypes[pointerRef7] =
                    data.ExpTypes[pointerRef1Exp] =
                    data.ExpTypes[pointerRef2Exp] =
                    data.ExpTypes[pointerRef4Exp] =
                    data.ExpTypes[pointerRef5Exp] =
                    data.ExpTypes[pointerRef6Exp] =
                    data.ExpTypes[pointerRef7Exp] =
                    data.LvalueTypes[identifierRef1] =
                    data.LvalueTypes[identifierRef2] =
                    data.ExpTypes[identifierRef2Exp] =
                    data.ExpTypes[intConst1] =
                    data.ExpTypes[intConst2] =
                    data.ExpTypes[intConst3] =
                    data.ExpTypes[intConst4] =
                    data.ExpTypes[intConst5] =
                    data.ExpTypes[intConst6] =
                    data.ExpTypes[intConst7] =
                    data.ExpTypes[intConst1] =
                    data.ExpTypes[binop2] =
                    data.ExpTypes[binop3] =
                    data.ExpTypes[binop4] =
                    data.ExpTypes[binop5] =
                    data.ExpTypes[binop6] =
                    data.ExpTypes[binop7] =
                    data.LvalueTypes[arrayLvalue1] =
                    data.LvalueTypes[arrayLvalue2] =
                    data.ExpTypes[arrayLvalue1Exp] =
                    data.ExpTypes[arrayLvalue2Exp] =
                    data.ExpTypes[assignment1] =
                    data.ExpTypes[assignment2] = new ANamedType(new TIdentifier("int"), null);

                data.ExpTypes[binop1] =
                    data.ExpTypes[binop8] =
                    data.ExpTypes[binop9] =
                    data.ExpTypes[binop10] =
                    data.ExpTypes[boolConst] = new ANamedType(new TIdentifier("bool"), null);

                data.LvalueTypes[usedRef] =
                    data.LvalueTypes[identifierArrayRef] =
                    data.ExpTypes[usedRefExp] =
                    data.ExpTypes[identifierArrayRefExp] = vars.IdentifierArray.GetType();

                return method;
            }
Esempio n. 23
0
 public override void CaseABooleanConstExp(ABooleanConstExp node)
 {
     InABooleanConstExp(node);
     if (node.GetBool() != null)
     {
         node.GetBool().Apply(this);
     }
     OutABooleanConstExp(node);
 }
Esempio n. 24
0
            private void MakeAssignmentRightDynamic(PLvalue leftSide, PExp rightSide, PType type, AABlock block, ref int index)
            {
                if (Util.IsBulkCopy(type))
                {
                    if (type is ANamedType)
                    {
                        ANamedType aType = (ANamedType)type;
                        AStructDecl structDecl = data.StructTypeLinks[aType];
                        foreach (AALocalDecl localDecl in structDecl.GetLocals())
                        {
                            AStructLvalue newleftSide = new AStructLvalue(new ALvalueExp(leftSide),
                                                                          new ADotDotType(new TDot(".")),
                                                                          new TIdentifier(localDecl.GetName().Text));

                            ABinopExp newrightSide = new ABinopExp(rightSide, new APlusBinop(new TPlus("+")),
                                                     new AStringConstExp(
                                                         new TStringLiteral("\"." + localDecl.GetName().Text + "\"")));

                             data.ExpTypes[newrightSide] =
                                data.ExpTypes[newrightSide.GetRight()] =
                                new ANamedType(new TIdentifier("string"), null);

                            data.ExpTypes[newleftSide.GetReceiver()] = type;
                            data.LvalueTypes[newleftSide] = localDecl.GetType();

                            data.StructFieldLinks[newleftSide] = localDecl;

                            MakeAssignmentRightDynamic(newleftSide, newrightSide, localDecl.GetType(), block, ref index);
                        }
                    }
                    else
                    {//Is array type. Can Only be a constant array type
                        AArrayTempType aType = (AArrayTempType)type;
                        for (int i = 0; i < int.Parse(aType.GetIntDim().Text); i++)
                        {
                            AArrayLvalue newleftSide = new AArrayLvalue(new TLBracket("["), new ALvalueExp(leftSide), new AIntConstExp(new TIntegerLiteral(i.ToString())));

                            ABinopExp newrightSide = new ABinopExp(rightSide, new APlusBinop(new TPlus("+")),
                                                     new AStringConstExp(
                                                         new TStringLiteral("\"[" + i + "]\"")));
                            data.ExpTypes[newrightSide] =
                                data.ExpTypes[newrightSide.GetRight()] =
                                new ANamedType(new TIdentifier("string"), null);

                            data.ExpTypes[newleftSide.GetBase()] = type;
                            data.ExpTypes[newleftSide.GetIndex()] = new ANamedType(new TIdentifier("int"), null);
                            data.LvalueTypes[newleftSide] = aType.GetType();

                            MakeAssignmentRightDynamic(newleftSide, newrightSide, aType.GetType(), block, ref index);

                        }

                    }
                }
                else
                {
                    ANamedType aType;// = type is APointerType ? new ANamedType(new TIdentifier("string"), null) : (ANamedType)type;
                    if (type is APointerType)
                    {
                        if (Util.IsIntPointer(type, ((APointerType)type).GetType(), data))
                            aType = new ANamedType(new TIdentifier("int"), null);
                        else
                            aType = new ANamedType(new TIdentifier("string"), null);
                    }
                    else
                    {
                        aType = (ANamedType) type;
                    }
                    string capitalType = Util.Capitalize(aType.AsIdentifierString());//Char.ToUpper(aType.GetName().Text[0]) + aType.GetName().Text.Substring(1);
                    leftSide = Util.MakeClone(leftSide, data);
                    rightSide = Util.MakeClone(rightSide, data);

                    ABooleanConstExp trueConst1 = new ABooleanConstExp(new ATrueBool());
                    //ABooleanConstExp trueConst2 = new ABooleanConstExp(new ATrueBool());
                    ASimpleInvokeExp innerInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableGet" + capitalType), new ArrayList() { trueConst1, rightSide });
                    //ASimpleInvokeExp outerInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableSet" + capitalType), new ArrayList() { trueConst2, leftSide, innerInvoke });
                    AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), leftSide, innerInvoke);
                    block.GetStatements().Insert(index, new AExpStm(new TSemicolon(";"), assignment));
                    index++;

                    data.ExpTypes[trueConst1] = new ANamedType(new TIdentifier("bool"), null);

                    data.ExpTypes[innerInvoke] = aType;
                    data.ExpTypes[assignment] = aType;

                    data.SimpleMethodLinks[innerInvoke] =
                        data.Libraries.Methods.First(m => m.GetName().Text == innerInvoke.GetName().Text);
                }
            }
Esempio n. 25
0
 public virtual void InABooleanConstExp(ABooleanConstExp node)
 {
     DefaultIn(node);
 }
Esempio n. 26
0
        private AMethodDecl GetMethodMethod()
        {
            if (GetMethodPartMethod != null)
                return GetMethodPartMethod;
            /*
                string GetMethodPart(string delegate)
                {
                    int i = StringFind(delegate, ":", false);
                    if (i == -1)
                    {
                        return delegate;
                    }
                    return StringSub(delegate, 1, i - 1);
                }
             */
            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"));
            ALocalLvalue delegateRef2 = new ALocalLvalue(new TIdentifier("delegate"));
            ALocalLvalue delegateRef3 = new ALocalLvalue(new TIdentifier("delegate"));
            ALvalueExp delegateRef1Exp = new ALvalueExp(delegateRef1);
            ALvalueExp delegateRef2Exp = new ALvalueExp(delegateRef2);
            ALvalueExp delegateRef3Exp = new ALvalueExp(delegateRef3);

            AStringConstExp stringConst = new AStringConstExp(new TStringLiteral("\":\""));
            ABooleanConstExp booleanConst = new ABooleanConstExp(new AFalseBool());
            AIntConstExp intConst1 = new AIntConstExp(new TIntegerLiteral("-1"));
            AIntConstExp intConst2 = new AIntConstExp(new TIntegerLiteral("1"));
            AIntConstExp intConst3 = new AIntConstExp(new TIntegerLiteral("1"));

            ASimpleInvokeExp stringFindInvoke = new ASimpleInvokeExp(new TIdentifier("StringFind"),
                                                                     new ArrayList()
                                                                         {delegateRef1Exp, stringConst, booleanConst});
            AALocalDecl iDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, new ANamedType(new TIdentifier("int"), null),
                                                new TIdentifier("i"), stringFindInvoke);
            ALocalLvalue iRef1 = new ALocalLvalue(new TIdentifier("i"));
            ALocalLvalue iRef2 = new ALocalLvalue(new TIdentifier("i"));
            ALvalueExp iRef1Exp = new ALvalueExp(iRef1);
            ALvalueExp iRef2Exp = new ALvalueExp(iRef2);

            ABinopExp binop1 = new ABinopExp(iRef1Exp, new AEqBinop(new TEq("==")), intConst1);
            AIfThenStm ifThen = new AIfThenStm(new TLParen("("), binop1,
                                               new ABlockStm(new TLBrace("{"),
                                                             new AABlock(
                                                                 new ArrayList()
                                                                     {
                                                                         new AValueReturnStm(new TReturn("return"),
                                                                                             delegateRef2Exp)
                                                                     },
                                                                 new TRBrace("}"))));

            ABinopExp binop2 = new ABinopExp(iRef2Exp, new AMinusBinop(new TMinus("-")), intConst3);
            ASimpleInvokeExp stringSubInvoke = new ASimpleInvokeExp(new TIdentifier("StringSub"),
                                                                    new ArrayList() {delegateRef3Exp, intConst2, binop2});

            GetMethodPartMethod = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null,
                                                  new ANamedType(new TIdentifier("string"), null),
                                                  new TIdentifier("GetMethodPart", finalTrans.data.LineCounts[sourceFile] + 1, 1), new ArrayList() { delegateFormal },
                                                  new AABlock(
                                                      new ArrayList()
                                                          {
                                                              new ALocalDeclStm(new TSemicolon(";"), iDecl),
                                                              ifThen,
                                                              new AValueReturnStm(new TReturn("return"), stringSubInvoke)
                                                          },
                                                      new TRBrace("}")));
            sourceFile.GetDecl().Add(GetMethodPartMethod);

            finalTrans.data.LocalLinks[delegateRef1] =
                finalTrans.data.LocalLinks[delegateRef2] =
                finalTrans.data.LocalLinks[delegateRef3] = delegateFormal;
            finalTrans.data.LocalLinks[iRef1] =
                finalTrans.data.LocalLinks[iRef2] = iDecl;
            finalTrans.data.LvalueTypes[delegateRef1] =
                finalTrans.data.LvalueTypes[delegateRef2] =
                finalTrans.data.LvalueTypes[delegateRef3] =
                finalTrans.data.ExpTypes[delegateRef1Exp] =
                finalTrans.data.ExpTypes[delegateRef2Exp] =
                finalTrans.data.ExpTypes[delegateRef3Exp] =
                finalTrans.data.ExpTypes[stringConst] =
                finalTrans.data.ExpTypes[stringSubInvoke] = new ANamedType(new TIdentifier("string"), null);
            finalTrans.data.LvalueTypes[iRef1] =
                finalTrans.data.LvalueTypes[iRef2] =
                finalTrans.data.ExpTypes[iRef1Exp] =
                finalTrans.data.ExpTypes[iRef2Exp] =
                finalTrans.data.ExpTypes[stringFindInvoke] =
                finalTrans.data.ExpTypes[intConst1] =
                finalTrans.data.ExpTypes[intConst2] =
                finalTrans.data.ExpTypes[intConst3] =
                finalTrans.data.ExpTypes[binop2] = new ANamedType(new TIdentifier("int"), null);
            finalTrans.data.ExpTypes[booleanConst] =
                finalTrans.data.ExpTypes[binop1] = new ANamedType(new TIdentifier("bool"), null);

            finalTrans.data.SimpleMethodLinks[stringFindInvoke] =
                finalTrans.data.Libraries.Methods.First(m => m.GetName().Text == stringFindInvoke.GetName().Text);
            finalTrans.data.SimpleMethodLinks[stringSubInvoke] =
                finalTrans.data.Libraries.Methods.First(m => m.GetName().Text == stringSubInvoke.GetName().Text);

            return GetMethodPartMethod;
        }
        private AMethodDecl CreateStringDeobfuscator()
        {
            AASourceFile file = (AASourceFile) finalTrans.mainEntry.Parent();

            //Create fields for the string constants
            AStringConstExp emptyStringConst = new AStringConstExp(new TStringLiteral("\"\""));
            AFieldDecl emptyStringField = new AFieldDecl(new APublicVisibilityModifier(), null, new TConst("const"),
                                                         new ANamedType(new TIdentifier("string"), null),
                                                         new TIdentifier("fOobar"), emptyStringConst);
            file.GetDecl().Add(emptyStringField);
            data.Fields.Add(new SharedData.DeclItem<AFieldDecl>(file, emptyStringField));
            AFieldLvalue emptyStringRef1 = new AFieldLvalue(new TIdentifier(emptyStringField.GetName().Text));
            AFieldLvalue emptyStringRef2 = new AFieldLvalue(new TIdentifier(emptyStringField.GetName().Text));
            AFieldLvalue emptyStringRef3 = new AFieldLvalue(new TIdentifier(emptyStringField.GetName().Text));
            ALvalueExp emptyStringRef1Exp = new ALvalueExp(emptyStringRef1);
            ALvalueExp emptyStringRef2Exp = new ALvalueExp(emptyStringRef2);
            ALvalueExp emptyStringRef3Exp = new ALvalueExp(emptyStringRef3);

            AStringConstExp colonStringConst = new AStringConstExp(new TStringLiteral("\":\""));
            AFieldDecl colonStringField = new AFieldDecl(new APublicVisibilityModifier(), null, new TConst("const"),
                                                         new ANamedType(new TIdentifier("string"), null),
                                                         new TIdentifier("foObar"), colonStringConst);
            file.GetDecl().Add(colonStringField);
            data.Fields.Add(new SharedData.DeclItem<AFieldDecl>(file, colonStringField));
            AFieldLvalue colonStringRef = new AFieldLvalue(new TIdentifier(colonStringField.GetName().Text));
            ALvalueExp colonStringRefExp = new ALvalueExp(colonStringRef);

            /*
                string output = "";
                string ch;
                int length = StringLength(s);
                int phase1 = (length - 1)%3;
                int phase2 = (length - 1)%2;
             */

            AALocalDecl stringParam = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                      new ANamedType(new TIdentifier("string"), null),
                                                      new TIdentifier("fo0bar"), emptyStringRef1Exp);
            ALocalLvalue stringParamRef1 = new ALocalLvalue(new TIdentifier(stringParam.GetName().Text));
            ALocalLvalue stringParamRef2 = new ALocalLvalue(new TIdentifier(stringParam.GetName().Text));
            ALocalLvalue stringParamRef3 = new ALocalLvalue(new TIdentifier(stringParam.GetName().Text));
            ALocalLvalue stringParamRef4 = new ALocalLvalue(new TIdentifier(stringParam.GetName().Text));
            ALocalLvalue stringParamRef5 = new ALocalLvalue(new TIdentifier(stringParam.GetName().Text));
            ALocalLvalue stringParamRef6 = new ALocalLvalue(new TIdentifier(stringParam.GetName().Text));
            ALocalLvalue stringParamRef7 = new ALocalLvalue(new TIdentifier(stringParam.GetName().Text));
            ALocalLvalue stringParamRef8 = new ALocalLvalue(new TIdentifier(stringParam.GetName().Text));
            ALvalueExp stringParamRef1Exp = new ALvalueExp(stringParamRef1);
            ALvalueExp stringParamRef2Exp = new ALvalueExp(stringParamRef2);
            ALvalueExp stringParamRef4Exp = new ALvalueExp(stringParamRef4);
            ALvalueExp stringParamRef5Exp = new ALvalueExp(stringParamRef5);
            ALvalueExp stringParamRef7Exp = new ALvalueExp(stringParamRef7);
            ALvalueExp stringParamRef8Exp = new ALvalueExp(stringParamRef8);

            AABlock methodBlock = new AABlock(new ArrayList(), new TRBrace("}"));

            AALocalDecl outputDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                     new ANamedType(new TIdentifier("string"), null),
                                                     new TIdentifier("foobar"), emptyStringRef1Exp);
            methodBlock.GetStatements().Add(new ALocalDeclStm(new TSemicolon(";"), outputDecl));
            ALocalLvalue outputRef1 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef2 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef3 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef4 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef5 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef6 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef7 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef8 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef9 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef10 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef11 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef12 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALocalLvalue outputRef13 = new ALocalLvalue(new TIdentifier(outputDecl.GetName().Text));
            ALvalueExp outputRef2Exp = new ALvalueExp(outputRef2);
            ALvalueExp outputRef4Exp = new ALvalueExp(outputRef4);
            ALvalueExp outputRef5Exp = new ALvalueExp(outputRef5);
            ALvalueExp outputRef6Exp = new ALvalueExp(outputRef6);
            ALvalueExp outputRef7Exp = new ALvalueExp(outputRef7);
            ALvalueExp outputRef8Exp = new ALvalueExp(outputRef8);
            ALvalueExp outputRef10Exp = new ALvalueExp(outputRef10);
            ALvalueExp outputRef11Exp = new ALvalueExp(outputRef11);
            ALvalueExp outputRef12Exp = new ALvalueExp(outputRef12);
            ALvalueExp outputRef13Exp = new ALvalueExp(outputRef13);

            AALocalDecl chDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                     new ANamedType(new TIdentifier("string"), null),
                                                     new TIdentifier("f0obar"), null);
            methodBlock.GetStatements().Add(new ALocalDeclStm(new TSemicolon(";"), chDecl));
            ALocalLvalue chRef1 = new ALocalLvalue(new TIdentifier(chDecl.GetName().Text));
            ALocalLvalue chRef2 = new ALocalLvalue(new TIdentifier(chDecl.GetName().Text));
            ALocalLvalue chRef3 = new ALocalLvalue(new TIdentifier(chDecl.GetName().Text));
            ALocalLvalue chRef4 = new ALocalLvalue(new TIdentifier(chDecl.GetName().Text));
            ALocalLvalue chRef5 = new ALocalLvalue(new TIdentifier(chDecl.GetName().Text));
            ALvalueExp chRef3Exp = new ALvalueExp(chRef3);
            ALvalueExp chRef4Exp = new ALvalueExp(chRef4);
            ALvalueExp chRef5Exp = new ALvalueExp(chRef5);

            ASimpleInvokeExp stringLengthInvoke1 = new ASimpleInvokeExp(new TIdentifier("StringLength"),
                                                                        new ArrayList() { stringParamRef1Exp });
            AALocalDecl lengthDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                     new ANamedType(new TIdentifier("int"), null),
                                                     new TIdentifier("f0Obar"), stringLengthInvoke1);
            methodBlock.GetStatements().Add(new ALocalDeclStm(new TSemicolon(";"), lengthDecl));
            ALocalLvalue lengthRef1 = new ALocalLvalue(new TIdentifier(lengthDecl.GetName().Text));
            ALocalLvalue lengthRef2 = new ALocalLvalue(new TIdentifier(lengthDecl.GetName().Text));
            ALocalLvalue lengthRef3 = new ALocalLvalue(new TIdentifier(lengthDecl.GetName().Text));
            ALocalLvalue lengthRef4 = new ALocalLvalue(new TIdentifier(lengthDecl.GetName().Text));
            ALocalLvalue lengthRef5 = new ALocalLvalue(new TIdentifier(lengthDecl.GetName().Text));
            ALocalLvalue lengthRef6 = new ALocalLvalue(new TIdentifier(lengthDecl.GetName().Text));
            ALocalLvalue lengthRef7 = new ALocalLvalue(new TIdentifier(lengthDecl.GetName().Text));
            ALocalLvalue lengthRef8 = new ALocalLvalue(new TIdentifier(lengthDecl.GetName().Text));
            ALvalueExp lengthRef1Exp = new ALvalueExp(lengthRef1);
            ALvalueExp lengthRef2Exp = new ALvalueExp(lengthRef2);
            ALvalueExp lengthRef3Exp = new ALvalueExp(lengthRef3);
            ALvalueExp lengthRef4Exp = new ALvalueExp(lengthRef4);
            ALvalueExp lengthRef5Exp = new ALvalueExp(lengthRef5);
            ALvalueExp lengthRef6Exp = new ALvalueExp(lengthRef6);
            ALvalueExp lengthRef7Exp = new ALvalueExp(lengthRef7);

            AIntConstExp intConstp1Init1 = new AIntConstExp(new TIntegerLiteral("1"));
            AIntConstExp intConstp1Init2 = new AIntConstExp(new TIntegerLiteral("3"));
            ABinopExp binopExpP1InitMinus = new ABinopExp(lengthRef1Exp, new AMinusBinop(new TMinus("-")), intConstp1Init1);
            ABinopExp binopExpP1InitMod = new ABinopExp(binopExpP1InitMinus, new AModuloBinop(new TMod("%")), intConstp1Init2);

            AALocalDecl phase1Decl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                     new ANamedType(new TIdentifier("int"), null),
                                                     new TIdentifier("fO0bar"), binopExpP1InitMod);
            methodBlock.GetStatements().Add(new ALocalDeclStm(new TSemicolon(";"), phase1Decl));
            ALocalLvalue phase1Ref1 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALocalLvalue phase1Ref2 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALocalLvalue phase1Ref3 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALocalLvalue phase1Ref4 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALocalLvalue phase1Ref5 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALocalLvalue phase1Ref6 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALocalLvalue phase1Ref7 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALocalLvalue phase1Ref8 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALocalLvalue phase1Ref9 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALocalLvalue phase1Ref10 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALocalLvalue phase1Ref11 = new ALocalLvalue(new TIdentifier(phase1Decl.GetName().Text));
            ALvalueExp phase1Ref1Exp = new ALvalueExp(phase1Ref1);
            ALvalueExp phase1Ref2Exp = new ALvalueExp(phase1Ref2);
            ALvalueExp phase1Ref4Exp = new ALvalueExp(phase1Ref4);
            ALvalueExp phase1Ref5Exp = new ALvalueExp(phase1Ref5);
            ALvalueExp phase1Ref7Exp = new ALvalueExp(phase1Ref7);
            ALvalueExp phase1Ref9Exp = new ALvalueExp(phase1Ref9);
            ALvalueExp phase1Ref10Exp = new ALvalueExp(phase1Ref10);
            ALvalueExp phase1Ref11Exp = new ALvalueExp(phase1Ref11);

            AIntConstExp intConstp2Init1 = new AIntConstExp(new TIntegerLiteral("1"));
            AIntConstExp intConstp2Init2 = new AIntConstExp(new TIntegerLiteral("2"));
            ABinopExp binopExpP2InitMinus = new ABinopExp(lengthRef2Exp, new AMinusBinop(new TMinus("-")), intConstp2Init1);
            ABinopExp binopExpP2InitMod = new ABinopExp(binopExpP2InitMinus, new AModuloBinop(new TMod("%")), intConstp2Init2);

            AALocalDecl phase2Decl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                     new ANamedType(new TIdentifier("int"), null),
                                                     new TIdentifier("carl"), binopExpP2InitMod);
            methodBlock.GetStatements().Add(new ALocalDeclStm(new TSemicolon(";"), phase2Decl));
            ALocalLvalue phase2Ref1 = new ALocalLvalue(new TIdentifier(phase2Decl.GetName().Text));
            ALocalLvalue phase2Ref2 = new ALocalLvalue(new TIdentifier(phase2Decl.GetName().Text));
            ALocalLvalue phase2Ref3 = new ALocalLvalue(new TIdentifier(phase2Decl.GetName().Text));
            ALocalLvalue phase2Ref4 = new ALocalLvalue(new TIdentifier(phase2Decl.GetName().Text));
            ALocalLvalue phase2Ref5 = new ALocalLvalue(new TIdentifier(phase2Decl.GetName().Text));
            ALocalLvalue phase2Ref6 = new ALocalLvalue(new TIdentifier(phase2Decl.GetName().Text));
            ALocalLvalue phase2Ref7 = new ALocalLvalue(new TIdentifier(phase2Decl.GetName().Text));
            ALocalLvalue phase2Ref8 = new ALocalLvalue(new TIdentifier(phase2Decl.GetName().Text));
            ALocalLvalue phase2Ref9 = new ALocalLvalue(new TIdentifier(phase2Decl.GetName().Text));
            ALvalueExp phase2Ref1Exp = new ALvalueExp(phase2Ref1);
            ALvalueExp phase2Ref2Exp = new ALvalueExp(phase2Ref2);
            ALvalueExp phase2Ref4Exp = new ALvalueExp(phase2Ref4);
            ALvalueExp phase2Ref5Exp = new ALvalueExp(phase2Ref5);
            ALvalueExp phase2Ref7Exp = new ALvalueExp(phase2Ref7);
            ALvalueExp phase2Ref9Exp = new ALvalueExp(phase2Ref9);

            /*
                while(length > 0)
                {
                    if(phase2 == 0)
                    {
                        ch = StringSub(s, 1, 1);
                        s = StringReplace(s, "", 1, 1);
                    }
                    else
                    {
                        if(phase2 == 1)
                        {
                            ch = StringSub(s, length, length);
                            s = StringReplace(s, "", length, length);
                        }
                    }

                    if(phase1 == 0)
                    {
                        output = ch + output;
                    }
                    else
                    {
                        if(phase1 == 1)
                        {
                            output = StringSub(output, 1, (StringLength(output) + 1)/2) + ch + StringSub(output, (StringLength(output) + 1)/2 + 1, StringLength(output));
                        }
                        else
                        {
                            output = output + ch;
                        }
                    }
                    phase1 = phase1 - 1;
                    if(phase1 < 0)
                    {
                        phase1 = phase1 + 3;
                    }
                    phase2 = phase2 - 1;
                    if(phase2 < 0)
                    {
                        phase2 = phase2 + 2;
                    }
                    length = StringLength(s);
                }
             */

            AABlock whileBlock = new AABlock(new ArrayList(), new TRBrace("}"));
            AIntConstExp intConstWhileCond = new AIntConstExp(new TIntegerLiteral("0"));
            ABinopExp binopWhileCond = new ABinopExp(lengthRef3Exp, new AGtBinop(new TGt(">")), intConstWhileCond);
            methodBlock.GetStatements().Add(new AWhileStm(new TLParen("("), binopWhileCond,
                                                          new ABlockStm(new TLBrace("{"), whileBlock)));

            /*
                    if(phase2 == 0)
                    {
                        ch = StringSub(s, 1, 1);
                        s = StringReplace(s, "", 1, 1);
                    }
                    else
                    {
                        if(phase2 == 1)
                        {
                            ch = StringSub(s, length, length);
                            s = StringReplace(s, "", length, length);
                        }
                    }
             */
            AIntConstExp intConstIf1Cond = new AIntConstExp(new TIntegerLiteral("0"));
            ABinopExp binopIf1Cond = new ABinopExp(phase2Ref1Exp, new AEqBinop(new TEq("==")), intConstIf1Cond);
            AABlock thenBlock = new AABlock();
            AABlock elseBlock = new AABlock();
            whileBlock.GetStatements().Add(new AIfThenElseStm(new TLParen("("), binopIf1Cond,
                                                              new ABlockStm(new TLBrace("{"), thenBlock),
                                                              new ABlockStm(new TLBrace("{"), elseBlock)));

            //ch = StringSub(s, 1, 1);
            AIntConstExp intConst1 = new AIntConstExp(new TIntegerLiteral("1"));
            AIntConstExp intConst2 = new AIntConstExp(new TIntegerLiteral("1"));
            ASimpleInvokeExp invokeStringSub1 = new ASimpleInvokeExp(new TIdentifier("StringSub"),
                                                           new ArrayList() {stringParamRef2Exp, intConst1, intConst2});
            AAssignmentExp assignment1 = new AAssignmentExp(new TAssign("="), chRef1, invokeStringSub1);
            thenBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment1));

            //s = StringReplace(s, "", 1, 1);
            AIntConstExp intConst3 = new AIntConstExp(new TIntegerLiteral("1"));
            AIntConstExp intConst4 = new AIntConstExp(new TIntegerLiteral("1"));
            ASimpleInvokeExp invokeStringReplace1 = new ASimpleInvokeExp(new TIdentifier("StringReplace"),
                                                           new ArrayList() { stringParamRef4Exp, emptyStringRef2Exp, intConst3, intConst4 });
            AAssignmentExp assignment2 = new AAssignmentExp(new TAssign("="), stringParamRef3, invokeStringReplace1);
            thenBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment2));

            //if(phase2 == 1)
            AIntConstExp intConst5 = new AIntConstExp(new TIntegerLiteral("1"));
            ABinopExp binop1 = new ABinopExp(phase2Ref2Exp, new AEqBinop(new TEq("==")), intConst5);
            thenBlock = new AABlock();
            elseBlock.GetStatements().Add(new AIfThenStm(new TLParen("("), binop1,
                                                         new ABlockStm(new TLBrace("{"), thenBlock)));

            //ch = StringSub(s, length, length);
            ASimpleInvokeExp invokeStringSub2 = new ASimpleInvokeExp(new TIdentifier("StringSub"),
                                                           new ArrayList() { stringParamRef5Exp, lengthRef3Exp, lengthRef4Exp });
            AAssignmentExp assignment3 = new AAssignmentExp(new TAssign("="), chRef2, invokeStringSub2);
            thenBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment3));

            //s = StringReplace(s, "", length, length);
            ASimpleInvokeExp invokeStringReplace2 = new ASimpleInvokeExp(new TIdentifier("StringReplace"),
                                                           new ArrayList() { stringParamRef7Exp, emptyStringRef3Exp, lengthRef5Exp, lengthRef6Exp });
            AAssignmentExp assignment4 = new AAssignmentExp(new TAssign("="), stringParamRef6, invokeStringReplace2);
            thenBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment4));

            //if(phase1 == 0)
            AIntConstExp intConst6 = new AIntConstExp(new TIntegerLiteral("0"));
            ABinopExp binop2 = new ABinopExp(phase1Ref1Exp, new AEqBinop(new TEq("==")), intConst6);
            thenBlock = new AABlock();
            elseBlock = new AABlock();
            whileBlock.GetStatements().Add(new AIfThenElseStm(new TLParen("("), binop2,
                                                              new ABlockStm(new TLBrace("{"), thenBlock),
                                                              new ABlockStm(new TLBrace("{"), elseBlock)));

            //output = ch + output;
            ABinopExp binop3 = new ABinopExp(chRef3Exp, new APlusBinop(new TPlus("+")), outputRef2Exp);
            AAssignmentExp assignment5 = new AAssignmentExp(new TAssign("="), outputRef1, binop3);
            thenBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment5));

            //if(phase1 == 1)
            AABlock cBlock = elseBlock;
            AIntConstExp intConst7 = new AIntConstExp(new TIntegerLiteral("1"));
            ABinopExp binop4 = new ABinopExp(phase1Ref2Exp, new AEqBinop(new TEq("==")), intConst7);
            thenBlock = new AABlock();
            elseBlock = new AABlock();
            cBlock.GetStatements().Add(new AIfThenElseStm(new TLParen("("), binop4,
                                                              new ABlockStm(new TLBrace("{"), thenBlock),
                                                              new ABlockStm(new TLBrace("{"), elseBlock)));

            //output = StringSub(output, 1, (StringLength(output) + 1)/2) + ch + StringSub(output, (StringLength(output) + 1)/2 + 1, StringLength(output));
            AIntConstExp intConst8 = new AIntConstExp(new TIntegerLiteral("1"));
            AIntConstExp intConst9 = new AIntConstExp(new TIntegerLiteral("1"));
            AIntConstExp intConst10 = new AIntConstExp(new TIntegerLiteral("2"));
            AIntConstExp intConst11 = new AIntConstExp(new TIntegerLiteral("1"));
            AIntConstExp intConst12 = new AIntConstExp(new TIntegerLiteral("2"));
            AIntConstExp intConst13 = new AIntConstExp(new TIntegerLiteral("1"));

            ASimpleInvokeExp invokeStringLength1 = new ASimpleInvokeExp(new TIdentifier("StringLength"),
                                                                        new ArrayList() {outputRef5Exp});
            ABinopExp binop5 = new ABinopExp(invokeStringLength1, new APlusBinop(new TPlus("+")), intConst9);
            ABinopExp binop6 = new ABinopExp(binop5, new ADivideBinop(new TDiv("/")), intConst10);

            ASimpleInvokeExp invokeStringSub3 = new ASimpleInvokeExp(new TIdentifier("StringSub"),
                                                           new ArrayList() { outputRef4Exp, intConst8, binop6});

            ABinopExp binop7 = new ABinopExp(invokeStringSub3, new APlusBinop(new TPlus("+")), chRef4Exp);

            ASimpleInvokeExp invokeStringLength2 = new ASimpleInvokeExp(new TIdentifier("StringLength"),
                                                                        new ArrayList() { outputRef7Exp });
            ABinopExp binop8 = new ABinopExp(invokeStringLength2, new APlusBinop(new TPlus("+")), intConst11);
            ABinopExp binop9 = new ABinopExp(binop8, new ADivideBinop(new TDiv("/")), intConst12);
            ABinopExp binop10 = new ABinopExp(binop9, new APlusBinop(new TPlus("+")), intConst13);

            ASimpleInvokeExp invokeStringLength3 = new ASimpleInvokeExp(new TIdentifier("StringLength"),
                                                                        new ArrayList() { outputRef8Exp });

            ASimpleInvokeExp invokeStringSub4 = new ASimpleInvokeExp(new TIdentifier("StringSub"),
                                                           new ArrayList() { outputRef6Exp, binop10, invokeStringLength3 });

            ABinopExp binop11 = new ABinopExp(binop7, new APlusBinop(new TPlus("+")), invokeStringSub4);

            AAssignmentExp assignment6 = new AAssignmentExp(new TAssign("="), outputRef3, binop11);

            thenBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment6));

            //output = output + ch;
            ABinopExp binop12 = new ABinopExp(outputRef10Exp, new APlusBinop(new TPlus("+")), chRef5Exp);
            AAssignmentExp assignment7 = new AAssignmentExp(new TAssign("="), outputRef9, binop12);
            elseBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment7));

            //phase1 = phase1 - 1;
            AIntConstExp intConst14 = new AIntConstExp(new TIntegerLiteral("1"));
            ABinopExp binop13 = new ABinopExp(phase1Ref4Exp, new AMinusBinop(new TMinus("-")), intConst14);
            AAssignmentExp assignment8 = new AAssignmentExp(new TAssign("="), phase1Ref3, binop13);
            whileBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment8));

            //if(phase1 < 0)
            AIntConstExp intConst15 = new AIntConstExp(new TIntegerLiteral("0"));
            ABinopExp binop14 = new ABinopExp(phase1Ref5Exp, new ALtBinop(new TLt("<")), intConst15);
            thenBlock = new AABlock();
            whileBlock.GetStatements().Add(new AIfThenStm(new TLParen("("), binop14,
                                                         new ABlockStm(new TLBrace("{"), thenBlock)));

            //phase1 = phase1 + 3;
            AIntConstExp intConst16 = new AIntConstExp(new TIntegerLiteral("3"));
            ABinopExp binop15 = new ABinopExp(phase1Ref7Exp, new APlusBinop(new TPlus("+")), intConst16);
            AAssignmentExp assignment9 = new AAssignmentExp(new TAssign("="), phase1Ref6, binop15);
            thenBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment9));

            //phase2 = phase2 - 1;
            AIntConstExp intConst17 = new AIntConstExp(new TIntegerLiteral("1"));
            ABinopExp binop16 = new ABinopExp(phase2Ref4Exp, new AMinusBinop(new TMinus("-")), intConst17);
            AAssignmentExp assignment10 = new AAssignmentExp(new TAssign("="), phase2Ref3, binop16);
            whileBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment10));

            //if(phase2 < 0)
            AIntConstExp intConst18 = new AIntConstExp(new TIntegerLiteral("0"));
            ABinopExp binop17 = new ABinopExp(phase2Ref5Exp, new ALtBinop(new TLt("<")), intConst18);
            thenBlock = new AABlock();
            whileBlock.GetStatements().Add(new AIfThenStm(new TLParen("("), binop17,
                                                         new ABlockStm(new TLBrace("{"), thenBlock)));

            //phase2 = phase2 + 2;
            AIntConstExp intConst19 = new AIntConstExp(new TIntegerLiteral("2"));
            ABinopExp binop18 = new ABinopExp(phase2Ref7Exp, new APlusBinop(new TPlus("+")), intConst19);
            AAssignmentExp assignment11 = new AAssignmentExp(new TAssign("="), phase2Ref6, binop18);
            thenBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment11));

            //length = StringLength(s);
            ASimpleInvokeExp invokeStringLength4 = new ASimpleInvokeExp(new TIdentifier("StringLength"),
                                                                        new ArrayList() { stringParamRef8Exp });
            AAssignmentExp assignment12 = new AAssignmentExp(new TAssign("="), lengthRef8, invokeStringLength4);
            whileBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment12));

            /*
                phase1 = StringFind(output, ":", false);
                phase2 = StringToInt(StringSub(output, 1, phase1 - 1));
                return StringSub(output, phase1 + 1, phase2 + phase1);
             */

            ABooleanConstExp boolConst1 = new ABooleanConstExp(new AFalseBool());
            ASimpleInvokeExp invokeStringFind = new ASimpleInvokeExp(new TIdentifier("StringFind"),
                                                                     new ArrayList()
                                                                         {outputRef11Exp, colonStringRefExp, boolConst1});
            AAssignmentExp assignment13 = new AAssignmentExp(new TAssign("="), phase1Ref8, invokeStringFind);
            methodBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment13));

            //phase2 = StringToInt(StringSub(output, 1, phase1 - 1));
            AIntConstExp intConst20 = new AIntConstExp(new TIntegerLiteral("1"));
            AIntConstExp intConst21 = new AIntConstExp(new TIntegerLiteral("1"));
            ABinopExp binop19 = new ABinopExp(phase1Ref9Exp, new AMinusBinop(new TMinus("-")), intConst21);
            ASimpleInvokeExp invokeStringSub5 = new ASimpleInvokeExp(new TIdentifier("StringSub"),
                                                           new ArrayList() { outputRef12Exp, intConst20, binop19});
            ASimpleInvokeExp invokeStringToInt = new ASimpleInvokeExp(new TIdentifier("StringToInt"),
                                                                      new ArrayList() { invokeStringSub5 });
            AAssignmentExp assignment14 = new AAssignmentExp(new TAssign("="), phase2Ref8, invokeStringToInt);
            methodBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment14));

            //return StringSub(output, phase1 + 1, phase2 + phase1);
            AIntConstExp intConst22 = new AIntConstExp(new TIntegerLiteral("1"));
            ABinopExp binop20 = new ABinopExp(phase1Ref10Exp, new APlusBinop(new TPlus("+")), intConst22);
            ABinopExp binop21 = new ABinopExp(phase2Ref9Exp, new APlusBinop(new TPlus("+")), phase1Ref11Exp);
            ASimpleInvokeExp invokeStringSub6 = new ASimpleInvokeExp(new TIdentifier("StringSub"),
                                                           new ArrayList() { outputRef12Exp, binop20, binop21 });
            methodBlock.GetStatements().Add(new AValueReturnStm(new TReturn("return"), invokeStringSub6));

            AMethodDecl method = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null,
                                                 new ANamedType(new TIdentifier("string"), null),
                                                 new TIdentifier("Galaxypp_Deobfuscate"), new ArrayList() {stringParam},
                                                 methodBlock);

            //Fix data refferences.. I got tired here.

            return method;
        }
        private void MakeInitializerInvokes()
        {
            AABlock block = (AABlock) mainEntry.GetBlock();
            AASourceFile file = Util.GetAncestor<AASourceFile>(mainEntry);
            AMethodDecl invokeMethod;
            /* Add
             * void Invoke(string methodName)
             * {
             *     trigger initTrigger = TriggerCreate(methodName);
             *     TriggerExecute(initTrigger, false, true);
             *     TriggerDestroy(initTrigger);
             * }
             */

            {
                //void Invoke(string methodName)
                AALocalDecl parameter = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                        new ANamedType(new TIdentifier("string"), null),
                                                        new TIdentifier("methodName"), null);
                AABlock methodBody = new AABlock();
                invokeMethod = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null,
                                                     new AVoidType(new TVoid("void")), new TIdentifier("Invoke"),
                                                     new ArrayList(){parameter}, methodBody);

                //trigger initTrigger = TriggerCreate(methodName);
                ALocalLvalue parameterLvalue = new ALocalLvalue(new TIdentifier("methodName"));
                data.LocalLinks[parameterLvalue] = parameter;
                ALvalueExp parameterLvalueExp = new ALvalueExp(parameterLvalue);
                data.LvalueTypes[parameterLvalue] =
                    data.ExpTypes[parameterLvalueExp] = parameter.GetType();
                ASimpleInvokeExp invoke = new ASimpleInvokeExp(new TIdentifier("TriggerCreate"), new ArrayList(){parameterLvalueExp});
                data.ExpTypes[invoke] = new ANamedType(new TIdentifier("trigger"), null);
                foreach (AMethodDecl methodDecl in data.Libraries.Methods)
                {
                    if (methodDecl.GetName().Text == "TriggerCreate")
                    {
                        data.SimpleMethodLinks[invoke] = methodDecl;
                        break;
                    }
                }
                AALocalDecl initTriggerDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                        new ANamedType(new TIdentifier("trigger"), null),
                                                        new TIdentifier("initTrigger"), invoke);
                methodBody.GetStatements().Add(new ALocalDeclStm(new TSemicolon(";"), initTriggerDecl));

                //TriggerExecute(initTrigger, false, true);
                ALocalLvalue initTriggerLvalue = new ALocalLvalue(new TIdentifier("initTrigger"));
                data.LocalLinks[initTriggerLvalue] = initTriggerDecl;
                ALvalueExp initTriggerLvalueExp = new ALvalueExp(initTriggerLvalue);
                data.LvalueTypes[initTriggerLvalue] =
                    data.ExpTypes[initTriggerLvalueExp] = initTriggerDecl.GetType();
                ABooleanConstExp falseBool = new ABooleanConstExp(new AFalseBool());
                ABooleanConstExp trueBool = new ABooleanConstExp(new ATrueBool());
                data.ExpTypes[falseBool] =
                    data.ExpTypes[trueBool] = new ANamedType(new TIdentifier("bool"), null);
                invoke = new ASimpleInvokeExp(new TIdentifier("TriggerExecute"), new ArrayList() { initTriggerLvalueExp, falseBool, trueBool });
                data.ExpTypes[invoke] = new AVoidType(new TVoid("void"));
                foreach (AMethodDecl methodDecl in data.Libraries.Methods)
                {
                    if (methodDecl.GetName().Text == "TriggerExecute")
                    {
                        data.SimpleMethodLinks[invoke] = methodDecl;
                        break;
                    }
                }
                methodBody.GetStatements().Add(new AExpStm(new TSemicolon(";"), invoke));

                //TriggerDestroy(initTrigger);
                initTriggerLvalue = new ALocalLvalue(new TIdentifier("initTrigger"));
                data.LocalLinks[initTriggerLvalue] = initTriggerDecl;
                initTriggerLvalueExp = new ALvalueExp(initTriggerLvalue);
                data.LvalueTypes[initTriggerLvalue] =
                    data.ExpTypes[initTriggerLvalueExp] = initTriggerDecl.GetType();
                invoke = new ASimpleInvokeExp(new TIdentifier("TriggerDestroy"), new ArrayList() { initTriggerLvalueExp });
                data.ExpTypes[invoke] = new AVoidType(new TVoid("void"));
                foreach (AMethodDecl methodDecl in data.Libraries.Methods)
                {
                    if (methodDecl.GetName().Text == "TriggerDestroy")
                    {
                        data.SimpleMethodLinks[invoke] = methodDecl;
                        break;
                    }
                }
                methodBody.GetStatements().Add(new AExpStm(new TSemicolon(";"), invoke));

                file.GetDecl().Add(invokeMethod);
            }

            for (int i = data.InitializerMethods.Count - 1; i >= 0; i--)
            {
                AMethodDecl method = data.InitializerMethods[i];
                //Turn method into a trigger
                method.SetReturnType(new ANamedType(new TIdentifier("bool"), null));
                method.GetFormals().Add(new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                        new ANamedType(new TIdentifier("bool"), null),
                                                        new TIdentifier("testConds"), null));
                method.GetFormals().Add(new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                        new ANamedType(new TIdentifier("bool"), null),
                                                        new TIdentifier("runActions"), null));
                method.SetTrigger(new TTrigger("trigger"));
                ((AABlock) method.GetBlock()).GetStatements().Add(new AVoidReturnStm(new TReturn("return")));
                TriggerConvertReturn returnConverter = new TriggerConvertReturn(data);
                method.Apply(returnConverter);
                data.TriggerDeclarations[method] = new List<TStringLiteral>();

                //Add Invoke(<name>); to main entry
                TStringLiteral literal = new TStringLiteral(method.GetName().Text);
                data.TriggerDeclarations[method].Add(literal);
                AStringConstExp stringConst = new AStringConstExp(literal);
                data.ExpTypes[stringConst] = new ANamedType(new TIdentifier("string"), null);
                ASimpleInvokeExp invoke = new ASimpleInvokeExp(new TIdentifier("Invoke"), new ArrayList(){stringConst});
                data.SimpleMethodLinks[invoke] = invokeMethod;
                data.ExpTypes[invoke] = invokeMethod.GetReturnType();
                block.GetStatements().Insert(0, new AExpStm(new TSemicolon(";"), invoke));

                //ASyncInvokeExp syncInvokeExp = new ASyncInvokeExp(new TSyncInvoke("Invoke"), new AAmbiguousNameLvalue(new ASimpleName(new TIdentifier(method.GetName().Text))), new ArrayList());
                //data.Invokes.Add(method, new List<InvokeStm>(){new InvokeStm(syncInvokeExp)});
                //data.ExpTypes[syncInvokeExp] = new AVoidType(new TVoid("void"));

                //block.GetStatements().Insert(0, new AExpStm(new TSemicolon(";"), syncInvokeExp));
            }
            for (int i = data.InvokeOnIniti.Count - 1; i >= 0; i--)
            {
                AMethodDecl method = data.InvokeOnIniti[i];

                //Turn method into a trigger
                method.SetReturnType(new ANamedType(new TIdentifier("bool"), null));
                method.GetFormals().Add(new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                        new ANamedType(new TIdentifier("bool"), null),
                                                        new TIdentifier("testConds"), null));
                method.GetFormals().Add(new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                        new ANamedType(new TIdentifier("bool"), null),
                                                        new TIdentifier("runActions"), null));
                method.SetTrigger(new TTrigger("trigger"));
                ((AABlock)method.GetBlock()).GetStatements().Add(new AVoidReturnStm(new TReturn("return")));
                TriggerConvertReturn returnConverter = new TriggerConvertReturn(data);
                method.Apply(returnConverter);
                data.TriggerDeclarations[method] = new List<TStringLiteral>();

                //Add Invoke(<name>); to main entry
                TStringLiteral literal = new TStringLiteral(method.GetName().Text);
                data.TriggerDeclarations[method].Add(literal);
                AStringConstExp stringConst = new AStringConstExp(literal);
                data.ExpTypes[stringConst] = new ANamedType(new TIdentifier("string"), null);
                ASimpleInvokeExp invoke = new ASimpleInvokeExp(new TIdentifier("Invoke"), new ArrayList() { stringConst });
                data.SimpleMethodLinks[invoke] = invokeMethod;
                data.ExpTypes[invoke] = invokeMethod.GetReturnType();
                block.GetStatements().Insert(0, new AExpStm(new TSemicolon(";"), invoke));

                /*
                ASyncInvokeExp syncInvokeExp = new ASyncInvokeExp(new TSyncInvoke("Invoke"),  new AAmbiguousNameLvalue(new ASimpleName(new TIdentifier(method.GetName().Text))), new ArrayList());
                data.Invokes.Add(method, new List<InvokeStm>() { new InvokeStm(syncInvokeExp) });
                data.ExpTypes[syncInvokeExp] = new AVoidType(new TVoid("void"));

                block.GetStatements().Insert(0, new AExpStm(new TSemicolon(";"), syncInvokeExp));*/

            }
            for (int i = data.FieldsToInitInMapInit.Count - 1; i >= 0; i--)
            {
                AFieldDecl field = data.FieldsToInitInMapInit[i];
                if (field.GetInit() == null)
                    continue;

                AFieldLvalue lvalue = new AFieldLvalue(new TIdentifier(field.GetName().Text));
                AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), lvalue, field.GetInit());

                data.ExpTypes[assignment] =
                    data.LvalueTypes[lvalue] = field.GetType();
                data.FieldLinks[lvalue] = field;

                block.GetStatements().Insert(0, new AExpStm(new TSemicolon(";"), assignment));

            }
            block.RemoveChild(mainEntryFieldInitBlock);
            block.GetStatements().Insert(0, mainEntryFieldInitBlock);
        }