public static Assembly FromAIN(string path) { Assembly asm = new Assembly(); System.IO.FileStream fs = new System.IO.FileStream(path, System.IO.FileMode.Open); System.IO.BinaryReader br = new System.IO.BinaryReader(fs); fs.Position = 8; uint size = br.ReadUInt32(); uint compressedSize = br.ReadUInt32(); byte[] buf; byte[] dst = new byte[size]; buf = br.ReadBytes((int)compressedSize); fixed (byte* ptr = buf) { fixed (byte* ptr2 = dst) { uncompress(ptr2, &size, ptr, compressedSize); } } fs.Close(); System.IO.MemoryStream ms = new System.IO.MemoryStream(dst); br = new System.IO.BinaryReader(ms); while (ms.Position < ms.Length) { string trunk = Encoding.ASCII.GetString(br.ReadBytes(4)); switch (trunk) { case "VERS": asm.Version = br.ReadInt32(); if (asm.Version != 6) { throw new NotSupportedException("本SDK仅支持版本为:6的反编译"); } break; case "KEYC": asm.Keyc = br.ReadInt32(); break; case "CODE": asm.CodeBuffer = br.ReadBytes(br.ReadInt32()); break; case "FUNC": { int count = br.ReadInt32(); for (int i = 0; i < count; i++) { Function func = new Function(); func.Address = br.ReadInt32(); func.Assembly = asm; func.Name = ReadString(br); func.U1 = br.ReadInt32(); func.ReturnType = (VarTypes)br.ReadInt32(); func.StructID = br.ReadInt32(); func.ArgCount = br.ReadInt32(); func.TotalLocalCount = br.ReadInt32(); func.U4 = br.ReadInt32(); for (int j = 0; j < func.TotalLocalCount; j++) { Variable arg = new Variable(); arg.Name = ReadString(br); arg.Assembly = asm; arg.VarType = (VarTypes)br.ReadInt32(); arg.StructID = br.ReadInt32(); arg.Dimension = br.ReadInt32(); if (j < func.ArgCount) func.Arguments.Add(arg); func.LocalVariables.Add(arg); } asm.Functions.Add(func); } } break; case "GLOB": { int count = br.ReadInt32(); for (int i = 0; i < count; i++) { Variable var = new Variable(); var.Name = ReadString(br); var.Assembly = asm; var.VarType = (VarTypes)br.ReadInt32(); var.StructID = br.ReadInt32(); var.Dimension = br.ReadInt32(); var.U3 = br.ReadInt32(); asm.global.Add(var); } } break; case "GSET": { int count = br.ReadInt32(); for (int i = 0; i < count; i++) { Variable var = asm.global[br.ReadInt32()]; VarTypes type = (VarTypes)br.ReadInt32(); switch (type) { case VarTypes.Float: var.FloatVal = br.ReadSingle(); break; case VarTypes.String: var.StringVal = ReadString(br); break; case VarTypes.Bool: var.BoolVal = br.ReadInt32() == 1; break; default: var.IntVal = br.ReadInt32(); break; } } } break; case "STRT": { int count = br.ReadInt32(); for (int i = 0; i < count; i++) { Struct str = new Struct(); str.Name = ReadString(br); int func = br.ReadInt32(); if (func != -1) str.Constructor = asm.func[func]; func = br.ReadInt32(); if (func != -1) str.Destructor = asm.func[func]; str.VarCount = br.ReadInt32(); for (int j = 0; j < str.VarCount; j++) { Variable arg = new Variable(); arg.Name = ReadString(br); arg.Assembly = asm; arg.VarType = (VarTypes)br.ReadInt32(); arg.StructID = br.ReadInt32(); arg.Dimension = br.ReadInt32(); str.Variables.Add(arg); } asm.structs.Add(str); } } break; case "MSG0": { int count = br.ReadInt32(); for (int i = 0; i < count; i++) { asm.msgs.Add(ReadString(br)); } } break; case "MAIN": asm.EntryPoint = asm.func[br.ReadInt32()]; break; case "MSGF": asm.MessageFunction = asm.func[br.ReadInt32()]; break; case "HLL0": { int count = br.ReadInt32(); for (int i = 0; i < count; i++) { string name = ReadString(br); Hll hll = new Hll(); hll.Name = name; int count2 = br.ReadInt32(); for (int j = 0; j < count2; j++) { Function func = new Function(); func.Name = ReadString(br); func.ReturnType = (VarTypes)br.ReadInt32(); func.TotalLocalCount = br.ReadInt32(); func.ArgCount = func.TotalLocalCount; for (int k = 0; k < func.TotalLocalCount; k++) { Variable arg = new Variable(); arg.Assembly = asm; arg.Name = ReadString(br); arg.VarType = (VarTypes)br.ReadInt32(); func.Arguments.Add(arg); } hll.Functions.Add(func); } asm.hlls.Add(hll); } } break; case "SWI0": { int count = br.ReadInt32(); for (int i = 0; i < count; i++) { Switch swi = new Switch(); swi.SwitchType = (SwitchTypes)br.ReadInt32(); swi.DefaultCase = br.ReadInt32(); int count2 = br.ReadInt32(); for (int j = 0; j < count2; j++) { swi.SwitchTable.Add(br.ReadInt32(), br.ReadInt32()); } asm.switches.Add(swi); } } break; case "GVER": asm.GVersion = br.ReadInt32(); break; case "STR0": { int count = br.ReadInt32(); for (int i = 0; i < count; i++) { string str = ReadString(br); asm.strings.Add(str); } } break; case "FNAM": { int count = br.ReadInt32(); for (int i = 0; i < count; i++) { string str = ReadString(br); asm.fname.Add(str); } } break; case "OJMP": { int funcID = br.ReadInt32(); if (funcID >= 0) asm.JumpFunction = asm.func[funcID]; } break; case "FNCT": { int len = br.ReadInt32(); int count = br.ReadInt32(); for (int i = 0; i < count; i++) { Function func = new Function(); func.Name = ReadString(br); func.ReturnType = (VarTypes)br.ReadInt32(); func.StructID = br.ReadInt32(); func.ArgCount = br.ReadInt32(); func.TotalLocalCount = br.ReadInt32(); for (int j = 0; j < func.TotalLocalCount; j++) { Variable arg = new Variable(); arg.Name = ReadString(br); arg.VarType = (VarTypes)br.ReadInt32(); arg.StructID = br.ReadInt32(); arg.Dimension = br.ReadInt32(); func.Arguments.Add(arg); } asm.fnct.Add(func); } } break; case "OBJG": { int count = br.ReadInt32(); for (int i = 0; i < count; i++) { string str = ReadString(br); asm.objg.Add(str); } } break; default: throw new ArgumentException(string.Format("{0}文件中包含未知的Trunk:{1}", path, trunk)); } } return asm; }
string DumpCodeBlock(Function func, Stack<string> stack, CodeBlock block, ref string pre) { string res = pre + "{\r\n"; pre += " "; Dictionary<int, List<string>> switchTargets = null; int startIndex = func.Instructions.IndexOf(block.Instructions[0]); int endIndex = block.EndIndex(func); int branch = 0; bool switchStarted = false; bool elseStarted = false; foreach (Instruction i in block.Instructions) { if (i.IsBranchTarget && (i.BranchFrom > func.Instructions.IndexOf(i)) && !block.Instructions.Contains(func.Instructions[i.BranchFrom])) { int index = func.Instructions.IndexOf(i); res += pre + "label" + index + ":\r\n"; } if (i.Inst == Instructions.DummyCodeBlock) { if (switchTargets != null) { CodeBlock tar = block.CodeBlocks[i.Operand1]; int index = func.Instructions.IndexOf(tar.Instructions[0]); if (switchTargets.ContainsKey(index)) { if (switchStarted) { res += pre + "break;\r\n"; pre = pre.Substring(4); } foreach (string j in switchTargets[index]) { if (j != "default") res += string.Format("{0}case {1}:\r\n", pre, j); else res += string.Format("{0}{1}:\r\n", pre, j); } switchStarted = true; } else pre = pre.Substring(4); } if (switchTargets != null) pre += " "; if (elseStarted && branch > 0) { res += pre + "else\r\n" + pre + "{\r\n"; pre += " "; } int stackOld = stack.Count; string cont = DumpCodeBlock(func, stack, block.CodeBlocks[i.Operand1], ref pre); res += cont; if (stack.Count > stackOld) { if (branch > 0) { if (!elseStarted) { Variable newVar = new Variable(); newVar.VarType = VarTypes.Unknown; newVar.Name = "v" + func.LocalVariables.Count; func.LocalVariables.Add(newVar); res += pre + newVar.Name + " = " + stack.Pop() + ";\r\n"; elseStarted = true; pre = pre.Substring(4); res += pre + "}\r\n"; stack.Push(newVar.Name); continue; } else { Variable newVar = func.LocalVariables[func.LocalVariables.Count - 1]; res += pre + newVar.Name + " = " + stack.Pop() + ";\r\n"; if (stack.Count == 0 || stack.Peek() != newVar.Name) stack.Push(newVar.Name); } } else { } } else { if (branch > 0 && !elseStarted) { elseStarted = i.Operand2 == 0; if (i.Operand2 == 1) branch--; pre = pre.Substring(4); res += pre + "}\r\n"; continue; } } if (switchTargets != null && !switchStarted) pre = pre.Substring(4); if (elseStarted && branch > 0) { pre = pre.Substring(4); res += pre + "}\r\n"; branch--; } } else { switch (i.Inst) { case Instructions.Push: { if (i.Operand1 == -1) stack.Push("null"); else stack.Push(i.Operand1.ToString()); } break; case Instructions.Pop: { string content = stack.Pop(); if (content.StartsWith("call ")) res += pre + content.Replace("call ", "") + ";\r\n"; } break; case Instructions.Ref: { string refObj = GetRef(func, stack); stack.Push(refObj); } break; case Instructions.PushGP: { stack.Push("GlobalPage"); } break; case Instructions.PushLP: { stack.Push("LocalPage"); } break; case Instructions.Inv: case Instructions.NegF: { stack.Push("-" + ProcessCondition(stack.Pop())); } break; case Instructions.Not: { stack.Push("!" + ProcessCondition(stack.Pop())); } break; case Instructions.NotBit: { stack.Push("~" + ProcessCondition(stack.Pop())); } break; case Instructions.Add: case Instructions.AddF: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " + " + op1 + ")"); } break; case Instructions.Min: case Instructions.MinF: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " - " + op1 + ")"); } break; case Instructions.Mul: case Instructions.MulF: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " * " + op1 + ")"); } break; case Instructions.Div: case Instructions.DivF: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " / " + op1 + ")"); } break; case Instructions.Mod: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " % " + op1 + ")"); } break; case Instructions.And: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " & " + op1 + ")"); } break; case Instructions.Or: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " | " + op1 + ")"); } break; case Instructions.Xor: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " ^ " + op1 + ")"); } break; case Instructions.Shl: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " << " + op1 + ")"); } break; case Instructions.Shr: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " >> " + op1 + ")"); } break; case Instructions.Le: case Instructions.LeF: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " < " + op1 + ")"); } break; case Instructions.Ge: case Instructions.GeF: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " > " + op1 + ")"); } break; case Instructions.Leq: case Instructions.LeqF: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " <= " + op1 + ")"); } break; case Instructions.Geq: case Instructions.GeqF: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " >= " + op1 + ")"); } break; case Instructions.Neq: case Instructions.NeqF: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " != " + op1 + ")"); } break; case Instructions.Eql: case Instructions.EqlF: { string op1 = ProcessCondition(stack.Pop()); string op2 = ProcessCondition(stack.Pop()); stack.Push("(" + op2 + " == " + op1 + ")"); } break; case Instructions.Assign: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} = {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(refObj); } break; case Instructions.AddA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} += {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(string.Format("{0}", refObj)); } break; case Instructions.MinA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} -= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(string.Format("{0}", refObj)); } break; case Instructions.MulA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} *= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(string.Format("{0}", refObj)); } break; case Instructions.DivA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} /= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(string.Format("{0}", refObj)); } break; case Instructions.ModA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} %= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(string.Format("{0}", refObj)); } break; case Instructions.AndA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} &= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(string.Format("{0}", refObj)); } break; case Instructions.OrA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} |= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(string.Format("{0}", refObj)); } break; case Instructions.ShlA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} <<= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(string.Format("{0}", refObj)); } break; case Instructions.ShrA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} >>= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(string.Format("{0}", refObj)); } break; case Instructions.AssignF: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} = {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(refObj); } break; case Instructions.AddFA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} += {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(refObj); } break; case Instructions.MinFA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} -= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(refObj); } break; case Instructions.MulFA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} *= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(refObj); } break; case Instructions.DivFA: { string val = stack.Pop(); string refObj = GetRef(func, stack); res += string.Format("{0}{1} /= {2};\r\n", pre, refObj, ProcessCondition(val)); stack.Push(refObj); } break; case Instructions.Dup2: { string v1 = stack.Pop(); string v2 = stack.Pop(); stack.Push(v2); stack.Push(v1); stack.Push(v2); stack.Push(v1); } break; case Instructions.Dup_At3: { string v3 = stack.Pop(); string v2 = stack.Pop(); string v1 = stack.Pop(); stack.Push(v3); stack.Push(v1); stack.Push(v2); stack.Push(v3); } break; case Instructions.Jmp: { if (i.BranchTarget[0] == startIndex) { if (branch == 0) { string pre2 = pre.Substring(0, pre.Length - 4); res = pre2 + "while(true)\r\n" + res; } else { string[] token = res.Split('\n'); res = ""; for (int j = 0; j < token.Length - 3; j++) { res += token[j] + "\n"; } pre = pre.Substring(0, pre.Length - 4); string pre2 = pre.Substring(0, pre.Length - 4); res = string.Format("{1}while{0}\n", token[token.Length - 3].TrimStart(' ').Replace("if", ""), pre2) + res; branch--; } } else { if (switchStarted) { res += pre + "break;\r\n"; pre = pre.Substring(4); } if (i.BranchTarget[0] < endIndex) { res += string.Format("{0}jmp label{1};\r\n", pre, i.BranchTarget[0]); } else { if (branch > 0 || block.Instructions.Count ==1) { res += string.Format("{0}jmp label{1};\r\n", pre, i.BranchTarget[0]); if (branch > 0) { pre = pre.Substring(4); res += pre + "}\r\n"; branch--; } } else { } } } } break; case Instructions.BrFalse: { if (i.BranchTarget[0] > endIndex) { } string cond = stack.Count > 0 ? stack.Pop() : func.LocalVariables[func.LocalVariables.Count - 1].Name; res += pre + string.Format("if({0})\r\n", ProcessCondition(cond)); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.BrTrue: { if (i.BranchTarget[0] > endIndex) { } string cond = stack.Count > 0 ? stack.Pop() : func.LocalVariables[func.LocalVariables.Count - 1].Name; res += pre + string.Format("if(!({0}))\r\n", ProcessCondition(cond)); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.Ret: { if (func.ReturnType != VarTypes.Void) res += pre + "return " + ProcessCondition(stack.Count > 0 ? stack.Pop() : func.LocalVariables[func.LocalVariables.Count - 1].Name) + ";\r\n"; else res += pre + "return;\r\n"; if (branch > 0) { pre = pre.Substring(4); res += pre + "}\r\n"; } } break; case Instructions.Call: case Instructions.CallMethod: case Instructions.CallDelegate: { string cmd = ""; Function tar = null; string refe = ""; if (i.Inst != Instructions.CallDelegate) tar = this.func[i.Operand1]; else { int funcID; //stack.Pop(); if (int.TryParse(stack.Peek(), out funcID)) { tar = this.fnct[int.Parse(stack.Pop())]; refe = ProcessCondition(stack.Pop()); } else { stack.Pop(); refe = ProcessCondition(stack.Pop()); res += string.Format("{0}{1}.UnknownDelegate();\r\n", pre, refe); break; } } string args = ""; for (int j = 0; j < tar.ArgCount; j++) { switch (tar.Arguments[tar.ArgCount - j - 1].VarType) { case VarTypes.IntRef: case VarTypes.FloatRef: { stack.Push("ref " + GetRef(func, stack)); } break; case VarTypes.StrucRef: case VarTypes.ArrayFloatRef: case VarTypes.ArrayIntRef: case VarTypes.ArrayStringRef: case VarTypes.ArrayStructRef: case VarTypes.StringRef: { stack.Push("ref " + ProcessCondition(stack.Pop())); } break; default: break; } if (tar.Arguments[tar.ArgCount - j - 1].VarType == VarTypes.Void) continue; args = ProcessCondition(stack.Count > 0 ? stack.Pop() : func.LocalVariables[func.LocalVariables.Count - 1].Name) + ", " + args; } if (args != "") args = args.Substring(0, args.Length - 2); if (i.Inst == Instructions.CallMethod) refe = stack.Pop() + "."; string name = i.Inst == Instructions.CallMethod ? tar.Name.Split('@')[1] : tar.Name; if (i.Inst == Instructions.CallDelegate) name = ""; cmd = string.Format("{2}{0}({1})", name, args, refe); if (tar.ReturnType != VarTypes.Void) stack.Push("call " + cmd); else res += pre + cmd + ";\r\n"; } break; case Instructions.Inc: { string refObj = GetRef(func, stack); res += string.Format("{0}{1}++;\r\n", pre, refObj); } break; case Instructions.Dec: { string refObj = GetRef(func, stack); res += string.Format("{0}{1}--;\r\n", pre, refObj); } break; case Instructions.FTOI: { stack.Push("((int)(" + ProcessCondition(stack.Pop()) + "))"); } break; case Instructions.ITOF: { stack.Push("((float)(" + ProcessCondition(stack.Pop()) + "))"); } break; case Instructions.PushF: { stack.Push(i.Operand1F.ToString()); } break; case Instructions.PushS: { stack.Push(string.Format("\"{0}\"", this.strings[i.Operand1].Replace("\n", "\\n"))); } break; case Instructions.PopStructRef: case Instructions.PopS: { string content = stack.Pop(); if (content.StartsWith("call ")) res += pre + content.Replace("call ", "") + ";\r\n"; } break; case Instructions.Add_S: { string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); stack.Push(string.Format("({0} + {1})", obj1, obj2)); } break; case Instructions.AssignS: { string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} = {2};\r\n", pre, obj1, obj2); stack.Push(obj1); } break; case Instructions.PushS_Ref: { stack.Push(GetRef(func, stack)); } break; case Instructions.StringNeq: { string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); stack.Push(string.Format("({0} != {1})", obj1, obj2)); } break; case Instructions.StringEql: { string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); stack.Push(string.Format("({0} == {1})", obj1, obj2)); } break; case Instructions.AssignStructRef: { stack.Pop(); string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} = {2};\r\n", pre, obj1, obj2); stack.Push(obj1); } break; case Instructions.ArrayStructRef: { string refObj = GetRef(func, stack); stack.Push(string.Format("(({0}){1})", this.structs[i.Operand1].Name, refObj)); } break; case Instructions.AllocA: { string dimension = ProcessCondition(stack.Pop()); string count = ""; for (int j = 0; j < int.Parse(dimension); j++) count += ProcessCondition(stack.Pop()) + ", "; if (count != "") count = count.Substring(0, count.Length - 2); string refObj = GetRef(func, stack); res += string.Format("{0}{1}.Alloc({2});\r\n", pre, refObj, count); } break; case Instructions.ReallocA: { string dimension = ProcessCondition(stack.Pop()); string count = ""; for (int j = 0; j < int.Parse(dimension); j++) count += ProcessCondition(stack.Pop()) + ", "; if (count != "") count = count.Substring(0, count.Length - 2); string refObj = GetRef(func, stack); res += string.Format("{0}{1}.Realloc({2});\r\n", pre, refObj, count); } break; case Instructions.FreeA: { string refObj = GetRef(func, stack); res += string.Format("{0}{1}.Free();\r\n", pre, refObj); } break; case Instructions.ArrayLength: { int dimension = int.Parse(stack.Pop()); string refObj = GetRef(func, stack); if (dimension == 1) { stack.Push(string.Format("{0}.Length", refObj)); } else { stack.Push(string.Format("{0}[{1}].Length", refObj, dimension)); } } break; case Instructions.CopyA: { string count = ProcessCondition(stack.Pop()); string index2 = ProcessCondition(stack.Pop()); string a2 = ProcessCondition(stack.Pop()); string index1 = ProcessCondition(stack.Pop()); string refObj = GetRef(func, stack); res += string.Format("{0}{1}.Copy({2},{3},{4},{5});\r\n", pre, refObj, index1, a2, index2, count); stack.Push(refObj); } break; case Instructions.ArrayFill: { string val = ProcessCondition(stack.Pop()); string count = ProcessCondition(stack.Pop()); string index = ProcessCondition(stack.Pop()); string refObj = GetRef(func, stack); stack.Push(string.Format("call {0}.Fill({1},{2},{3})", refObj, index, count, val)); } break; case Instructions.CharRef: { string refObj = GetRef(func, stack); stack.Push(refObj); } break; case Instructions.AssignChar: { string val = ProcessCondition(stack.Pop()); string refObj = GetRef(func, stack); res += string.Format("{0}{1} = {2}", pre, refObj, val); stack.Push(refObj); } break; case Instructions.Msg: { res += string.Format("{0}System.Message(\"{1}\");\r\n", pre, this.msgs[i.Operand1].Replace("\n", "\\n")); } break; case Instructions.CallHLL: { string cmd = ""; Hll tar = this.hlls[i.Operand1]; string args = ""; for (int j = 0; j < tar.Functions[i.Operand2].ArgCount; j++) { switch (tar.Functions[i.Operand2].Arguments[tar.Functions[i.Operand2].ArgCount - j - 1].VarType) { case VarTypes.IntRef: case VarTypes.FloatRef: { stack.Push("ref " + GetRef(func, stack)); } break; case VarTypes.StrucRef: case VarTypes.ArrayFloatRef: case VarTypes.ArrayIntRef: case VarTypes.ArrayStringRef: case VarTypes.ArrayStructRef: case VarTypes.StringRef: { stack.Push("ref " + ProcessCondition(stack.Pop())); } break; default: break; } if (tar.Functions[i.Operand2].Arguments[tar.Functions[i.Operand2].ArgCount - j - 1].VarType == VarTypes.Void) continue; args = ProcessCondition(stack.Count > 0 ? stack.Pop() : func.LocalVariables[func.LocalVariables.Count - 1].Name) + ", " + args; } /*for (int j = 0; j < tar.Functions[i.Operand2].ArgCount; j++) args = ProcessCondition(stack.Pop()) + ", " + args;*/ if (args != "") args = args.Substring(0, args.Length - 2); cmd = string.Format("{0}.{1}({2})", tar.Name, tar.Functions[i.Operand2].Name, args); if (tar.Functions[i.Operand2].ReturnType != VarTypes.Void) stack.Push("call " + cmd); else res += pre + cmd + ";\r\n"; } break; case Instructions.PushSP: { stack.Push("this"); } break; case Instructions.RefGlobal: { stack.Push(string.Format("Global.{0}", this.global[i.Operand1].Name)); } break; case Instructions.RefLocal: { stack.Push(func.LocalVariables[i.Operand1].Name); } break; case Instructions.Switch: case Instructions.SwitchS: { Switch swi = this.SwitchTables[i.Operand1]; List<int> keys = swi.SwitchTable.Keys.ToList(); switchTargets = new Dictionary<int, List<string>>(); for (int j = 0; j < keys.Count; j++) { if (!switchTargets.ContainsKey(i.BranchTarget[j])) switchTargets.Add(i.BranchTarget[j], new List<string>()); if (swi.SwitchType == SwitchTypes.Integer) switchTargets[i.BranchTarget[j]].Add(keys[j].ToString()); else switchTargets[i.BranchTarget[j]].Add("\"" + this.strings[keys[j]] + "\""); } if (swi.DefaultCase != -1) { if (!switchTargets.ContainsKey(i.BranchTarget[keys.Count])) switchTargets.Add(i.BranchTarget[keys.Count], new List<string>()); switchTargets[i.BranchTarget[keys.Count]].Add("default"); } res += pre + string.Format("switch({0})\r\n", ProcessCondition(stack.Pop())); res += pre + "{\r\n"; pre += " "; } break; case Instructions.CallSys: { string cmd = ""; Function tar = Function.Syscalls[(Syscalls)i.Operand1]; string args = ""; for (int j = 0; j < tar.ArgCount; j++) { switch (tar.Arguments[tar.ArgCount - j - 1].VarType) { case VarTypes.IntRef: case VarTypes.FloatRef: { stack.Push("ref " + GetRef(func, stack)); } break; case VarTypes.StrucRef: case VarTypes.ArrayFloatRef: case VarTypes.ArrayIntRef: case VarTypes.ArrayStringRef: case VarTypes.ArrayStructRef: case VarTypes.StringRef: { stack.Push("ref " + ProcessCondition(stack.Pop())); } break; default: break; } if (tar.Arguments[tar.ArgCount - j - 1].VarType == VarTypes.Void) continue; args = ProcessCondition(stack.Count > 0 ? stack.Pop() : func.LocalVariables[func.LocalVariables.Count - 1].Name) + ", " + args; } if (args != "") args = args.Substring(0, args.Length - 2); cmd = string.Format("System.{0}({1})", tar.Name, args); if (tar.ReturnType != VarTypes.Void) stack.Push("call " + cmd); else res += pre + cmd + ";\r\n"; } break; case Instructions.Swap: { string var2 = stack.Pop(); string var1 = stack.Pop(); stack.Push(var2); stack.Push(var1); } break; case Instructions.PushField: { Struct clsObj = GetFuncClass(func); stack.Push("this." + clsObj.Variables[i.Operand1].Name); } break; case Instructions.StringLen: { string refObj = GetRef(func, stack); stack.Push(string.Format("call {0}.Length", refObj)); } break; case Instructions.StringLenBytes: { string refObj = GetRef(func, stack); stack.Push(string.Format("call {0}.ByteCount", refObj)); } break; case Instructions.AssignDelegate: { int type = int.Parse(stack.Pop()); string val = ProcessCondition(stack.Pop()); string refObj = GetRef(func, stack); res += string.Format("{0}{1} = ({2}){3};\r\n", pre, refObj, fnct[type].Name, val); stack.Push(val); } break; case Instructions.NewObj: { int num = int.Parse(stack.Pop()); stack.Push(string.Format("new {0}()", this.structs[num].Name)); } break; case Instructions.Delete: { string obj = stack.Pop(); res += pre + obj + "= null;\r\n"; } break; case Instructions.Clone: { stack.Push(string.Format("call {0}.Clone()", ProcessCondition(stack.Pop()))); } break; case Instructions.Dup: { string obj = stack.Pop(); stack.Push(obj); stack.Push(obj); } break; case Instructions.SPInc: { res += pre + stack.Pop() + ".spinc();\r\n"; } break; case Instructions.SPDec: { res += pre + stack.Pop() + ".spdec();\r\n"; } break; case Instructions.StructCreateLocal: { res += pre + string.Format("{0} = new {1}();\r\n", func.LocalVariables[i.Operand1].Name, this.structs[i.Operand2].Name); } break; case Instructions.StructDelLocal: { res += pre + string.Format("{0} = null;\r\n", func.LocalVariables[i.Operand1].Name); } break; case Instructions.STOI: { stack.Push(string.Format("call int.Parse({0})", ProcessCondition(stack.Pop()))); } break; case Instructions.ArrayPushBack: { string val=ProcessCondition(stack.Pop()); string refObj = GetRef(func, stack); res += string.Format("{0}{1}.PushBack({2});\r\n", pre, refObj, val); } break; case Instructions.ArrayPopBack: { string refObj = GetRef(func, stack); res += string.Format("{0}{1}.PopBack();\r\n", pre, refObj); } break; case Instructions.StringEmpty: { stack.Push(string.Format("call {0}.IsEmpty", ProcessCondition(stack.Pop()))); } break; case Instructions.ArrayEmpty: { string refObj = GetRef(func, stack); stack.Push(string.Format("call {0}.IsEmpty", refObj)); } break; case Instructions.ArrayRemove: { string index = ProcessCondition(stack.Pop()); string refObj = GetRef(func, stack); stack.Push(string.Format("call {0}.RemoveAt({1})", refObj, index)); } break; case Instructions.IncLocal: { res += pre + string.Format("{0}++;\r\n", func.LocalVariables[i.Operand1].Name); } break; case Instructions.DecLocal: { res += pre + string.Format("{0}--;\r\n", func.LocalVariables[i.Operand1].Name); } break; case Instructions.AssignLocal: { res += pre + string.Format("{0} = {1};\r\n", func.LocalVariables[i.Operand1].Name, i.Operand2); } break; case Instructions.StringIndexOf: { string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); stack.Push(string.Format("call {0}.IndexOf({1})", obj1, obj2)); } break; case Instructions.StringSubString: { string count = ProcessCondition(stack.Pop()); string index = ProcessCondition(stack.Pop()); string obj = ProcessCondition(stack.Pop()); stack.Push(string.Format("call {0}.Substring({1},{2})", obj, index, count)); } break; case Instructions.SortA: { int funcID = int.Parse(stack.Pop()); string refObj = GetRef(func, stack); res += string.Format("{0}{1}.Sort({2});\r\n", pre, refObj, this.func[funcID].Name); } break; case Instructions.ITOB: { stack.Push("(" + ProcessCondition(stack.Count > 0 ? stack.Pop() : func.LocalVariables[func.LocalVariables.Count - 1].Name) + " == 1)"); } break; case Instructions.StringPushBack: { string val = ProcessCondition(stack.Pop()); string refObj = GetRef(func, stack); res += string.Format("{0}{1}.PushBack({2});\r\n", pre, refObj, val); } break; case Instructions.StringPopBack: { string refObj = GetRef(func, stack); res += string.Format("{0}{1}.PopBack();\r\n", pre, refObj); } break; case Instructions.StringFormat: { string type = stack.Pop(); string val = ProcessCondition(stack.Pop()); string format = ProcessCondition(stack.Pop()); switch (type) { case "2"://int case "3"://float case "4": case "48": stack.Push(format + ", " + val); break; default: break; } } break; case Instructions.AddS: { string val = ProcessCondition(stack.Pop()); string ori = ProcessCondition(stack.Pop()); res += (string.Format("{0}{1} += {2};\r\n", pre, ori, val)); stack.Push(string.Format("{0} + {1}", ori, val)); } break; case Instructions.ObjSwap: { stack.Pop(); string obj2 = GetRef(func, stack); string obj1 = GetRef(func, stack); res += string.Format("{0}tmp = {1};\r\n{0}{1} = {2};\r\n{0}{2} = tmp;\r\n", pre, obj1, obj2); } break; case Instructions.StructRef: { } break; case Instructions.StringPushBackRef: { string val = ProcessCondition(stack.Pop()); string obj = ProcessCondition(stack.Pop()); res += string.Format("{0}{1}.PushBack({2});\r\n", pre, obj, val); } break; case Instructions.StringPopBackRef: { res += string.Format("{0}{1}.PopBack();\r\n", pre, ProcessCondition(stack.Pop())); } break; case Instructions.ITOUI: { string obj = ProcessCondition(stack.Pop()); stack.Push(string.Format("((uint){0})", obj)); } break; case Instructions.AddUI: { string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} += {2};\r\n", pre, obj1, obj2); stack.Push(obj1); } break; case Instructions.MinUI: { string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} -= {2};\r\n", pre, obj1, obj2); stack.Push(obj1); } break; case Instructions.MulUI: { string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} *= {2};\r\n", pre, obj1, obj2); stack.Push(obj1); } break; case Instructions.DivUI: { string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} /= {2};\r\n", pre, obj1, obj2); stack.Push(obj1); } break; case Instructions.ModUI: { string obj2 = ProcessCondition(stack.Pop()); string obj1 = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} %= {2};\r\n", pre, obj1, obj2); stack.Push(obj1); } break; case Instructions.AssignUI: { string val = ProcessCondition(stack.Pop()); string refObj = GetRef(func, stack); res += string.Format("{0}{1} = {2};\r\n", pre, refObj, val); stack.Push(refObj); } break; case Instructions.ArrayFind: { int funcID = int.Parse(stack.Pop()); string cmpObj = ProcessCondition(stack.Pop()); string end = ProcessCondition(stack.Pop()); string start = ProcessCondition(stack.Pop()); string refObj = GetRef(func, stack); stack.Push(string.Format("call {0}.Find({1},{2},{3},{4})", refObj, start, end, cmpObj, this.func[funcID].Name)); } break; case Instructions.ArrayReverse: { string refObj = GetRef(func, stack); res += string.Format("{0}{1}.Reverse();\r\n", pre, refObj); } break; case Instructions.AssignRef: { string refObj = GetRef(func, stack); res += string.Format("{0}{1} = {2};\r\n", pre, ProcessCondition(stack.Pop()), refObj); } break; case Instructions.AssignFieldLocal: { Struct clsObj = GetFuncClass(func); res += pre + string.Format("this.{0} = {1};\r\n", clsObj.Variables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); } break; case Instructions.ArraySizeField: { Struct clsObj = GetFuncClass(func); stack.Push("this." + clsObj.Variables[i.Operand1].Name + ".Length"); } break; case Instructions.ArraySizeGlobal: { stack.Push("Global." + this.global[i.Operand1].Name + ".Length"); } break; case Instructions.AssignField: { Struct clsObj = GetFuncClass(func); res += pre + string.Format("this.{0} = {1};\r\n", clsObj.Variables[i.Operand1].Name, i.Operand2); } break; case Instructions.PushLocal2: { stack.Push(func.LocalVariables[i.Operand1].Name); stack.Push(func.LocalVariables[i.Operand1 + 1].Name); } break; case Instructions.MinLocal: { res += string.Format("{0}{1} -= {2};\r\n", pre, func.LocalVariables[i.Operand1].Name, i.Operand2); } break; case Instructions.BltLocal: { if (i.BranchTarget[0] > endIndex) { } res += pre + string.Format("if({0} >= {1})\r\n", func.LocalVariables[i.Operand1].Name, i.Operand2); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.BgeLocal: { if (i.BranchTarget[0] > endIndex) { } res += pre + string.Format("if({0} < {1})\r\n", func.LocalVariables[i.Operand1].Name, i.Operand2); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.AssignArrayLocalField: { Struct clsObj = GetFuncClass(func); string obj = func.LocalVariables[i.Operand1].Name; string index = func.LocalVariables[i.Operand1 + 1].Name; string val = "this." + clsObj.Variables[i.Operand2]; index = index != "<void>" ? "[" + index + "]" : ""; res += string.Format("{0}{1}{2} = {3};\r\n", pre, obj, index, val); } break; case Instructions.AssignGlobalLocal: { res += string.Format("{0}Global.{1} = {2};\r\n", pre, this.global[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); } break; case Instructions.GeField: { Struct clsObj = GetFuncClass(func); stack.Push(string.Format("({0} > {1})", clsObj.Variables[i.Operand1].Name, i.Operand2)); } break; case Instructions.AssignFieldLocalITOB: { Struct clsObj = GetFuncClass(func); res += string.Format("{0}this.{1} = {2} == 1;\r\n", pre, clsObj.Variables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); } break; case Instructions.AssignLocalField: { Struct clsObj = GetFuncClass(func); res += string.Format("{0}{1} = this.{2};\r\n", pre, func.LocalVariables[i.Operand1].Name, clsObj.Variables[i.Operand2].Name); } break; case Instructions.BneFieldLocal: { Struct clsObj = GetFuncClass(func); res += pre + string.Format("if(this.{0} == {1})\r\n", clsObj.Variables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.BgtField: { Struct clsObj = GetFuncClass(func); res += pre + string.Format("if(this.{0} <= {1})\r\n", clsObj.Variables[i.Operand1].Name, i.Operand2); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.BrFalseField: { if (i.BranchTarget[0] > endIndex) { } Struct clsObj = GetFuncClass(func); res += pre + string.Format("if(this.{0})\r\n", clsObj.Variables[i.Operand1].Name); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.BNotEmptyField: { Struct clsObj = GetFuncClass(func); res += pre + string.Format("if(this.{0}.IsEmpty)\r\n", clsObj.Variables[i.Operand1].Name); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.BneLocal: { if (i.BranchTarget[0] > endIndex) { } res += pre + string.Format("if({0} == {1})\r\n", func.LocalVariables[i.Operand1].Name, i.Operand2); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.BeqField: { Struct clsObj = GetFuncClass(func); res += pre + string.Format("if(this.{0} != {1})\r\n", clsObj.Variables[i.Operand1].Name, i.Operand2); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.AssignGlobal: { res += string.Format("{0}Global.{1} = {2};\r\n", pre, this.global[i.Operand1].Name, i.Operand2); } break; case Instructions.ArrayPushBackFieldLocal: { Struct clsObj = GetFuncClass(func); res += string.Format("{0}this.{1}.PushBack({2});\r\n", pre, clsObj.Variables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); } break; case Instructions.ArrayPushBackGlobalLocal: { res += string.Format("{0}Global.{1}.PushBack({2});\r\n", pre, this.global[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); } break; case Instructions.ArrayPushBackLocal: { res += string.Format("{0}{1}.PushBack({2});\r\n", pre, func.LocalVariables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); } break; case Instructions.BneS: { string refObj = GetRef(func, stack); res += pre + string.Format("if({0} == \"{1}\")\r\n", refObj, this.strings[i.Operand1].Replace("\n", "\\n")); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.AssignSRef: { string refObj = GetRef(func, stack); string obj = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} = {2};\r\n", pre, obj, refObj); } break; case Instructions.StringEmptyRef: { string refObj = GetRef(func, stack); stack.Push(string.Format("call {0}.IsEmpty", refObj)); } break; case Instructions.EqlSFieldLocal: { Struct clsObj = GetFuncClass(func); stack.Push(string.Format("(this.{0} == {1})", clsObj.Variables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name)); } break; case Instructions.EqlSLocal: { stack.Push(string.Format("({0} == \"{1}\")", func.LocalVariables[i.Operand1].Name, this.strings[i.Operand2].Replace("\n", "\\n"))); } break; case Instructions.NeqSFieldLocal: { Struct clsObj = GetFuncClass(func); stack.Push(string.Format("(this.{0} != {1})", clsObj.Variables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name)); } break; case Instructions.NeqSLocal: { stack.Push(string.Format("({0} != \"{1}\")", func.LocalVariables[i.Operand1].Name, this.strings[i.Operand2].Replace("\n", "\\n"))); } break; case Instructions.PushStructRefField: { Struct clsObj = GetFuncClass(func); stack.Push(string.Format("this.{0}.Clone()", clsObj.Variables[i.Operand1].Name)); } break; case Instructions.PushSField: { Struct clsObj = GetFuncClass(func); stack.Push("this." + clsObj.Variables[i.Operand1].Name); } break; case Instructions.BgtLocal: { if (i.BranchTarget[0] > endIndex) { } res += pre + string.Format("if({0} <= {1})\r\n", func.LocalVariables[i.Operand1].Name, i.Operand2); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.BneField: { Struct clsObj = GetFuncClass(func); res += pre + string.Format("if(this.{0} == {1})\r\n", clsObj.Variables[i.Operand1].Name, i.Operand2); res += pre + "{\r\n"; pre += " "; branch++; } break; case Instructions.PushSGlobal: { stack.Push("Global." + this.global[i.Operand1].Name); } break; case Instructions.PushSLocal: { stack.Push(func.LocalVariables[i.Operand1].Name); } break; case Instructions.AssignSConst: { string target = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} = \"{2}\";\r\n", pre, target, this.strings[i.Operand1].Replace("\n", "\\n")); } break; case Instructions.AssignSLocal: { string target = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} = \"{2}\";\r\n", pre, target, func.LocalVariables[i.Operand1].Name); } break; case Instructions.AssignSFieldLocal: { Struct clsObj = GetFuncClass(func); res += (string.Format("{0}this.{1} = {2};\r\n)", pre, clsObj.Variables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name)); } break; case Instructions.AssignSLocalLocal: { res += string.Format("{0}{1} = {2};\r\n",pre, func.LocalVariables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); } break; case Instructions.ArrayPushBackLocalString: { res += string.Format("{0}{1}.PushBack({2});\r\n", pre, func.LocalVariables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); } break; case Instructions.AssignRefCallStack: { string level = ProcessCondition(stack.Pop()); string obj = ProcessCondition(stack.Pop()); res += string.Format("{0}{1} = System.GetFuncStackName({2});\r\n", pre, obj, level); } break; case Instructions.StringEmptyLocal: { stack.Push(string.Format("call {0}.IsEmpty", func.LocalVariables[i.Operand1].Name)); } break; case Instructions.ArrayPushBackGlobalLocalRef: { res += string.Format("{0}this.{1}.PushBack({2});\r\n", pre, this.global[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); } break; case Instructions.ArrayPushBackFieldLocalRef: { Struct clsObj = GetFuncClass(func); res += string.Format("{0}this.{1}.PushBack({2});\r\n", pre, clsObj.Variables[i.Operand1].Name, func.LocalVariables[i.Operand2].Name); } break; case Instructions.StringEmptyField: { Struct clsObj = GetFuncClass(func); stack.Push(string.Format("call this.{0}.IsEmpty", clsObj.Variables[i.Operand1].Name)); } break; case Instructions.AssignSField: { Struct clsObj = GetFuncClass(func); string val = ProcessCondition(stack.Pop()); res += string.Format("{0}this.{1} = {2};\r\n", pre, clsObj.Variables[i.Operand1].Name, val); } break; case Instructions.NeqFieldS: { Struct clsObj = GetFuncClass(func); stack.Push(string.Format("({0} != \"{1}\")", clsObj.Variables[i.Operand1].Name, this.strings[i.Operand2].Replace("\n", "\\n"))); } break; case Instructions.LtOrGeLocal: { stack.Push(string.Format("({0} < {1} || {0} >= {2})", func.LocalVariables[i.Operand1].Name, i.Operand2, i.Operand3)); } break; case Instructions.AssertFile: case Instructions.AssertFunc: case Instructions.EndOfFunc: break; default: throw new NotSupportedException(); } // res += pre + i + "\r\n"; } } while (branch > 0) { //pre = pre.Substring(0, pre.Length - 4); //res += pre + "}\r\n"; branch--; } if (switchStarted) { res += pre + "break;\r\n"; pre = pre.Substring(8); res += pre + "}\r\n"; } pre = pre.Substring(0, pre.Length - 4); if (res.StartsWith(pre + "{")) { string[] token = res.Split('\n'); StringBuilder sb = new StringBuilder(); res = ""; for (int i = 1; i < token.Length; i++) { if (string.IsNullOrEmpty(token[i])) continue; sb.Append(token[i].Substring(4) + "\n"); } res = sb.ToString(); } else { res += pre + "}\r\n"; } return res; }
public static void AddArg(this Function func, VarTypes type) { Variable var = new Variable(); var.VarType = type; func.Arguments.Add(var); }