/// <summary> /// Write human readable output. /// </summary> public override void WriteTo(ITextOutput output) { output.Write("BasicBlock{"); output.WriteLine(); output.Indent(); foreach (var child in GetChildren()) { child.WriteTo(output); output.WriteLine(); } output.Unindent(); output.Write("}"); output.WriteLine(); }
public override void WriteTo(ITextOutput output) { output.WriteLine(""); output.Write("loop ("); if (this.Condition != null) { this.Condition.WriteTo(output); } output.WriteLine(") {"); output.Indent(); this.BodyBlock.WriteTo(output); output.Unindent(); output.WriteLine("}"); }
static void WriteMethod(MethodDefinition def, ITextOutput output) { if (def.IsConstructor && def.IsStatic) { return; } if (def.DeclaringType != null && def.DeclaringType.IsInterface) { return; } var info = InfoUtil.Info(def); if (def.IsConstructor) { output.Write(def.DeclaringType.Name + "::" + def.DeclaringType.Name); } else { output.Write(info.ReturnTypeName); output.Write(" "); output.Write(def.DeclaringType.Name + "::" + info.Name); } output.Write("("); WriteParameters(def, output, false); output.Write(")"); if (def.IsGetter) { output.Write(" const"); } output.WriteLine(); output.WriteLine("{"); if (!def.IsConstructor) { output.Indent(); if (def.ReturnType.MetadataType != MetadataType.Void) { output.Write("return "); } output.Write("d_ptr->"); output.Write(info.Name); output.Write("("); WriteParameterNames(def, output); output.WriteLine(");"); output.Unindent(); } output.WriteLine("}"); }
public override void WriteTo(ITextOutput output) { output.Write("catch "); output.WriteReference(ExceptionType.FullName, ExceptionType); if (ExceptionVariable != null) { output.Write(' '); output.Write(ExceptionVariable.Name); } output.WriteLine(" {"); output.Indent(); base.WriteTo(output); output.Unindent(); output.WriteLine("}"); }
static void WriteFieldMethodBody(FieldDefinition def, ITextOutput output, bool isRead) { if (!isRead) { output.WriteLine("{"); output.WriteLine("}"); } else { output.WriteLine("{"); output.Indent(); string value = Util.GetDefaultValue(def.FieldType); output.WriteLine("return " + value + ";"); output.Unindent(); output.WriteLine("}"); } }
public List <int> Values; // null for the default case public override void WriteTo(ITextOutput output) { if (this.Values != null) { foreach (int i in this.Values) { output.WriteLine("case {0}:", i); } } else { output.WriteLine("default:"); } output.Indent(); base.WriteTo(output); output.Unindent(); }
public override void WriteTo(ITextOutput output) { output.Write("fixed ("); for (int i = 0; i < this.Initializers.Count; i++) { if (i > 0) { output.Write(", "); } this.Initializers[i].WriteTo(output); } output.WriteLine(") {"); output.Indent(); this.BodyBlock.WriteTo(output); output.Unindent(); output.WriteLine("}"); }
/// <summary> /// Write human readable output. /// </summary> public override void WriteTo(ITextOutput output, FormattingOptions format) { if (Values != null) { foreach (var i in Values) { output.WriteLine("case {0}:", i); } } else { output.WriteLine("default:"); } output.Indent(); base.WriteTo(output, format); output.Unindent(); }
static void WriteFields(TypeDefinition def, ITextOutput output) { if (def.Fields.Count() > 0) { output.WriteLine("public:"); output.Indent(); foreach (var f in def.Fields) { var info = InfoUtil.Info(f); output.Write(info.FieldTypeName); output.Write(" "); output.Write(f.Name); output.WriteLine(";"); } output.Unindent(); output.WriteLine(); } }
public override void WriteTo(ITextOutput output, ILAstWritingOptions options) { WriteILRange(output, options); output.Write("using"); if (IsAsync) { output.Write(".async"); } output.Write(" ("); Variable.WriteTo(output); output.Write(" = "); ResourceExpression.WriteTo(output, options); output.WriteLine(") {"); output.Indent(); Body.WriteTo(output, options); output.Unindent(); output.WriteLine(); output.Write("}"); }
public static bool WriteNodes <T>(this IList <T> nodes, ITextOutput output, int start, int count, bool endingSemiColon, bool withBrackets) where T : ILNode { // Generic method to print a list of nodes if (nodes.Count == 0 || count == 0) { return(false); } else if ((nodes.Count - start) == 1 || count == 1) { nodes[start].WriteTo(output); if (endingSemiColon) { output.Write(';'); } return(false); } else { if (withBrackets) { output.Write('{'); } output.WriteLine(); output.Indent(); for (; start < count; start++) { ILNode n = nodes[start]; n.WriteTo(output); if (endingSemiColon && n is ILExpression) { output.Write(';'); } output.WriteLine(); } output.Unindent(); if (withBrackets) { output.Write('}'); } return(true); // we did a writeline, atleast one } }
public override void WriteTo(ITextOutput output, ILAstWritingOptions options) { output.Write("switch ("); value.WriteTo(output, options); output.Write(") "); output.MarkFoldStart("{...}"); output.WriteLine("{"); output.Indent(); output.Write("default: "); defaultBody.WriteTo(output, options); output.WriteLine(); foreach (var section in this.Sections) { section.WriteTo(output, options); output.WriteLine(); } output.Unindent(); output.Write('}'); output.MarkFoldEnd(); }
public static void WriteEventTypeInclude(TypeDefinition def, ITextOutput output) { output.WriteLine("class QUANTKIT_EXPORT EventType"); output.WriteLine("{"); output.WriteLine("public:"); output.Indent(); if (eventList == null) { BuildEventTypeTable(def.Module); } foreach (var f in Helper.eventList) { output.Write("static const unsigned char "); output.Write(f.Name); output.Write(" = "); output.Write(f.Constant.ToString()); output.WriteLine(";"); } output.Unindent(); output.WriteLine("};"); }
public List <int> Values; // null for the default case public override void WriteTo(ITextOutput output, MemberMapping memberMapping) { if (this.Values != null) { foreach (int i in this.Values) { output.Write("case", TextTokenKind.Keyword); output.WriteSpace(); output.Write(string.Format("{0}", i), TextTokenKind.Number); output.WriteLine(":", TextTokenKind.Operator); } } else { output.Write("default", TextTokenKind.Keyword); output.WriteLine(":", TextTokenKind.Operator); } output.Indent(); base.WriteTo(output, memberMapping); output.Unindent(); }
public override void WriteTo(ITextOutput output, ILAstWritingOptions options) { WriteILRange(output, options); output.Write("Block "); output.WriteLocalReference(Label, this, isDefinition: true); if (Kind != BlockKind.ControlFlow) { output.Write($" ({Kind})"); } if (Parent is BlockContainer) { output.Write(" (incoming: {0})", IncomingEdgeCount); } output.Write(' '); output.MarkFoldStart("{...}"); output.WriteLine("{"); output.Indent(); int index = 0; foreach (var inst in Instructions) { if (options.ShowChildIndexInBlock) { output.Write("[" + index + "] "); index++; } inst.WriteTo(output, options); output.WriteLine(); } if (finalInstruction.OpCode != OpCode.Nop) { output.Write("final: "); finalInstruction.WriteTo(output, options); output.WriteLine(); } output.Unindent(); output.Write("}"); output.MarkFoldEnd(); }
public override void WriteTo(ITextOutput output, ILAstWritingOptions options) { WriteILRange(output, options); output.Write("switch"); if (IsLifted) { output.Write(".lifted"); } output.Write(" ("); value.WriteTo(output, options); output.Write(") "); output.MarkFoldStart("{...}"); output.WriteLine("{"); output.Indent(); foreach (var section in this.Sections) { section.WriteTo(output, options); output.WriteLine(); } output.Unindent(); output.Write('}'); output.MarkFoldEnd(); }
private void PrintMethod(CompiledMethod cmethod, ITextOutput output, DecompilationOptions options) { if ((cmethod != null) && (cmethod.RLBody != null)) { var body = cmethod.RLBody; var basicBlocks = BasicBlock.Find(body); foreach (var block in basicBlocks) { output.Write(string.Format("D_{0:X4}:", block.Entry.Index)); output.WriteLine(); output.Indent(); foreach (var ins in block.Instructions) { if (ShowHasSeqPoint) { if (ins.SequencePoint != null) output.Write(ins.SequencePoint.IsSpecial ? "!" : "~"); } output.Write(ins.ToString()); output.WriteLine(); } output.Unindent(); } if (body.Exceptions.Any()) { output.WriteLine(); output.Write("Exception handlers:"); output.WriteLine(); output.Indent(); foreach (var handler in body.Exceptions) { output.Write(string.Format("{0:x4}-{1:x4}", handler.TryStart.Index, handler.TryEnd.Index)); output.WriteLine(); output.Indent(); foreach (var c in handler.Catches) { output.Write(string.Format("{0} => {1:x4}", c.Type, c.Instruction.Index)); output.WriteLine(); } if (handler.CatchAll != null) { output.Write(string.Format("{0} => {1:x4}", "<any>", handler.CatchAll.Index)); output.WriteLine(); } output.Unindent(); } output.Unindent(); } } else { output.Write("Method not found in dex"); output.WriteLine(); } }
void DisassembleMethodInternal(MethodDefinition method) { // .method public hidebysig specialname // instance default class [mscorlib]System.IO.TextWriter get_BaseWriter () cil managed // //emit flags WriteEnum(method.Attributes & MethodAttributes.MemberAccessMask, methodVisibility); WriteFlags(method.Attributes & ~MethodAttributes.MemberAccessMask, methodAttributeFlags); output.WriteLine(); output.Indent(); if (method.HasThis) { output.Write("instance "); } //call convention WriteEnum(method.CallingConvention & (MethodCallingConvention)0x1f, callingConvention); //return type method.ReturnType.WriteTo(output); output.Write(' '); output.Write(DisassemblerHelpers.Escape(method.Name)); WriteTypeParameters(output, method); //( params ) output.Write(" ("); if (method.HasParameters) { output.WriteLine(); output.Indent(); WriteParameters(method.Parameters); output.Unindent(); } output.Write(") "); //cil managed WriteEnum(method.ImplAttributes & MethodImplAttributes.CodeTypeMask, methodCodeType); if ((method.ImplAttributes & MethodImplAttributes.ManagedMask) == MethodImplAttributes.Managed) { output.Write("managed "); } else { output.Write("unmanaged "); } WriteFlags(method.ImplAttributes & ~(MethodImplAttributes.CodeTypeMask | MethodImplAttributes.ManagedMask), methodImpl); output.Unindent(); if (method.HasBody || method.HasCustomAttributes) { OpenBlock(defaultCollapsed: isInType); WriteAttributes(method.CustomAttributes); if (method.HasBody) { // create IL code mappings - used in debugger MemberMapping methodMapping = method.CreateCodeMapping(this.CodeMappings); methodBodyDisassembler.Disassemble(method.Body, methodMapping); } CloseBlock("End of method " + method.DeclaringType.Name + "." + method.Name); } else { output.WriteLine(); } }
public override void WriteTo(ITextOutput output, ILAstWritingOptions options) { WriteILRange(output, options); output.Write(OpCode); if (Method != null) { output.Write(' '); Method.WriteTo(output); } if (IsExpressionTree) { output.Write(".ET"); } if (DelegateType != null) { output.Write("["); DelegateType.WriteTo(output); output.Write("]"); } output.WriteLine(" {"); output.Indent(); if (IsAsync) { output.WriteLine(".async"); } if (IsIterator) { output.WriteLine(".iterator"); } output.MarkFoldStart(Variables.Count + " variable(s)", true); foreach (var variable in Variables) { variable.WriteDefinitionTo(output); output.WriteLine(); } output.MarkFoldEnd(); output.WriteLine(); foreach (string warning in Warnings) { output.WriteLine("//" + warning); } body.WriteTo(output, options); output.WriteLine(); if (options.ShowILRanges) { var unusedILRanges = FindUnusedILRanges(); if (!unusedILRanges.IsEmpty) { output.Write("// Unused IL Ranges: "); output.Write(string.Join(", ", unusedILRanges.Intervals.Select( range => $"[{range.Start:x4}..{range.InclusiveEnd:x4}]"))); output.WriteLine(); } } output.Unindent(); output.WriteLine("}"); }
public void Disassemble(MethodBody body, MemberMapping methodMapping) { // start writing IL code MethodDefinition method = body.Method; output.WriteLine("// Method begins at RVA 0x{0:x4}", method.RVA); output.WriteLine("// Code size {0} (0x{0:x})", body.CodeSize); output.WriteLine(".maxstack {0}", body.MaxStackSize); if (method.DeclaringType.Module.Assembly.EntryPoint == method) { output.WriteLine(".entrypoint"); } if (method.Body.HasVariables) { output.Write(".locals "); if (method.Body.InitLocals) { output.Write("init "); } output.WriteLine("("); output.Indent(); foreach (var v in method.Body.Variables) { output.WriteDefinition("[" + v.Index + "] ", v); v.VariableType.WriteTo(output); if (!string.IsNullOrEmpty(v.Name)) { output.Write(' '); output.Write(DisassemblerHelpers.Escape(v.Name)); } if (v.Index + 1 < method.Body.Variables.Count) { output.Write(','); } output.WriteLine(); } output.Unindent(); output.WriteLine(")"); } output.WriteLine(); if (detectControlStructure && body.Instructions.Count > 0) { Instruction inst = body.Instructions[0]; HashSet <int> branchTargets = GetBranchTargets(body.Instructions); WriteStructureBody(new ILStructure(body), branchTargets, ref inst, methodMapping, method.Body.CodeSize); } else { foreach (var inst in method.Body.Instructions) { inst.WriteTo(output); if (methodMapping != null) { // add IL code mappings - used in debugger methodMapping.MemberCodeMappings.Add( new SourceCodeMapping() { SourceCodeLine = output.CurrentLine, ILInstructionOffset = new ILRange { From = inst.Offset, To = inst.Next == null ? method.Body.CodeSize : inst.Next.Offset }, MemberMapping = methodMapping }); } output.WriteLine(); } if (method.Body.HasExceptionHandlers) { output.WriteLine(); foreach (var eh in method.Body.ExceptionHandlers) { eh.WriteTo(output); output.WriteLine(); } } } }
public static void WriteClass(TypeDefinition def, ITextOutput output) { if (def.IsInterface || Helper.isClassAsEnum(def)) { return; } output.WriteLine("#include <QuantKit/" + def.Name + ".h>"); output.WriteLine(); WriteIncludeBody(def, output); var info = InfoUtil.Info(def); bool isFinalClass = info != null && !info.HasDerivedClass; if (!CppLanguage.IsNeedWriteHxx(def)) { if (info.BaseTypeInModule != null) { output.WriteLine("#include \"" + info.BaseTypeInModule.Name + CppLanguage.HxxFileExtension + "\""); } var tevent = Util.GetTypeDefinition(def.Module, "Event"); if (tevent == def || Util.isInhertFrom(def, tevent)) { if (!CppLanguage.IsNeedWriteHxx(def)) { output.WriteLine("#include <QuantKit/EventType.h>"); } } Hxx.WriteClassBody(def, output); } else { output.WriteLine("#include \"" + def.Name + CppLanguage.HxxFileExtension + "\""); } //output.WriteLine("#include <QuantKit/" + def.Name + CppLanguage.HxxFileExtension + ">"); //output.WriteLine(); //WriteIncludeBody(def, output); output.WriteLine(); output.WriteLine("using namespace QuantKit;"); //output.WriteLine("using namespace QuantKit::Internal;"); output.WriteLine(); //WriteNamespaceStart(def.Namespace, output); //output.WriteLine("namespace Internal {"); //output.WriteLine(); Cxx.WritePrivateClassBody(def, output); //output.WriteLine("} // namespace Internal"); output.WriteLine(); output.WriteLine("// Pubic API "); output.WriteLine(); WriteProxyClassBody(def, output); if (!def.IsInterface && !Helper.isClassAsEnum(def)) { output.WriteLine(); output.WriteLine("QDataStream& " + def.Name + "::operator<<(QDataStream &stream, const " + def.Name + " &" + def.Name.ToLower() + ")"); output.WriteLine("{"); output.Indent(); output.WriteLine("return stream << " + def.Name.ToLower() + ".toString();"); output.Unindent(); output.WriteLine("}"); } output.WriteLine(); //WriteNamespaceEnd(def.Namespace, output); }
void EndKeywordBlock(ITextOutput output) { output.Unindent(); output.WriteRightBrace(); output.WriteLine(); }
public override void Unindent() { output.Unindent(); }
public override void WriteTo(ITextOutput output) { if (Code.isExpression()) { WriteExpression(output); } else { switch (Code) { case GMCode.Constant: // primitive c# type WriteOperand(output); break; case GMCode.Var: // should be ILVariable if (Arguments.Count > 0) { WriteArgument(output, 0, false); } else { output.Write("stack"); } output.Write("."); WriteOperand(output, false); // generic, string name if (Arguments.Count > 1) // its an array { output.Write('['); WriteArgument(output, 1, false); output.Write(']'); } break; case GMCode.Call: output.Write(Operand.ToString()); WriteCommaArguments(output); break; case GMCode.Pop: if (Operand == null) { output.Write(POPDefaultString); } else { output.Write("Pop("); WriteOperand(output, false); // generic, string name output.Write(" = "); output.Write(POPDefaultString); output.Write(")"); } break; case GMCode.Assign: WriteArgumentOrPop(output, 0, false); output.Write(" = "); WriteArgumentOrPop(output, 1, true); break; case GMCode.Popz: output.Write("Popz"); break; case GMCode.Push: output.Write("Push "); if (Operand != null) { output.Write("(Operand="); WriteOperand(output, true); output.Write(")"); } if (Arguments.Count > 0) { output.Write("(Arguments="); WriteArgumentOrPop(output, 0); output.Write(")"); } break; case GMCode.Dup: output.Write("Dup "); output.Write(Operand.ToString()); break; case GMCode.B: // this is where the magic happens...woooooooooo output.Write("goto "); WriteOperand(output); break; case GMCode.Bf: if (Arguments.Count > 0) { output.Write("Push("); Arguments[0].WriteTo(output); output.Write(")"); } output.Write("Branch IfFalse "); WriteOperand(output); break; case GMCode.Bt: if (Arguments.Count > 0) { output.Write("Push("); Arguments[0].WriteTo(output); output.Write(")"); } output.Write("BranchIfTrue "); WriteOperand(output); break; case GMCode.Pushenv: output.Write("PushEnviroment("); WriteArgumentOrPop(output, 0, false); output.Write(") : "); WriteOperand(output, false); break; case GMCode.Popenv: output.Write("PopEnviroment "); WriteOperand(output); break; case GMCode.Exit: // exit without output.Write("return; // exit"); return; case GMCode.Ret: output.Write("return "); WriteArgumentOrPop(output, 0); break; case GMCode.LoopOrSwitchBreak: output.Write("break"); break; case GMCode.LoopContinue: output.Write("continue"); break; case GMCode.DefaultCase: output.Write("default: goto "); WriteOperand(output); break; case GMCode.Case: output.Write("case "); WriteArgumentOrPop(output, 0); output.Write(": goto "); WriteOperand(output); break; case GMCode.Switch: // debug print of the created switch statement output.Write("switch("); WriteArgument(output, 0); output.Write(") {"); output.WriteLine(); output.Indent(); for (int i = 1; i < Arguments.Count; i++) { WriteArgument(output, i); output.Write(';'); output.WriteLine(); } output.Unindent(); output.Write("}"); output.WriteLine(); break; default: throw new Exception("Not Implmented! ugh"); } } }
public void Disassemble(MethodDef method, MemberMapping debugSymbols) { // start writing IL code CilBody body = method.Body; uint codeSize = (uint)body.GetCodeSize(); uint rva = (uint)method.RVA; long offset = method.Module.ToFileOffset(rva); if (options.ShowTokenAndRvaComments) { output.WriteLine(string.Format("// Header Size: {0} {1}", method.Body.HeaderSize, method.Body.HeaderSize == 1 ? "byte" : "bytes"), TextTokenType.Comment); output.WriteLine(string.Format("// Code Size: {0} (0x{0:X}) {1}", codeSize, codeSize == 1 ? "byte" : "bytes"), TextTokenType.Comment); if (body.LocalVarSigTok != 0) { output.WriteLine(string.Format("// LocalVarSig Token: 0x{0:X8} RID: {1}", body.LocalVarSigTok, body.LocalVarSigTok & 0xFFFFFF), TextTokenType.Comment); } } output.Write(".maxstack", TextTokenType.ILDirective); output.WriteSpace(); output.WriteLine(string.Format("{0}", body.MaxStack), TextTokenType.Number); if (method.DeclaringType.Module.EntryPoint == method) { output.WriteLine(".entrypoint", TextTokenType.ILDirective); } if (method.Body.HasVariables) { output.Write(".locals", TextTokenType.ILDirective); output.WriteSpace(); if (method.Body.InitLocals) { output.Write("init", TextTokenType.Keyword); output.WriteSpace(); } output.WriteLine("(", TextTokenType.Operator); output.Indent(); foreach (var v in method.Body.Variables) { output.Write('[', TextTokenType.Operator); output.WriteDefinition(v.Index.ToString(), v, TextTokenType.Number); output.Write(']', TextTokenType.Operator); output.WriteSpace(); v.Type.WriteTo(output); if (!string.IsNullOrEmpty(v.Name)) { output.WriteSpace(); output.Write(DisassemblerHelpers.Escape(v.Name), TextTokenType.Local); } if (v.Index + 1 < method.Body.Variables.Count) { output.Write(',', TextTokenType.Operator); } output.WriteLine(); } output.Unindent(); output.WriteLine(")", TextTokenType.Operator); } output.WriteLine(); uint baseRva = rva == 0 ? 0 : rva + method.Body.HeaderSize; long baseOffs = baseRva == 0 ? 0 : method.Module.ToFileOffset(baseRva); using (var byteReader = !options.ShowILBytes || options.CreateInstructionBytesReader == null ? null : options.CreateInstructionBytesReader(method)) { if (detectControlStructure && body.Instructions.Count > 0) { int index = 0; HashSet <uint> branchTargets = GetBranchTargets(body.Instructions); WriteStructureBody(body, new ILStructure(body), branchTargets, ref index, debugSymbols, method.Body.GetCodeSize(), baseRva, baseOffs, byteReader, method); } else { var instructions = method.Body.Instructions; for (int i = 0; i < instructions.Count; i++) { var inst = instructions[i]; var startLocation = output.Location; inst.WriteTo(output, options, baseRva, baseOffs, byteReader, method); if (debugSymbols != null) { // add IL code mappings - used in debugger var next = i + 1 < instructions.Count ? instructions[i + 1] : null; debugSymbols.MemberCodeMappings.Add( new SourceCodeMapping() { StartLocation = output.Location, EndLocation = output.Location, ILInstructionOffset = new ILRange(inst.Offset, next == null ? (uint)method.Body.GetCodeSize() : next.Offset), MemberMapping = debugSymbols }); } output.WriteLine(); } if (method.Body.HasExceptionHandlers) { output.WriteLine(); foreach (var eh in method.Body.ExceptionHandlers) { eh.WriteTo(output, method); output.WriteLine(); } } } } }
public static void ShowUnResolvedFieldAndMethod(ModuleDefinition module, ITextOutput output) { Dictionary <TypeDefinition, Tuple <List <FieldDefinition>, List <MethodDefinition> > > rdict = new Dictionary <TypeDefinition, Tuple <List <FieldDefinition>, List <MethodDefinition> > >(); foreach (var t in module.Types) { if (t.IsEnum) { continue; } if (t.Namespace != "SmartQuant") { continue; } if (t.Name == "CurrencyId" || t.Name == "EventType" || t.Name == "DataObjectType" || t.Name == "AccountDataField") { continue; } List <FieldDefinition> flist = new List <FieldDefinition>(); List <MethodDefinition> mlist = new List <MethodDefinition>(); foreach (var f in t.Fields) { var modifiers = Util.ConvertModifiers(f); if (modifiers.HasFlag(Modifiers.Const)) { continue; } if (!f.Name.StartsWith("m_")) { flist.Add(f); //output.WriteLine("fieldRenameList.Add(Tuple.Create(\"" + t.Name + "\", \"" + f.Name + "\", \"" + f.Name + "\"));"); } } foreach (var m in t.Methods) { if (m.Name.StartsWith("method_") || m.Name.StartsWith("vmethod_")) { mlist.Add(m); //output.WriteLine("methodRenameList.Add(Tuple.Create(\"" + t.Name + "\", \"" + m.Name + "\", \"" + m.Name + "\"));"); } } if (flist.Count() > 0 || mlist.Count() > 0) { rdict.Add(t, Tuple.Create(flist, mlist)); } } foreach (var t in rdict) { output.WriteLine("{ \"" + t.Key.FullName + "\", Tuple.Create( new Dictionary<string, string>(){"); output.Indent(); output.Indent(); output.WriteLine("// field "); foreach (var f in t.Value.Item1) { output.WriteLine("{\"" + f.Name + "\",\"" + f.Name + "\"},"); } output.Unindent(); output.WriteLine("},new Dictionary<string,string>(){"); output.Indent(); output.WriteLine("// method "); foreach (var m in t.Value.Item2) { output.WriteLine("{\"" + m.Name + "\",\"" + m.Name + "\"},"); } output.WriteLine("})"); output.Unindent(); output.Unindent(); output.WriteLine("},"); } }
public void Unindent() { output.Unindent(); }
public static void WriteCurrencyIdCode(TypeDefinition def, ITextOutput output) { output.WriteLine("#include <QuantKit/CurrencyId.h>"); output.WriteLine(); output.WriteLine("#include <boost/multi_index_container.hpp>"); output.WriteLine("#include <boost/multi_index/hashed_index.hpp>"); output.WriteLine("#include <boost/multi_index/ordered_index.hpp>"); output.WriteLine("#include <boost/multi_index/member.hpp>"); output.WriteLine("#include <boost/multi_index/tag.hpp>"); output.WriteLine(); output.WriteLine("#include \"qt_boost.h\""); output.WriteLine(); output.WriteLine("namepsace QuantKit {"); output.WriteLine(); output.WriteLine("class CurrencyItem {"); output.WriteLine("public:"); output.Indent(); output.WriteLine("QString name;"); output.WriteLine("unsigned char code;"); output.WriteLine("CurrencyItem(const QString& currency, unsigned char id) : name(currency), code(id) {}"); output.Unindent(); output.Write("};"); output.WriteLine(); output.WriteLine("struct by_name{};"); output.WriteLine("struct by_code{};"); output.WriteLine(); output.WriteLine("typedef boost::multi_index::multi_index_container<\n CurrencyItem,\n boost::multi_index::indexed_by<\n boost::multi_index::hashed_unique<\n boost::multi_index::tag<by_name>,\n boost::multi_index::member<\n CurrencyItem, QString, &CurrencyItem::name\n >\n >,\n boost::multi_index::hashed_unique<\n boost::multi_index::tag<by_code>,\n boost::multi_index::member<\n CurrencyItem, unsigned char, &CurrencyItem::code\n >\n >\n >\n> CurrencyIdContainer;"); output.WriteLine("\ntypedef CurrencyIdContainer::index<by_name>::type CurrencyId_by_name;\ntypedef CurrencyIdContainer::index<by_code>::type CurrencyId_by_code;\n"); output.WriteLine("static CurrencyIdContainer currencyIds = {"); output.Indent(); List <FieldDefinition> constList = new List <FieldDefinition>(); foreach (var f in def.Fields) { var modifiers = Util.ConvertModifiers(f); if (modifiers.HasFlag(Modifiers.Const) && f.Constant != null) { constList.Add(f); } } for (int i = 0; i < constList.Count(); ++i) { var f = constList[i]; output.Write("{\""); output.Write(f.Name); output.Write("\", "); output.Write(f.Constant.ToString()); if (i < constList.Count() - 1) { output.WriteLine("},"); } else { output.WriteLine("}"); } } output.Unindent(); output.WriteLine("};"); output.WriteLine("\nstatic QString nullstring = QString();\n\nunsigned char CurrencyId::GetId(const QString& name)\n{\n CurrencyId_by_name& index = currencyIds.get<by_name>();\n CurrencyId_by_name::iterator it = index.find(name);\n if (it != index.end())\n return it->code;\n else\n return 0;\n}\n\nconst QString& CurrencyId::GetName(unsigned char id)\n{\n CurrencyId_by_code& index = currencyIds.get<by_code>();\n CurrencyId_by_code::iterator it = index.find(id);\n if (it != index.end())\n return it->name;\n else\n return nullstring;\n}\n\n} // namespace QuantKit"); }
private static void FallbackFormatting(ITextOutput output, CompiledMethod cmethod) { var body = cmethod.DexMethod.Body; body.UpdateInstructionOffsets(); var targetInstructions = body.Instructions.Select(x => x.Operand).OfType<Instruction>().ToList(); targetInstructions.AddRange(body.Exceptions.Select(x => x.TryStart)); targetInstructions.AddRange(body.Exceptions.Select(x => x.TryEnd)); targetInstructions.AddRange(body.Exceptions.SelectMany(x => x.Catches, (h, y) => y.Instruction)); targetInstructions.AddRange(body.Exceptions.Select(x => x.CatchAll)); foreach (var ins in body.Instructions) { if (targetInstructions.Contains(ins) || (ins.Offset == 0)) { output.Write(string.Format("D_{0:X4}:", ins.Offset)); output.WriteLine(); } output.Indent(); output.Write(ins.ToString()); output.WriteLine(); output.Unindent(); } if (body.Exceptions.Any()) { output.WriteLine(); output.Write("Exception handlers:"); output.WriteLine(); output.Indent(); foreach (var handler in body.Exceptions) { output.Write(string.Format("{0:x4}-{1:x4}", handler.TryStart.Offset, handler.TryEnd.Offset)); output.WriteLine(); output.Indent(); foreach (var c in handler.Catches) { output.Write(string.Format("{0} => {1:x4}", c.Type, c.Instruction.Offset)); output.WriteLine(); } if (handler.CatchAll != null) { output.Write(string.Format("{0} => {1:x4}", "<any>", handler.CatchAll.Offset)); output.WriteLine(); } output.Unindent(); } output.Unindent(); } }
void EndKeywordBlock(ITextOutput output) { output.Unindent(); output.WriteRightBrace(); output.WriteLine(); }
public void Unindent() { _inner.Unindent(); }
private void DisassembleMethodInternal(MethodDefinition method) { // .method public hidebysig specialname // instance default class [mscorlib]System.IO.TextWriter get_BaseWriter () cil managed // //emit flags WriteEnum(method.Attributes & MethodAttributes.MemberAccessMask, _methodVisibility); WriteFlags(method.Attributes & ~MethodAttributes.MemberAccessMask, _methodAttributeFlags); if (method.IsCompilerControlled) { _output.Write("privatescope "); } if ((method.Attributes & MethodAttributes.PInvokeImpl) == MethodAttributes.PInvokeImpl) { _output.Write("pinvokeimpl"); if (method.HasPInvokeInfo && method.PInvokeInfo != null) { var info = method.PInvokeInfo; _output.Write("(\"" + TextWriterTokenWriter.ConvertString(info.Module.Name) + "\""); if (!string.IsNullOrEmpty(info.EntryPoint) && info.EntryPoint != method.Name) { _output.Write(" as \"" + TextWriterTokenWriter.ConvertString(info.EntryPoint) + "\""); } if (info.IsNoMangle) { _output.Write(" nomangle"); } if (info.IsCharSetAnsi) { _output.Write(" ansi"); } else if (info.IsCharSetAuto) { _output.Write(" autochar"); } else if (info.IsCharSetUnicode) { _output.Write(" unicode"); } if (info.SupportsLastError) { _output.Write(" lasterr"); } if (info.IsCallConvCdecl) { _output.Write(" cdecl"); } else if (info.IsCallConvFastcall) { _output.Write(" fastcall"); } else if (info.IsCallConvStdCall) { _output.Write(" stdcall"); } else if (info.IsCallConvThiscall) { _output.Write(" thiscall"); } else if (info.IsCallConvWinapi) { _output.Write(" winapi"); } _output.Write(')'); } _output.Write(' '); } _output.WriteLine(); _output.Indent(); if (method.ExplicitThis) { _output.Write("instance explicit "); } else if (method.HasThis) { _output.Write("instance "); } //call convention // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags WriteEnum(method.CallingConvention & (MethodCallingConvention)0x1f, _callingConvention); //return type method.ReturnType.WriteTo(_output); _output.Write(' '); if (method.MethodReturnType.HasMarshalInfo) { WriteMarshalInfo(method.MethodReturnType.MarshalInfo); } _output.Write(method.IsCompilerControlled ? DisassemblerHelpers.Escape(method.Name + "$PST" + method.MetadataToken.ToInt32().ToString("X8")) : DisassemblerHelpers.Escape(method.Name)); WriteTypeParameters(_output, method); //( params ) _output.Write(" ("); if (method.HasParameters) { _output.WriteLine(); _output.Indent(); WriteParameters(method.Parameters); _output.Unindent(); } _output.Write(") "); //cil managed WriteEnum(method.ImplAttributes & MethodImplAttributes.CodeTypeMask, _methodCodeType); _output.Write((method.ImplAttributes & MethodImplAttributes.ManagedMask) == MethodImplAttributes.Managed ? "managed " : "unmanaged "); WriteFlags(method.ImplAttributes & ~(MethodImplAttributes.CodeTypeMask | MethodImplAttributes.ManagedMask), _methodImpl); _output.Unindent(); OpenBlock(defaultCollapsed: _isInType); WriteAttributes(method.CustomAttributes); if (method.HasOverrides) { foreach (var methodOverride in method.Overrides) { _output.Write(".override method "); methodOverride.WriteTo(_output); _output.WriteLine(); } } WriteParameterAttributes(0, method.MethodReturnType, method.MethodReturnType); foreach (var p in method.Parameters) { WriteParameterAttributes(p.Index + 1, p, p); } WriteSecurityDeclarations(method); if (method.HasBody) { // create IL code mappings - used in debugger _methodBodyDisassembler.Disassemble(method.Body); } CloseBlock("end of method " + DisassemblerHelpers.Escape(method.DeclaringType.Name) + "::" + DisassemblerHelpers.Escape(method.Name)); }
public void Disassemble(MethodBody body) { // start writing IL code var method = body.Method; _output.WriteLine("// Method begins at RVA 0x{0:x4}", method.RVA); _output.WriteLine("// Code size {0} (0x{0:x})", body.CodeSize); _output.WriteLine(".maxstack {0}", body.MaxStackSize); if (method.DeclaringType.Module.Assembly != null && method.DeclaringType.Module.Assembly.EntryPoint == method) { _output.WriteLine(".entrypoint"); } if (method.Body.HasVariables) { _output.Write(".locals "); if (method.Body.InitLocals) { _output.Write("init "); } _output.WriteLine("("); _output.Indent(); foreach (var v in method.Body.Variables) { _output.WriteDefinition("[" + v.Index + "] ", v); v.VariableType.WriteTo(_output); if (!string.IsNullOrEmpty(v.ToString())) { _output.Write(' '); _output.Write(DisassemblerHelpers.Escape(v.ToString())); } if (v.Index + 1 < method.Body.Variables.Count) { _output.Write(','); } _output.WriteLine(); } _output.Unindent(); _output.WriteLine(")"); } _output.WriteLine(); if (_detectControlStructure && body.Instructions.Count > 0) { var inst = body.Instructions[0]; var branchTargets = GetBranchTargets(body.Instructions); WriteStructureBody(new ILStructure(body), branchTargets, ref inst); } else { foreach (var inst in method.Body.Instructions) { inst.WriteTo(_output); _output.WriteLine(); } if (method.Body.HasExceptionHandlers) { _output.WriteLine(); foreach (var eh in method.Body.ExceptionHandlers) { eh.WriteTo(_output); _output.WriteLine(); } } } }