public override void OutAAProgram(AAProgram node) { if (multipleEntryCandidates.Count > 0) { finalTrans.errors.Add(new ErrorCollection.Error(multipleEntryCandidates[0], LocRM.GetString("ErrorText1"), multipleEntryCandidates.ToArray())); } }
public override void OutAAProgram(AAProgram node) { //First, analyze methods with no dependancies List<AMethodDecl> analyzedMethods = new List<AMethodDecl>(); while (true) { bool processedSomething = false; foreach (KeyValuePair<AMethodDecl, List<AMethodDecl>> pair in dependancies) { AMethodDecl method = pair.Key; if (analyzedMethods.Contains(method)) continue; bool hasDependancies = false; foreach (AMethodDecl dependancy in pair.Value) { if (!analyzedMethods.Contains(dependancy)) { hasDependancies = true; break; } } if (hasDependancies) continue; processedSomething = true; Analyze(method); analyzedMethods.Add(method); } if (analyzedMethods.Count == dependancies.Count) break; if (processedSomething) continue; //There is a cycle left. } }
public void Parse(AAProgram ast) { FindNullChecks finder = new FindNullChecks(data); ast.Apply(finder); ast.Apply(new Phase0(data)); //ast.Apply(new Phase0(data)); ast.Apply(new Phase2(data, finder.TypesWithIdentifierArray)); }
public static void Parse(AAProgram ast, ErrorCollection errors, SharedData data, out string rootFile) { FinalTransformations finalTrans = new FinalTransformations(errors, data); finalTrans.Apply(ast); AASourceFile rootSrcFile = Util.GetAncestor<AASourceFile>(finalTrans.mainEntry); if (rootSrcFile == null) rootFile = ""; else rootFile = rootSrcFile.GetName().Text + ".galaxy"; }
public override void OutAAProgram(AAProgram node) { //Remove all inits of struct fields foreach (AStructDecl str in data.Structs.Select(declItem => declItem.Decl)) { foreach (AALocalDecl localDecl in str.GetLocals().OfType<AALocalDecl>()) { localDecl.SetInit(null); } } base.OutAAProgram(node); }
public override void OutAAProgram(AAProgram node) { //Link stuff in delegates /* foreach (SharedData.DeclItem<AMethodDecl> declItem in data.Delegates) { //declItem.File.GetDecl().Add(declItem.Decl); declItem.Decl.Apply(this); //declItem.File.GetDecl().Remove(declItem.Decl); }*/ //Remove typedefs foreach (ATypedefDecl decl in data.Typedefs) { decl.Parent().RemoveChild(decl); } data.Typedefs.Clear(); base.OutAAProgram(node); }
public override void CaseAAProgram(AAProgram node) { /*decls.AddRange(finalTrans.data.Structs.Select(str => str.Decl)); decls.AddRange(finalTrans.data.Methods.Select(str => str.Decl)); decls.AddRange(finalTrans.data.Fields.Select(str => str.Decl)); if (finalTrans.data.Locals.Count > 0) decls.AddRange(finalTrans.data.Locals.Select(str => str.Value).Aggregate(Aggregate)); if (finalTrans.data.Structs.Count > 0) decls.AddRange(finalTrans.data.StructFields.Values.Aggregate(Aggregate));*/ base.CaseAAProgram(node); Random rand = new Random(); while (decls.Count > 0) { int i = rand.Next(decls.Count); Node n = decls[i]; decls.RemoveAt(i); if (n is AFieldDecl) { AFieldDecl an = (AFieldDecl) n; an.GetName().Text = nextName; } else if (n is AMethodDecl) { AMethodDecl an = (AMethodDecl)n; if (finalTrans.mainEntry == an || (an.GetTrigger() != null && finalTrans.data.HasUnknownTrigger)) continue; an.GetName().Text = nextName; } else if (n is AALocalDecl) { AALocalDecl an = (AALocalDecl)n; an.GetName().Text = nextName; } else if (n is AStructDecl) { AStructDecl an = (AStructDecl)n; an.GetName().Text = nextName; } NextName(); } }
public static void Parse(AAProgram ast, FinalTransformations finalTrans) { /* * Should be done in Pointers phase * foo == null > foo == "" || !DataTableExists(foo); * | foo == -1 || !inUse[foo] || GetIdentifier(foo) != foo->identifier * * * delete foo > delete foo; * foo = null; * * foo = null > foo = "" * | foo = -1 * * * This phase: * Add identifier to all structs and classes that are ever dynamically created * At any (*foo), analyze if foo can be null, and if so, create null check. * * Phase 1: Generate SafeVariablesData for all methods. * */ }
public static void Parse(AAProgram ast, ErrorCollection errors, SharedData data) { ast.Apply(new Weeder(errors, data)); }
public static void Apply(AAProgram ast, FinalTransformations finalTrans) { //Build list of file dependacies Phase1 phase1 = new Phase1(finalTrans); ast.Apply(phase1); var dependancies = phase1.dependancies; if (dependancies.Keys.Count == 0) return; AASourceFile root = Util.GetAncestor<AASourceFile>(finalTrans.mainEntry) ?? dependancies.Keys.FirstOrDefault(file => !file.GetName().Text.Contains("\\")) ?? dependancies.Keys.First(file => true); //Remove files unreachable from root //On second thought, dont. there might be static refferences the other way which needs to be included /*{ List<AASourceFile> reachable = GetReachable(root, dependancies); AASourceFile[] keys = new AASourceFile[dependancies.Count]; dependancies.Keys.CopyTo(keys, 0); foreach (AASourceFile key in keys) { if (!reachable.Contains(key)) dependancies.Remove(key); } }*/ //Push common depancies up /* * root -> (item1 -> (item3), item2 -> (item4 -> (item3))) * * root -> (item3, item1, item2 -> (item4)) */ //Add unreachable to the root while (true) { List<AASourceFile> reachable = new List<AASourceFile>(); GetReachable(root, dependancies, ref reachable); if (reachable.Count == dependancies.Count + (reachable.Contains(null) ? 1 : 0)) break; AASourceFile[] keys = new AASourceFile[dependancies.Count]; dependancies.Keys.CopyTo(keys, 0); foreach (AASourceFile key in keys) { if (!reachable.Contains(key)) { AASourceFile k = key; //See if you can find another unreachable file which need this file Dictionary<AASourceFile, int> decendantCounts = new Dictionary<AASourceFile, int>(); decendantCounts.Add(k, CountDecendants(k, dependancies, new List<AASourceFile>())); while (true) { AASourceFile file = null; foreach (KeyValuePair<AASourceFile, List<AASourceFile>> dependancy in dependancies) { if (decendantCounts.ContainsKey(dependancy.Key)) continue; if (!dependancy.Value.Contains(k)) continue; file = dependancy.Key; break; } //AASourceFile file = dependancies.FirstOrDefault(item => item.Value.Contains(k)).Key; if (file == null) break; decendantCounts.Add(file, CountDecendants(file, dependancies, new List<AASourceFile>())); k = file; } foreach (KeyValuePair<AASourceFile, int> decendantItem in decendantCounts) { if (decendantItem.Value > decendantCounts[k]) k = decendantItem.Key; } dependancies[root].Add(k); break; } } } //It is moved down here because cycles are not removed in unreachable RemoveCycles(root, dependancies, new List<AASourceFile> { root }); //Convert to tree to make it easier List<Item> allItems = new List<Item>(); IncludeItem rootIncludeItem = MakeTree(root, dependancies, allItems, null); bool[] removed = new bool[allItems.Count]; for (int i = 0; i < removed.Length; i++) removed[i] = false; int removedCount = 0; //Ensure that each include is only included one place for (int i = 0; i < allItems.Count; i++) { if (removed[i]) continue; IncludeItem item1 = (IncludeItem)allItems[i]; for (int j = i + 1; j < allItems.Count; j++) { if (removed[j]) continue; IncludeItem item2 = (IncludeItem)allItems[j]; if (item1.Current == item2.Current) { List<Item> path1 = item1.Path; List<Item> path2 = item2.Path; for (int k = 0; k < Math.Min(path1.Count, path2.Count); k++) { if (path1[k] != path2[k]) { int insertAt = Math.Min(path1[k - 1].Children.IndexOf(path1[k]), path2[k - 1].Children.IndexOf(path2[k])); item1.Parent.Children.Remove(item1); LinkedList<IncludeItem> toRemove = new LinkedList<IncludeItem>(); toRemove.AddLast(item2); while (toRemove.Count > 0) { IncludeItem item = toRemove.First.Value; toRemove.RemoveFirst(); item.Parent.Children.Remove(item); //allItems.Remove(item); removedCount++; removed[item.ListIndex] = true; foreach (IncludeItem child in item.Children) { toRemove.AddLast(child); } } //j--; path1[k - 1].Children.Insert(insertAt, item1); item1.Parent = path1[k - 1]; break; } } } } } List<Item> newAllItems = new List<Item>(allItems.Count - removedCount); for (int i = 0; i < allItems.Count; i++) if (!removed[i]) newAllItems.Add(allItems[i]); allItems = newAllItems; //Move the null node to nr [0] foreach (IncludeItem item in allItems) { if (item.Current == null) { int itemIndex = item.Parent.Children.IndexOf(item); Item item0 = item.Parent.Children[0]; item.Parent.Children[0] = item; item.Parent.Children[itemIndex] = item0; break; } } //Insert method decls and move structs & fields up as needed ast.Apply(new Phase2(finalTrans, allItems)); //Insert the headers in the files if (Options.Compiler.OneOutputFile) { //for (int i = 0; i < allItems.Count; i++) int i = 0; while (allItems.Count > 0) { if (allItems[i] is IncludeItem) { IncludeItem includeItem = (IncludeItem) allItems[i]; //Dont want the standard lib if (includeItem.Current == null) { i++; continue; } //If it has children with children, then pick another first if (includeItem.Children.Any(child => child.Children.Count > 0)) { i++; continue; } if (includeItem.Children.Count == 0) { if (includeItem.Parent == null) break; i++; continue; } i = 0; //Put all children into this while (includeItem.Children.Count > 0) { int childNr = includeItem.Children.Count - 1; allItems.Remove(includeItem.Children[childNr]); if (includeItem.Children[childNr] is FieldItem) { FieldItem aItem = (FieldItem)includeItem.Children[childNr]; Node node = aItem.FieldDecl; node.Parent().RemoveChild(node); includeItem.Current.GetDecl().Insert(0, node); } else if (includeItem.Children[childNr] is StructItem) { StructItem aItem = (StructItem)includeItem.Children[childNr]; Node node = aItem.StructDecl; node.Parent().RemoveChild(node); includeItem.Current.GetDecl().Insert(0, node); } else if (includeItem.Children[childNr] is MethodDeclItem) { MethodDeclItem aItem = (MethodDeclItem)includeItem.Children[childNr]; AMethodDecl aNode = new AMethodDecl(); if (aItem.RealDecl.GetStatic() != null) aNode.SetStatic(new TStatic("static")); aNode.SetReturnType(Util.MakeClone(aItem.RealDecl.GetReturnType(), finalTrans.data)); aNode.SetName(new TIdentifier(aItem.RealDecl.GetName().Text)); foreach (AALocalDecl formal in aItem.RealDecl.GetFormals()) { AALocalDecl clone = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, Util.MakeClone(formal.GetType(), finalTrans.data), new TIdentifier(formal.GetName().Text), null); aNode.GetFormals().Add(clone); } includeItem.Current.GetDecl().Insert(0, aNode); } else if (includeItem.Children[childNr] is IncludeItem) { IncludeItem aChild = (IncludeItem)includeItem.Children[childNr]; if (aChild.Current == null) { AIncludeDecl node = new AIncludeDecl(new TInclude("include"), new TStringLiteral("\"TriggerLibs/NativeLib\"")); includeItem.Current.GetDecl().Insert(0, node); } else { PDecl[] decls = new PDecl[aChild.Current.GetDecl().Count]; aChild.Current.GetDecl().CopyTo(decls, 0); for (int k = decls.Length - 1; k >= 0; k--) { includeItem.Current.GetDecl().Insert(0, decls[k]); } aChild.Current.Parent().RemoveChild(aChild.Current); //i = -1; } } includeItem.Children.RemoveAt(childNr); } } } } else foreach (IncludeItem includeItem in allItems.OfType<IncludeItem>()) { for (int i = includeItem.Children.Count - 1; i >= 0; i--) { Node node; if (includeItem.Children[i] is IncludeItem) { IncludeItem aItem = (IncludeItem) includeItem.Children[i]; node = new AIncludeDecl(new TInclude("include"), new TStringLiteral("\"" + (aItem.Current == null ? "TriggerLibs/NativeLib" : aItem.Current.GetName().Text.Replace("\\", "/")) + "\"")); if (aItem.Current == null && finalTrans.mainEntry != null) { //Search for user defined initlib bool foundInvoke = false; foreach (ASimpleInvokeExp invokeExp in finalTrans.data.SimpleMethodLinks.Keys) { if(invokeExp.GetName().Text == "libNtve_InitLib" && invokeExp.GetArgs().Count == 0) { /*finalTrans.errors.Add(new ErrorCollection.Error(invokeExp.GetName(), Util.GetAncestor<AASourceFile>( invokeExp), "You are invoking libNtve_InitLib() yourself somewhere. It will not be auto inserted.", true));*/ foundInvoke = true; break; } } if (!foundInvoke) { //Init the lib ASimpleInvokeExp initExp = new ASimpleInvokeExp(); initExp.SetName(new TIdentifier("libNtve_InitLib")); finalTrans.data.ExpTypes[initExp] = new AVoidType(new TVoid("void")); foreach (AMethodDecl method in finalTrans.data.Libraries.Methods) { if (method.GetName().Text == "libNtve_InitLib" && method.GetFormals().Count == 0) { finalTrans.data.SimpleMethodLinks[initExp] = method; } } AABlock block = (AABlock) finalTrans.mainEntry.GetBlock(); block.GetStatements().Insert(0, new AExpStm(new TSemicolon(";"), initExp)); } } } else if (includeItem.Children[i] is FieldItem) { FieldItem aItem = (FieldItem)includeItem.Children[i]; node = aItem.FieldDecl; node.Parent().RemoveChild(node); } else if (includeItem.Children[i] is StructItem) { StructItem aItem = (StructItem)includeItem.Children[i]; node = aItem.StructDecl; node.Parent().RemoveChild(node); } else if (includeItem.Children[i] is MethodDeclItem) { MethodDeclItem aItem = (MethodDeclItem)includeItem.Children[i]; AMethodDecl aNode = new AMethodDecl(); if (aItem.RealDecl.GetStatic() != null) aNode.SetStatic(new TStatic("static")); aNode.SetReturnType(Util.MakeClone(aItem.RealDecl.GetReturnType(), finalTrans.data)); aNode.SetName(new TIdentifier(aItem.RealDecl.GetName().Text)); foreach (AALocalDecl formal in aItem.RealDecl.GetFormals()) { AALocalDecl clone = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, Util.MakeClone(formal.GetType(), finalTrans.data), new TIdentifier(formal.GetName().Text), null); aNode.GetFormals().Add(clone); } node = aNode; } else throw new Exception("FixIncludes.Apply: Unexpected item type"); includeItem.Current.GetDecl().Insert(0, node); } } }
public virtual void OutAAProgram(AAProgram node) { DefaultOut(node); }
public virtual void InAAProgram(AAProgram node) { DefaultIn(node); }
public override void InAAProgram(AAProgram node) { LocalChecker.CalculateMethodModify(node, data, out methodCount); }
public override void CaseAAProgram(AAProgram node) { if (Options.Compiler.ObfuscateStrings) base.CaseAAProgram(node); }
internal SourceFiles_Cast(AAProgram obj) { this.obj = obj; }
public override void OutAAProgram(AAProgram node) { foreach (var pair in Refferences) { if (structsWithGenerics.Contains(pair.Key) && pair.Value.Count > 0) needAnotherPass = true; } foreach (var pair in Refferences) { AStructDecl str = pair.Key; if (!copies.ContainsKey(str)) copies[str] = new List<List<PType>>(); IList declList; Node parent = str.Parent(); if (parent is AASourceFile) declList = ((AASourceFile)parent).GetDecl(); else declList = ((ANamespaceDecl)parent).GetDecl(); //AASourceFile pFile = (AASourceFile) str.Parent(); foreach (AGenericType refference in pair.Value) { AStructDecl clone = null; bool addList = true; foreach (List<PType> list in copies[str]) { bool listEqual = true; for (int i = 0; i < list.Count; i++) { if (!Util.TypesEqual(list[i], (PType) refference.GetGenericTypes()[i], data)) { listEqual = false; break; } } if (listEqual) { addList = false; clone = clones[list]; break; } } if (addList) { List<PType> list = new List<PType>(); foreach (PType type in refference.GetGenericTypes()) { list.Add(type); } copies[str].Add(list); clone = (AStructDecl)str.Clone(); declList.Insert(declList.IndexOf(str), clone); clone.Apply(new EnviromentBuilding(errors, data)); clone.Apply(new EnviromentChecking(errors, data, false)); clone.Apply(new LinkNamedTypes(errors, data)); /* data.Structs.Add(new SharedData.DeclItem<AStructDecl>(pFile, clone)); data.StructFields[clone] = new List<AALocalDecl>(); data.StructMethods[clone] = new List<AMethodDecl>(); data.StructProperties[clone] = new List<APropertyDecl>(); data.StructConstructors[clone] = new List<AConstructorDecl>(); foreach (PLocalDecl localDecl in clone.GetLocals()) { if (localDecl is AALocalDecl) { data.StructFields[clone].Add((AALocalDecl)localDecl); } else { PDecl decl = ((ADeclLocalDecl) localDecl).GetDecl(); if (decl is AMethodDecl) { data.StructMethods[clone].Add((AMethodDecl) decl); } else if (decl is APropertyDecl) { data.StructProperties[clone].Add((APropertyDecl)decl); } else { data.StructConstructors[clone].Add((AConstructorDecl) decl); } } }*/ clones[list] = clone; clone.setGenericVars(new ArrayList()); FixGenericLinks.Parse(str, clone, list, data); clone.GetName().Text = Util.TypeToIdentifierString(refference); } //Change refference to clone ANamedType baseRef = (ANamedType) refference.GetBase(); List<string> cloneNs = Util.GetFullNamespace(clone); cloneNs.Add(clone.GetName().Text); AAName aName = (AAName) baseRef.GetName(); aName.GetIdentifier().Clear(); foreach (var n in cloneNs) { aName.GetIdentifier().Add(new TIdentifier(n)); } data.StructTypeLinks[baseRef] = clone; refference.ReplaceBy(baseRef); } if (!needAnotherPass) parent.RemoveChild(str); } if (needAnotherPass) { Refferences.Clear(); structsWithGenerics.Clear(); needAnotherPass = false; CaseAAProgram(node); } }
public override void OutAAProgram(AAProgram node) { List<ALocalLvalue> deleteUs = new List<ALocalLvalue>(); foreach (KeyValuePair<ALocalLvalue, AALocalDecl> pair in finalTrans.data.LocalLinks) { if (!Util.HasAncestor<AAProgram>(pair.Key)) deleteUs.Add(pair.Key); } foreach (ALocalLvalue lvalue in deleteUs) { finalTrans.data.LocalLinks.Remove(lvalue); } }
public override void OutAAProgram(AAProgram node) { List<AMethodDecl> checkedMethods = new List<AMethodDecl>(); List<AMethodDecl> path = new List<AMethodDecl>(); //Check that we dont have an inline method cycle foreach (KeyValuePair<AMethodDecl, List<AMethodDecl>> inlineMethodCall in InlineMethodCalls) { CheckInlineMethod(inlineMethodCall.Key, checkedMethods, path); } //Check that we dont have a struct dependancy cycle List<AStructDecl> checkedStructs = new List<AStructDecl>(); List<AStructDecl> structPath = new List<AStructDecl>(); foreach (KeyValuePair<AStructDecl, List<AStructDecl>> structDepandancy in StructDepandancies) { CheckStructDependancies(structDepandancy.Key, checkedStructs, structPath); } }
public static void Parse(AAProgram ast, ErrorCollection errors, SharedData data) { ast.Apply(new TypeChecking(errors, data)); }
public static void Parse(AAProgram ast, ErrorCollection errors, SharedData data) { ast.Apply(new EnviromentBuilding(errors, data)); }
public static void Parse(AAProgram ast, ErrorCollection errors, SharedData data, DirectoryInfo outputDir) { ast.Apply(new CodeGeneration(errors, data, outputDir)); }
public override void InAAProgram(AAProgram node) { node.Apply(new BlockFixer(data)); }
public override void OutAAProgram(AAProgram node) { foreach (KeyValuePair<AArrayLengthLvalue, AArrayTempType> pair in data.ArrayLengthTypes) { AIntConstExp intConst = new AIntConstExp(new TIntegerLiteral(pair.Value.GetIntDim().Text)); data.ExpTypes[intConst] = new ANamedType(new TIdentifier("int"), null); ALvalueExp exp = Util.GetAncestor<ALvalueExp>(pair.Key); exp.ReplaceBy(intConst); } base.OutAAProgram(node); }
public override void InAAProgram(AAProgram node) { return; //Check that there are not two diffrent definitions with same name, in same namespace for (int i = 0; i < node.GetSourceFiles().Count; i++) { for (int j = i; j < node.GetSourceFiles().Count; j++) { AASourceFile file1 = (AASourceFile) node.GetSourceFiles()[i]; AASourceFile file2 = (AASourceFile) node.GetSourceFiles()[j]; Check(new List<IList>() {file1.GetDecl()}, new List<IList>() {file2.GetDecl()}); } } }
public override void OutAAProgram(AAProgram node) { List<IDecl> decls = new List<IDecl>(this.decls.Count); decls.AddRange(this.decls); bool changes; do { decls.Sort(Compare); changes = false; for (int i = 0; i < decls.Count; i++ ) { int j = i + 1; for (; j < decls.Count; j++) { if (Compare(decls[i], decls[j]) != 0) break; } if (j - i > 1) {//The same from i to j-1 bool sameType = true; for (int k = i + 1; k < j; k++) if (decls[i].GetType() != decls[k].GetType()) { //We have diffrent types. Add letter sameType = false; for (k = i; k < j; k++) decls[k].AddStandardLetter(); break; } //Now, add numbers if they are still the same if (sameType) { for (int k = i; k < j; k++) { decls[k].Name += k - i + 1; } } i = j - 1; changes = true; } } } while (changes); List<IDecl> localDecls = new List<IDecl>(this.localDecls.Count); localDecls.AddRange(this.localDecls); do { localDecls.Sort(Compare); changes = false; for (int i = 0; i < localDecls.Count; i++) { int j = i + 1; for (; j < localDecls.Count; j++) { if (Compare(localDecls[i], localDecls[j]) != 0) break; } if (j - i > 1) {//The same from i to j-1 bool sameType = true; for (int k = i + 1; k < j; k++) if (localDecls[i].GetType() != localDecls[k].GetType()) { //We have diffrent types. Add letter sameType = false; for (k = i; k < j; k++) localDecls[k].AddStandardLetter(); break; } //Now, add numbers if they are still the same if (sameType) { for (int k = i; k < j; k++) { localDecls[k].Name += k - i + 1; } } i = j - 1; changes = true; } } } while (changes); }
public override void CaseAAProgram(AAProgram node) { InAAProgram(node); { Object[] temp = new Object[node.GetSourceFiles().Count]; node.GetSourceFiles().CopyTo(temp, 0); for (int i = temp.Length - 1; i >= 0; i--) { ((PSourceFile)temp[i]).Apply(this); } } OutAAProgram(node); }
public override void OutAAProgram(AAProgram node) { if (strings.Count == 0) return; //Obfuscate all strings List<string> obfuscated = new List<string>(); foreach (AStringConstExp stringConstExp in strings) { TStringLiteral token = stringConstExp.GetStringLiteral(); string s = token.Text.Substring(1, token.Text.Length - 2); obfuscated.Add(Obfuscate(s)); } //Set invokes instead of string constants, and move varaiabes down List<AFieldDecl> ignoredFields = new List<AFieldDecl>(); List<AFieldDecl> moveFieldsIn = new List<AFieldDecl>(); Dictionary<AFieldDecl, AMethodDecl> fieldMethods = new Dictionary<AFieldDecl, AMethodDecl>(); for (int i = 0; i < strings.Count; i++) { AStringConstExp stringExp = strings[i]; Token token = stringExp.GetStringLiteral(); bool inDeobfuscator = Util.GetAncestor<AMethodDecl>(stringExp) == finalTrans.data.DeobfuscateMethod; if (inDeobfuscator) { AFieldDecl field = finalTrans.data.UnobfuscatedStrings[stringExp]; AStringConstExp newStringConst = new AStringConstExp(stringExp.GetStringLiteral()); field.SetInit(newStringConst); AFieldLvalue fieldRef = new AFieldLvalue(new TIdentifier(field.GetName().Text, token.Line, token.Pos)); finalTrans.data.FieldLinks[fieldRef] = field; stringExp.ReplaceBy(new ALvalueExp(fieldRef)); } else { AFieldDecl field; if (!finalTrans.data.ObfuscatedStrings.ContainsKey(stringExp)) { int line = -finalTrans.data.ObfuscatedStrings.Count - 1; field = new AFieldDecl(new APublicVisibilityModifier(), null, new TConst("const", line, 0), new ANamedType(new TIdentifier("string", line, 1), null), new TIdentifier("Galaxy_pp_stringO" + finalTrans.data.ObfuscatedStrings.Count), null); //If the strings are the same - point them to same field bool newField = true; foreach (AStringConstExp oldStringConstExp in finalTrans.data.ObfuscatedStrings.Keys) { if (stringExp.GetStringLiteral().Text == oldStringConstExp.GetStringLiteral().Text) { field = finalTrans.data.ObfuscatedStrings[oldStringConstExp]; newField = false; break; } } if (newField) { AASourceFile file = (AASourceFile)finalTrans.data.DeobfuscateMethod.Parent(); file.GetDecl().Insert(file.GetDecl().IndexOf(finalTrans.data.DeobfuscateMethod) + 1, field); finalTrans.data.Fields.Add(new SharedData.DeclItem<AFieldDecl>(file, field)); } finalTrans.data.ObfuscatedStrings.Add(stringExp, field); } field = finalTrans.data.ObfuscatedStrings[stringExp]; string obfuscatedString = obfuscated[i]; ASimpleInvokeExp invoke = new ASimpleInvokeExp(); invoke.SetName(new TIdentifier(finalTrans.data.DeobfuscateMethod.GetName().Text, stringExp.GetStringLiteral().Line, stringExp.GetStringLiteral().Pos)); AStringConstExp newStringConst = new AStringConstExp(new TStringLiteral("\"" + obfuscatedString + "\"")); invoke.GetArgs().Add(newStringConst); finalTrans.data.SimpleMethodLinks[invoke] = finalTrans.data.DeobfuscateMethod; if (Util.GetAncestor<PStm>(stringExp) == null && false) { ignoredFields.Add(field); /*if (Util.GetAncestor<ASimpleInvokeExp>(stringExp) == null) stringExp.ReplaceBy(invoke);*/ //Add obfuscate call to this location); continue; /*ASimpleInvokeExp invoke = new ASimpleInvokeExp(); invoke.SetName(new TIdentifier(finalTrans.data.DeobfuscateMethod.GetName().Text, stringExp.GetStringLiteral().Line, stringExp.GetStringLiteral().Pos)); AStringConstExp newStringConst = new AStringConstExp(new TStringLiteral("\"" + obfuscatedString + "\"")); invoke.GetArgs().Add(newStringConst); stringExp.ReplaceBy(invoke); finalTrans.data.SimpleMethodLinks[invoke] = finalTrans.data.DeobfuscateMethod; continue;*/ } if (field.GetInit() == null) { /*field.SetInit(invoke); field.SetConst(null);*/ if ( stringExp.GetStringLiteral().Text.Remove(0, 1).Substring(0, stringExp.GetStringLiteral().Text. Length - 2) == "") { //Make method /* string <field>Method() { return ""; } * */ ANullExp nullExp = new ANullExp(); field.SetInit(nullExp); field.SetConst(null); AStringConstExp stringConst = new AStringConstExp(new TStringLiteral("\"\"")); AMethodDecl method = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null, new ANamedType(new TIdentifier("string"), null), new TIdentifier("Get" + field.GetName()), new ArrayList(), new AABlock( new ArrayList() { new AValueReturnStm(new TReturn("return"), stringConst) }, new TRBrace("}"))); AASourceFile pFile = (AASourceFile)field.Parent(); pFile.GetDecl().Insert(pFile.GetDecl().IndexOf(field) + 1, method); finalTrans.data.ExpTypes[stringConst] = new ANamedType(new TIdentifier("string"), null); finalTrans.data.ExpTypes[nullExp] = new ANamedType(new TIdentifier("null"), null); fieldMethods[field] = method; } else { //Make method /* string <field>Method() { if (field == null) { field = Invoke; } if (field == null) { return Invoke; } return field; } */ ANullExp nullExp1 = new ANullExp(); field.SetInit(nullExp1); field.SetConst(null); ANullExp nullExp2 = new ANullExp(); AFieldLvalue fieldRef1 = new AFieldLvalue(new TIdentifier(field.GetName().Text)); AFieldLvalue fieldRef2 = new AFieldLvalue(new TIdentifier(field.GetName().Text)); AFieldLvalue fieldRef3 = new AFieldLvalue(new TIdentifier(field.GetName().Text)); ALvalueExp fieldRef1Exp = new ALvalueExp(fieldRef1); ALvalueExp fieldRef3Exp = new ALvalueExp(fieldRef3); ABinopExp binop1 = new ABinopExp(fieldRef1Exp, new AEqBinop(new TEq("==")), nullExp2); AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), fieldRef2, invoke); AIfThenStm ifStm1 = new AIfThenStm(new TLParen("("), binop1, new ABlockStm(new TLBrace("{"), new AABlock( new ArrayList() { new AExpStm(new TSemicolon(";"), assignment) }, new TRBrace("}")))); /*ANullExp nullExp3 = new ANullExp(); AFieldLvalue fieldRef4 = new AFieldLvalue(new TIdentifier(field.GetName().Text)); ALvalueExp fieldRef4Exp = new ALvalueExp(fieldRef4); AStringConstExp invokeArgClone = new AStringConstExp(new TStringLiteral("\"" + obfuscatedString + "\"")); ASimpleInvokeExp invokeClone = new ASimpleInvokeExp(new TIdentifier(invoke.GetName().Text), new ArrayList() { invokeArgClone }); finalTrans.data.SimpleMethodLinks[invokeClone] = finalTrans.data.DeobfuscateMethod; ABinopExp binop2 = new ABinopExp(fieldRef4Exp, new AEqBinop(new TEq("==")), nullExp3); AIfThenStm ifStm2 = new AIfThenStm(new TLParen("("), binop2, new ABlockStm(new TLBrace("{"), new AABlock( new ArrayList() { new AValueReturnStm(new TReturn("return"), invokeClone) }, new TRBrace("}"))));*/ AMethodDecl method = new AMethodDecl(new APublicVisibilityModifier(), null, null, null, null, null, new ANamedType(new TIdentifier("string"), null), new TIdentifier("Get" + field.GetName()), new ArrayList(), new AABlock( new ArrayList() { ifStm1, //ifStm2, new AValueReturnStm(new TReturn("return"), fieldRef3Exp) }, new TRBrace("}"))); AASourceFile pFile = (AASourceFile) field.Parent(); pFile.GetDecl().Insert(pFile.GetDecl().IndexOf(field) + 1, method); finalTrans.data.FieldLinks[fieldRef1] = finalTrans.data.FieldLinks[fieldRef2] = finalTrans.data.FieldLinks[fieldRef3] = /*finalTrans.data.FieldLinks[fieldRef4] = */field; finalTrans.data.LvalueTypes[fieldRef1] = finalTrans.data.LvalueTypes[fieldRef2] = finalTrans.data.LvalueTypes[fieldRef3] = //finalTrans.data.LvalueTypes[fieldRef4] = finalTrans.data.ExpTypes[fieldRef1Exp] = finalTrans.data.ExpTypes[fieldRef3Exp] = //finalTrans.data.ExpTypes[fieldRef4Exp] = finalTrans.data.ExpTypes[assignment] = field.GetType(); finalTrans.data.ExpTypes[nullExp1] = finalTrans.data.ExpTypes[nullExp2] = /*finalTrans.data.ExpTypes[nullExp3] =*/ new ANamedType(new TIdentifier("null"), null); finalTrans.data.ExpTypes[binop1] = /*finalTrans.data.ExpTypes[binop2] = */new ANamedType(new TIdentifier("bool"), null); fieldMethods[field] = method; } /* AFieldLvalue fieldRef = new AFieldLvalue(new TIdentifier(field.GetName().Text, token.Line, token.Pos)); finalTrans.data.FieldLinks[fieldRef] = field;*/ //stringExp.ReplaceBy(new ALvalueExp(fieldRef)); } ASimpleInvokeExp invoke2 = new ASimpleInvokeExp(new TIdentifier(fieldMethods[field].GetName().Text), new ArrayList()); finalTrans.data.SimpleMethodLinks[invoke2] = fieldMethods[field]; stringExp.ReplaceBy(invoke2); //If we are in a field, move it in if (Util.GetAncestor<AFieldDecl>(invoke2) != null) moveFieldsIn.Add(Util.GetAncestor<AFieldDecl>(invoke2)); } } foreach (AFieldDecl field in finalTrans.data.ObfuscationFields) { if (field.GetInit() == null && field.Parent() != null) { field.Parent().RemoveChild(field); } } //A constant field, or a field used by a constant field cannot be moved in List<AFieldDecl> constantFields = new List<AFieldDecl>(); foreach (SharedData.DeclItem<AFieldDecl> field in finalTrans.data.Fields) { if (field.Decl.GetConst() != null) constantFields.Add(field.Decl); } for (int i = 0; i < constantFields.Count; i++) { GetFieldLvalues lvalues = new GetFieldLvalues(); constantFields[i].Apply(lvalues); foreach (AFieldLvalue lvalue in lvalues.Lvalues) { AFieldDecl field = finalTrans.data.FieldLinks[lvalue]; if (!constantFields.Contains(field)) constantFields.Add(field); } } moveFieldsIn.RemoveAll(constantFields.Contains); Dictionary<AFieldDecl, List<AFieldDecl>> dependancies = new Dictionary<AFieldDecl, List<AFieldDecl>>(); //Order the fields so any dependancies are instansiated first foreach (AFieldDecl field in moveFieldsIn) { dependancies.Add(field, new List<AFieldDecl>()); GetFieldLvalues lvalues = new GetFieldLvalues(); field.Apply(lvalues); foreach (AFieldLvalue lvalue in lvalues.Lvalues) { AFieldDecl dependancy = finalTrans.data.FieldLinks[lvalue]; if (!dependancies[field].Contains(dependancy)) dependancies[field].Add(dependancy); } } List<PStm> newStatements = new List<PStm>(); while (dependancies.Keys.Count > 0) { AFieldDecl field = dependancies.FirstOrDefault(f1 => f1.Value.Count == 0).Key ?? dependancies.Keys.First(f => true); AFieldLvalue fieldRef = new AFieldLvalue(new TIdentifier(field.GetName().Text)); AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), fieldRef, field.GetInit()); field.SetInit(null); newStatements.Add(new AExpStm(new TSemicolon(";"), assignment)); finalTrans.data.FieldLinks[fieldRef] = field; finalTrans.data.LvalueTypes[fieldRef] = finalTrans.data.ExpTypes[assignment] = field.GetType(); foreach (KeyValuePair<AFieldDecl, List<AFieldDecl>> dependancy in dependancies) { if (dependancy.Value.Contains(field)) dependancy.Value.Remove(field); } dependancies.Remove(field); } AABlock initBody = (AABlock) finalTrans.mainEntry.GetBlock(); for (int i = newStatements.Count - 1; i >= 0; i--) { initBody.GetStatements().Insert(0, newStatements[i]); } }
public virtual void CaseAAProgram(AAProgram node) { DefaultCase(node); }
public static void CalculateMethodModify(AAProgram ast, SharedData data, out int methodCount) { //Calculate what global variables all methods might modify. methodData.Clear(); GetDependancies dependancies = new GetDependancies(data); ast.Apply(dependancies); methodCount = dependancies.UsedMethods.Count; while (dependancies.UsedMethods.Count > 0) { LinkedList<AMethodDecl> modified = new LinkedList<AMethodDecl>(); foreach (var pair in dependancies.UsedMethods) { AMethodDecl method = pair.Key; List<AMethodDecl> usedMethods = pair.Value; ModifyData modifyData = new ModifyData(); foreach (AFieldDecl fieldDecl in dependancies.ReadFields[method]) { modifyData.Add(fieldDecl, true, false); } foreach (AFieldDecl fieldDecl in dependancies.WrittenFields[method]) { modifyData.Add(fieldDecl, false, true); } bool skip = false; foreach (AMethodDecl usedMethod in usedMethods) { ModifyData usedData = GetModifyData(usedMethod); if (usedData == null) { skip = true; break; } modifyData.Union(usedData); } if (skip) continue; methodData[method] = modifyData; modified.AddLast(method); } foreach (AMethodDecl decl in modified) { dependancies.UsedMethods.Remove(decl); dependancies.ReadFields.Remove(decl); dependancies.WrittenFields.Remove(decl); } if (modified.Count == 0) {//The rest is in a circular dependancy foreach (var pair in dependancies.UsedMethods) { AMethodDecl method = pair.Key; ModifyData modifyData = new ModifyData(); Update(method, new List<AMethodDecl>(), modifyData, dependancies.UsedMethods, dependancies.ReadFields, dependancies.WrittenFields); methodData[method] = modifyData; modified.AddLast(method); } dependancies.UsedMethods.Clear(); } } }
public override void OutAAProgram(AAProgram node) { foreach (ANamedType type in finalTrans.data.DelegateTypeLinks.Keys) { type.SetPrimitive("string"); } base.OutAAProgram(node); }