public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options) { if (!method.HasBody) { return; } ILAstBuilder astBuilder = new ILAstBuilder(); ILBlock ilMethod = new ILBlock(); ilMethod.Body = astBuilder.Build(method, inlineVariables); if (abortBeforeStep != null) { DecompilerContext context = new DecompilerContext(method.Module) { CurrentType = method.DeclaringType, CurrentMethod = method }; new ILAstOptimizer().Optimize(context, ilMethod, abortBeforeStep.Value); } var allVariables = ilMethod.GetSelfAndChildrenRecursive<ILExpression>().Select(e => e.Operand as ILVariable) .Where(v => v != null && !v.IsParameter).Distinct(); foreach (ILVariable v in allVariables) { output.WriteDefinition(v.Name, v); if (v.Type != null) { output.Write(" : "); if (v.IsPinned) output.Write("pinned "); v.Type.WriteTo(output, ILNameSyntax.ShortTypeName); } output.WriteLine(); } output.WriteLine(); foreach (ILNode node in ilMethod.Body) { node.WriteTo(output); output.WriteLine(); } }
public void Decompile(Stream assemblyStream, TextWriter resultWriter) { // ReSharper disable once AgentHeisenbug.CallToNonThreadSafeStaticMethodInThreadSafeType var module = ModuleDefinition.ReadModule(assemblyStream); ((BaseAssemblyResolver)module.AssemblyResolver).AddSearchDirectory( Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ); var context = new DecompilerContext(module) { Settings = { AnonymousMethods = false, YieldReturn = false, AsyncAwait = false, AutomaticProperties = false, ExpressionTrees = false } }; var ast = new AstBuilder(context); ast.AddAssembly(module.Assembly); RunTransforms(ast, context); // I cannot use GenerateCode as it re-runs all the transforms var userCode = GetUserCode(ast); WriteResult(resultWriter, userCode, context); }
public ILBlockTranslator(AssemblyTranslator translator, DecompilerContext context, MethodReference methodReference, MethodDefinition methodDefinition, ILBlock ilb, IEnumerable<ILVariable> parameters, IEnumerable<ILVariable> allVariables) { Translator = translator; Context = context; ThisMethodReference = methodReference; ThisMethod = methodDefinition; Block = ilb; SpecialIdentifiers = new JSIL.SpecialIdentifiers(TypeSystem); if (methodReference.HasThis) Variables.Add("this", JSThisParameter.New(methodReference.DeclaringType, methodReference)); foreach (var parameter in parameters) { if ((parameter.Name == "this") && (parameter.OriginalParameter.Index == -1)) continue; ParameterNames.Add(parameter.Name); Variables.Add(parameter.Name, new JSParameter(parameter.Name, parameter.Type, methodReference)); } foreach (var variable in allVariables) { var v = JSVariable.New(variable, methodReference); if (Variables.ContainsKey(v.Identifier)) { v = new JSVariable(variable.OriginalVariable.Name, variable.Type, methodReference); RenamedVariables[variable] = v; Variables.Add(v.Identifier, v); } else { Variables.Add(v.Identifier, v); } } }
/// <summary> /// Public translation interface. /// Translates the given method to GLSL /// </summary> /// <param name="s">Shader type definition.</param> /// <param name="m">A method representing a shader to translate.</param> /// <param name="attr">The shader type as attribute (either FragmentShaderAttribute or VertexShaderAttribute</param> /// <param name="type">The shader type as ShaderType</param> /// <returns>The translated GLSL shader source</returns> public FunctionDescription Transform(TypeDefinition s, MethodDefinition m, CustomAttribute attr, ShaderType type) { if (s == null) throw new ArgumentNullException("s"); if (m == null) throw new ArgumentNullException("m"); if (attr == null) throw new ArgumentNullException("attr"); var ctx = new DecompilerContext(s.Module) { CurrentType = s, CurrentMethod = m, CancellationToken = CancellationToken.None }; var d = AstMethodBodyBuilder.CreateMethodBody(m, ctx); var glsl = new GlslVisitor(d, attr, ctx); _functions.UnionWith(glsl.Functions); var entry = (bool)attr.ConstructorArguments.FirstOrDefault().Value; var sig = entry ? "void main()" : GlslVisitor.GetSignature(m); var code = glsl.Result; var desc = new FunctionDescription(entry ? "main" : Shader.GetMethodName(m), sig + code, entry, type); _dependencies.UnionWith(glsl.Dependencies); return desc; }
public void DecompileOnDemand(TypeDefinition type) { if (type == null) return; if (CheckMappings(type.MetadataToken.ToInt32())) return; try { DecompilerContext context = new DecompilerContext(type.Module); AstBuilder astBuilder = new AstBuilder(context); astBuilder.AddType(type); astBuilder.GenerateCode(new PlainTextOutput()); int token = type.MetadataToken.ToInt32(); var info = new DecompileInformation { CodeMappings = astBuilder.CodeMappings, LocalVariables = astBuilder.LocalVariables, DecompiledMemberReferences = astBuilder.DecompiledMemberReferences }; // save the data DebugInformation.AddOrUpdate(token, info, (k, v) => info); } catch { return; } }
public static async Task<string> GetSourceCode(MethodDefinition methodDefinition, ILWeaver weaver = null) { return await Task.Run(() => { try { if (weaver != null) weaver.Apply(methodDefinition.Body); var settings = new DecompilerSettings { UsingDeclarations = false }; var context = new DecompilerContext(methodDefinition.Module) { CurrentType = methodDefinition.DeclaringType, Settings = settings }; var astBuilder = new AstBuilder(context); astBuilder.AddMethod(methodDefinition); var textOutput = new PlainTextOutput(); astBuilder.GenerateCode(textOutput); return textOutput.ToString(); } catch (Exception ex) { return "Error in creating source code from IL: " + ex.Message + Environment.NewLine + ex.StackTrace; } finally { if (weaver != null) methodDefinition.Body = null; } }); }
public override void DecompileMethod(MethodDef method, ITextOutput output, DecompilationOptions options) { WriteComment(output, "Method: "); output.WriteDefinition(IdentifierEscaper.Escape(method.FullName), method, TextTokenType.Comment, false); output.WriteLine(); if (!method.HasBody) { return; } StartKeywordBlock(output, ".body", method); ILAstBuilder astBuilder = new ILAstBuilder(); ILBlock ilMethod = new ILBlock(); DecompilerContext context = new DecompilerContext(method.Module) { CurrentType = method.DeclaringType, CurrentMethod = method }; ilMethod.Body = astBuilder.Build(method, inlineVariables, context); if (abortBeforeStep != null) { new ILAstOptimizer().Optimize(context, ilMethod, abortBeforeStep.Value); } if (context.CurrentMethodIsAsync) { output.Write("async", TextTokenType.Keyword); output.Write('/', TextTokenType.Operator); output.WriteLine("await", TextTokenType.Keyword); } var allVariables = ilMethod.GetSelfAndChildrenRecursive<ILExpression>().Select(e => e.Operand as ILVariable) .Where(v => v != null && !v.IsParameter).Distinct(); foreach (ILVariable v in allVariables) { output.WriteDefinition(IdentifierEscaper.Escape(v.Name), v, v.IsParameter ? TextTokenType.Parameter : TextTokenType.Local); if (v.Type != null) { output.WriteSpace(); output.Write(':', TextTokenType.Operator); output.WriteSpace(); if (v.IsPinned) { output.Write("pinned", TextTokenType.Keyword); output.WriteSpace(); } v.Type.WriteTo(output, ILNameSyntax.ShortTypeName); } if (v.IsGenerated) { output.WriteSpace(); output.Write('[', TextTokenType.Operator); output.Write("generated", TextTokenType.Keyword); output.Write(']', TextTokenType.Operator); } output.WriteLine(); } var memberMapping = new MemberMapping(method); foreach (ILNode node in ilMethod.Body) { node.WriteTo(output, memberMapping); if (!node.WritesNewLine) output.WriteLine(); } output.AddDebugSymbols(memberMapping); EndKeywordBlock(output); }
public TextTokenWriter(ITextOutput output, DecompilerContext context) { if (output == null) throw new ArgumentNullException("output"); if (context == null) throw new ArgumentNullException("context"); this.output = output; this.context = context; }
public AstBuilder(DecompilerContext context) { if (context == null) throw new ArgumentNullException("context"); this.context = context; this.DecompileMethodBodies = true; this.LocalVariables = new ConcurrentDictionary<int, IEnumerable<ILVariable>>(); }
//private IEnumerable<AstNode> FlattenScript(TypeDeclaration scriptClass) { // foreach (var member in scriptClass.Members) { // var constructor = member as ConstructorDeclaration; // if (constructor != null) { // foreach (var statement in constructor.Body.Statements) { // yield return statement; // } // } // else { // yield return member; // } // } //} private void RunTransforms(AstBuilder ast, DecompilerContext context) { var transforms = TransformationPipeline.CreatePipeline(context).ToList(); transforms[transforms.FindIndex(t => t is ConvertConstructorCallIntoInitializer)] = new RoslynFriendlyConvertConstructorCallIntoInitializer(); foreach (var transform in transforms) { transform.Run(ast.SyntaxTree); } }
AstBuilder CreateBuilder(IDnlibDef item, CancellationToken token) { ModuleDef moduleDef; DecompilerContext ctx; AstBuilder builder; if (item is ModuleDef) { var def = (ModuleDef)item; moduleDef = def; builder = new AstBuilder(ctx = new DecompilerContext(moduleDef) { CancellationToken = token }); builder.AddAssembly(def, true); } else if (item is TypeDef) { var def = (TypeDef)item; moduleDef = def.Module; builder = new AstBuilder(ctx = new DecompilerContext(moduleDef) { CancellationToken = token }); builder.DecompileMethodBodies = false; ctx.CurrentType = def; builder.AddType(def); } else if (item is MethodDef) { var def = (MethodDef)item; moduleDef = def.Module; builder = new AstBuilder(ctx = new DecompilerContext(moduleDef) { CancellationToken = token }); ctx.CurrentType = def.DeclaringType; builder.AddMethod(def); } else if (item is FieldDef) { var def = (FieldDef)item; moduleDef = def.Module; builder = new AstBuilder(ctx = new DecompilerContext(moduleDef) { CancellationToken = token }); ctx.CurrentType = def.DeclaringType; builder.AddField(def); } else if (item is PropertyDef) { var def = (PropertyDef)item; moduleDef = def.Module; builder = new AstBuilder(ctx = new DecompilerContext(moduleDef) { CancellationToken = token }); ctx.CurrentType = def.DeclaringType; builder.AddProperty(def); } else if (item is EventDef) { var def = (EventDef)item; moduleDef = def.Module; builder = new AstBuilder(ctx = new DecompilerContext(moduleDef) { CancellationToken = token }); ctx.CurrentType = def.DeclaringType; builder.AddEvent(def); } else return null; ctx.Settings = new DecompilerSettings { UsingDeclarations = false }; return builder; }
protected override void WriteResult(TextWriter writer, IEnumerable<AstNode> ast, DecompilerContext context) { var visitor = new DecompiledPseudoCSharpOutputVisitor( new TextWriterOutputFormatter(writer) { IndentationString = " " }, context.Settings.CSharpFormattingOptions ); foreach (var node in ast) { node.AcceptVisitor(visitor); } }
public GlslVisitor(BlockStatement block, CustomAttribute attr, DecompilerContext ctx) : this() { _attr = attr; var trans1 = new ReplaceMethodCallsWithOperators(ctx); var trans2 = new RenameLocals(); ((IAstTransform)trans1).Run(block); trans2.Run(block); Result = block.AcceptVisitor(this, 0).ToString(); Result += Environment.NewLine; }
public void EmitField(DecompilerContext context, IAstEmitter astEmitter, FieldDefinition field, JSRawOutputIdentifier dollar, JSExpression defaultValue) { var fieldInfo = Translator.TypeInfoProvider.GetField(field); var typeKeyword = WasmUtil.PickTypeKeyword(fieldInfo.FieldType); // Unhandled type if (typeKeyword == null) return; Switch(PrecedingType.Global); Formatter.WriteRaw("(global ${0} {1})", WasmUtil.EscapeIdentifier(fieldInfo.Name), typeKeyword); Formatter.ConditionalNewLine(); }
public static string ToSource(MethodDefinition methodDefinition) { var settings = new DecompilerSettings { UsingDeclarations = false }; var context = new DecompilerContext(methodDefinition.Module) { CurrentType = methodDefinition.DeclaringType, Settings = settings, }; var astBuilder = new AstBuilder(context); astBuilder.AddMethod(methodDefinition); var textOutput = new PlainTextOutput(); astBuilder.GenerateCode(textOutput); return textOutput.ToString(); }
protected override void WriteResult(TextWriter writer, IEnumerable<AstNode> ast, DecompilerContext context) { var converter = new CSharpToVBConverterVisitor(new ILSpyEnvironmentProvider()); var visitor = new OutputVisitor( new VBTextOutputFormatter(new CustomizableIndentPlainTextOutput(writer) { IndentationString = " " }), new VBFormattingOptions() ); foreach (var node in ast) { node.AcceptVisitor(new InsertParenthesesVisitor { InsertParenthesesForReadability = true }); var converted = node.AcceptVisitor(converter, null); converted.AcceptVisitor(visitor, null); } }
public Dictionary<int, EventRegistration[]> DecompileEventMappings(string fullTypeName) { var result = new Dictionary<int, EventRegistration[]>(); TypeDefinition type = this.assembly.MainModule.GetType(fullTypeName); if (type == null) return result; MethodDefinition def = null; foreach (var method in type.Methods) { if (method.Name == "System.Windows.Markup.IComponentConnector.Connect") { def = method; break; } } if (def == null) return result; // decompile method and optimize the switch ILBlock ilMethod = new ILBlock(); ILAstBuilder astBuilder = new ILAstBuilder(); ILAstOptimizer optimizer = new ILAstOptimizer(); var context = new DecompilerContext(type.Module) { CurrentMethod = def, CurrentType = type }; ilMethod.Body = astBuilder.Build(def, true, context); optimizer.Optimize(context, ilMethod, ILAstOptimizationStep.RemoveRedundantCode3); ILSwitch ilSwitch = ilMethod.Body.OfType<ILSwitch>().FirstOrDefault(); ILCondition condition = ilMethod.Body.OfType<ILCondition>().FirstOrDefault(); if (ilSwitch != null) { foreach (var caseBlock in ilSwitch.CaseBlocks) { if (caseBlock.Values == null) continue; var events = FindEvents(caseBlock); foreach (int id in caseBlock.Values) result.Add(id, events); } } else if (condition != null) { result.Add(1, FindEvents(condition.FalseBlock)); } return result; }
internal static IEnumerable<CSharpLanguage> GetDebugLanguages() { DecompilerContext context = new DecompilerContext(ModuleDefinition.CreateModule("dummy", ModuleKind.Dll)); string lastTransformName = "no transforms"; foreach (Type _transformType in TransformationPipeline.CreatePipeline(context).Select(v => v.GetType()).Distinct()) { Type transformType = _transformType; // copy for lambda yield return new CSharpLanguage { transformAbortCondition = v => transformType.IsInstanceOfType(v), name = "C# - " + lastTransformName, showAllMembers = true }; lastTransformName = "after " + transformType.Name; } yield return new CSharpLanguage { name = "C# - " + lastTransformName, showAllMembers = true }; }
internal static IEnumerable<CSharpDecompiler> GetDebugDecompilers(CSharpVBDecompilerSettings langSettings) { DecompilerContext context = new DecompilerContext(new ModuleDefUser("dummy"), CSharpMetadataTextColorProvider.Instance); string lastTransformName = "no transforms"; double orderUI = DecompilerConstants.CSHARP_ILSPY_DEBUG_ORDERUI; uint id = 0xBF67AF3F; foreach (Type _transformType in TransformationPipeline.CreatePipeline(context).Select(v => v.GetType()).Distinct()) { Type transformType = _transformType; // copy for lambda yield return new CSharpDecompiler(langSettings, orderUI++) { transformAbortCondition = v => transformType.IsInstanceOfType(v), uniqueNameUI = "C# - " + lastTransformName, uniqueGuid = new Guid($"203F702E-7E87-4F01-84CD-B0E8{id++:X8}"), showAllMembers = true }; lastTransformName = "after " + transformType.Name; } yield return new CSharpDecompiler(langSettings, orderUI++) { uniqueNameUI = "C# - " + lastTransformName, uniqueGuid = new Guid($"203F702E-7E87-4F01-84CD-B0E8{id++:X8}"), showAllMembers = true }; }
public static async Task<string> GetSourceCode(TypeDefinition typeDefinition) { return await Task.Run(() => { try { var settings = new DecompilerSettings { UsingDeclarations = true }; var context = new DecompilerContext(typeDefinition.Module) { CurrentType = typeDefinition, Settings = settings }; var astBuilder = new AstBuilder(context); var textOutput = new PlainTextOutput(); astBuilder.GenerateCode(textOutput); return textOutput.ToString(); } catch (Exception ex) { return "Error in creating source code from Type: " + ex.Message + ex.Message + Environment.NewLine + ex.StackTrace; } }); }
public static IAstTransform[] CreatePipeline(DecompilerContext context) { // from ICSharpCode.Decompiler.Ast.Transforms.TransformationPipeline return new IAstTransform[] { new PushNegation(), new DelegateConstruction(context), new PatternStatementTransform(context), new ReplaceMethodCallsWithOperators(context), new IntroduceUnsafeModifier(), new AddCheckedBlocks(), new DeclareVariables(context), // should run after most transforms that modify statements new ConvertConstructorCallIntoInitializer(), // must run after DeclareVariables new DecimalConstantTransform(), new IntroduceUsingDeclarations(context), //new IntroduceExtensionMethods(context), // must run after IntroduceUsingDeclarations //new IntroduceQueryExpressions(context), // must run after IntroduceExtensionMethods //new CombineQueryExpressions(context), //new FlattenSwitchBlocks(), new FixBadNames(), new RemoveAnnot() }; }
CodeGeneratorMemberResult GenerateCode (IMethod method, CodeGenerationOptions options) { int bodyStartOffset = -1, bodyEndOffset = -1; StringBuilder result = new StringBuilder (); AppendObsoleteAttribute (result, options, method); AppendModifiers (result, options, method); if (method.IsPartial) result.Append ("partial "); AppendReturnType (result, options, method.ReturnType); result.Append (" "); if (options.ExplicitDeclaration) { AppendReturnType (result, options, method.DeclaringType); result.Append ("."); } result.Append (CSharpAmbience.FilterName (method.Name)); if (method.TypeParameters.Count > 0) { result.Append ("<"); for (int i = 0; i < method.TypeParameters.Count; i++) { if (i > 0) result.Append (", "); var p = method.TypeParameters [i]; result.Append (CSharpAmbience.FilterName (p.Name)); } result.Append (">"); } if (Policy.BeforeMethodDeclarationParentheses) result.Append (" "); result.Append ("("); AppendParameterList (result, options, method.Parameters); result.Append (")"); var typeParameters = method.TypeParameters; // This should also check the types are in the correct mscorlib Func<IType, bool> validBaseType = t => t.FullName != "System.Object" && t.FullName != "System.ValueType"; bool isFromInterface = method.DeclaringType != null && method.DeclaringTypeDefinition.Kind == TypeKind.Interface; if (!options.ExplicitDeclaration && isFromInterface && typeParameters.Any (p => p.HasDefaultConstructorConstraint || p.HasReferenceTypeConstraint || p.HasValueTypeConstraint || p.DirectBaseTypes.Any (validBaseType))) { result.Append (" where "); int typeParameterCount = 0; foreach (var p in typeParameters) { if (typeParameterCount != 0) result.Append (", "); typeParameterCount++; result.Append (CSharpAmbience.FilterName (p.Name)); result.Append (" : "); int constraintCount = 0; if (p.HasDefaultConstructorConstraint) { result.Append ("new ()"); constraintCount++; } if (p.HasValueTypeConstraint) { if (constraintCount != 0) result.Append (", "); result.Append ("struct"); constraintCount++; } if (p.HasReferenceTypeConstraint) { if (constraintCount != 0) result.Append (", "); result.Append ("class"); constraintCount++; } // bool hadInterfaces = false; foreach (var c in p.DirectBaseTypes.Where (validBaseType)) { if (constraintCount != 0) result.Append (", "); constraintCount++; AppendReturnType (result, options, c); // if (c.Kind == TypeKind.Interface) // hadInterfaces = true; } } } if (options.ImplementingType.Kind == TypeKind.Interface) { result.Append (";"); } else { AppendBraceStart (result, Policy.MethodBraceStyle); if (method.Name == "ToString" && (method.Parameters == null || method.Parameters.Count == 0) && method.ReturnType != null/* && method.ReturnType.FullName == "System.String"*/) { AppendIndent (result); bodyStartOffset = result.Length; result.Append ("return string.Format"); if (Policy.BeforeMethodDeclarationParentheses) result.Append (" "); result.Append ("(\"["); result.Append (options.ImplementingType.Name); if (options.ImplementingType.Properties.Any ()) result.Append (": "); int i = 0; foreach (IProperty property in options.ImplementingType.Properties) { if (property.IsStatic || !property.IsPublic) continue; if (i > 0) result.Append (", "); result.Append (property.Name); result.Append ("={"); result.Append (i++); result.Append ("}"); } result.Append ("]\""); foreach (IProperty property in options.ImplementingType.Properties) { if (property.IsStatic || !property.IsPublic) continue; result.Append (", "); result.Append (property.Name); } result.Append (");"); bodyEndOffset = result.Length; AppendLine (result); } else if (IsMonoTouchModelMember (method)) { AppendMonoTouchTodo (result, options, out bodyStartOffset, out bodyEndOffset); } else if (method.IsAbstract || !(method.IsVirtual || method.IsOverride) || method.DeclaringTypeDefinition.Kind == TypeKind.Interface) { AppendNotImplementedException (result, options, out bodyStartOffset, out bodyEndOffset); } else { bool skipBody = false; // Analyze if the body consists just of a single throw instruction // See: Bug 1373 - overriding [Model] class methods shouldn't insert base.Methods // TODO: Extend this to user defined code. try { if (method.Region.FileName == null) { var asm = AssemblyDefinition.ReadAssembly (method.ParentAssembly.UnresolvedAssembly.Location); foreach (var type in asm.MainModule.Types) { if (type.FullName != method.DeclaringType.FullName) continue; foreach (var m in type.Resolve ().Methods) { if (m.HasBody && m.Name == method.Name) { var context = new DecompilerContext (asm.MainModule); context.CurrentType = type; context.Settings = new DecompilerSettings () { AnonymousMethods = true, AutomaticEvents = true, AutomaticProperties = true, ForEachStatement = true, LockStatement = true }; var astBuilder = new AstBuilder (context); astBuilder.AddMethod (m); astBuilder.RunTransformations (o => false); var visitor = new ThrowsExceptionVisitor (); astBuilder.CompilationUnit.AcceptVisitor (visitor); skipBody = visitor.Throws; if (skipBody) break; } } if (skipBody) break; } } } catch (Exception) { } AppendIndent (result); bodyStartOffset = result.Length; if (!skipBody) { if (method.ReturnType.ReflectionName != typeof(void).FullName) result.Append ("return "); result.Append ("base."); result.Append (CSharpAmbience.FilterName (method.Name)); if (Policy.BeforeMethodCallParentheses) result.Append (" "); result.Append ("("); for (int i = 0; i < method.Parameters.Count; i++) { if (i > 0) result.Append (", "); var p = method.Parameters [i]; if (p.IsOut) result.Append ("out "); if (p.IsRef) result.Append ("ref "); result.Append (CSharpAmbience.FilterName (p.Name)); } result.Append (");"); } else { result.Append ("throw new System.NotImplementedException ();"); } bodyEndOffset = result.Length; AppendLine (result); } AppendBraceEnd (result, Policy.MethodBraceStyle); } return new CodeGeneratorMemberResult (result.ToString (), bodyStartOffset, bodyEndOffset); }
public static List<ReferenceSegment> Decompile (TextEditorData data, ModuleDefinition module, TypeDefinition currentType, Action<AstBuilder> setData, DecompilerSettings settings) { try { var context = new DecompilerContext (module); var source = new CancellationTokenSource (); context.CancellationToken = source.Token; context.CurrentType = currentType; context.Settings = settings; AstBuilder astBuilder = new AstBuilder (context); setData (astBuilder); astBuilder.RunTransformations (o => false); GeneratedCodeSettings.Default.Apply (astBuilder.CompilationUnit); var output = new ColoredCSharpFormatter (data.Document); astBuilder.GenerateCode (output); output.SetDocumentData (); return output.ReferencedSegments; } catch (Exception e) { data.Text = "Decompilation failed: \n" + e; } return null; }
public DelegateConstruction(DecompilerContext context) : base(context) { }
public void EmitEvent ( DecompilerContext context, IAstEmitter astEmitter, EventDefinition @event, JSRawOutputIdentifier dollar ) { if (Translator.ShouldSkipMember(@event)) return; var eventInfo = TypeInfo.GetMemberInformation<Internal.EventInfo>(@event); if ((eventInfo == null) || eventInfo.IsIgnored) return; var isStatic = (@event.AddMethod ?? @event.RemoveMethod).IsStatic; Formatter.NewLine(); dollar.WriteTo(Formatter); Formatter.Dot(); if (eventInfo.IsExternal) Formatter.Identifier("ExternalEvent", EscapingMode.None); else if (@event.DeclaringType.HasGenericParameters && isStatic) Formatter.Identifier("GenericEvent", EscapingMode.None); else Formatter.Identifier("Event", EscapingMode.None); Formatter.LPar(); Formatter.MemberDescriptor(eventInfo.IsPublic, eventInfo.IsStatic, eventInfo.IsVirtual); Formatter.Comma(); Formatter.Value(Util.EscapeIdentifier(eventInfo.Name, EscapingMode.String)); Formatter.Comma(); Formatter.TypeReference(@event.EventType, astEmitter.ReferenceContext); Formatter.RPar(); EmitCustomAttributes(context, @event.DeclaringType, @event, astEmitter); Formatter.Semicolon(); }
protected abstract void WriteResult(TextWriter writer, IEnumerable<AstNode> ast, DecompilerContext context);
void Run(Config config) { if (config.ShowHelp) { Console.WriteLine ("Netjs compiler, Copyright 2014 Frank A. Krueger"); Console.WriteLine ("netjs [options] assembly-file"); return; } if (string.IsNullOrEmpty (config.MainAssembly)) { throw new Exception ("No assembly specified."); } var asmPath = Path.GetFullPath (config.MainAssembly); asmDir = Path.GetDirectoryName (asmPath); var outPath = Path.ChangeExtension (asmPath, ".ts"); Step ("Reading IL"); var parameters = new ReaderParameters { AssemblyResolver = this, }; var asm = AssemblyDefinition.ReadAssembly (asmPath, parameters); mscorlib = AssemblyDefinition.ReadAssembly (typeof(String).Assembly.Location, parameters); system = AssemblyDefinition.ReadAssembly (typeof(INotifyPropertyChanged).Assembly.Location, parameters); systemCore = AssemblyDefinition.ReadAssembly (typeof(Enumerable).Assembly.Location, parameters); Step ("Decompiling IL to C#"); var context = new DecompilerContext (asm.MainModule); context.Settings.ForEachStatement = false; context.Settings.ObjectOrCollectionInitializers = false; context.Settings.UsingStatement = false; context.Settings.AsyncAwait = false; context.Settings.AutomaticProperties = true; context.Settings.AutomaticEvents = true; context.Settings.QueryExpressions = false; context.Settings.AlwaysGenerateExceptionVariableForCatchBlocks = true; context.Settings.UsingDeclarations = false; context.Settings.FullyQualifyAmbiguousTypeNames = true; context.Settings.YieldReturn = false; var builder = new AstBuilder (context); builder.AddAssembly (asm); foreach (var a in referencedAssemblies.Values) { if (a != null) builder.AddAssembly (a); } builder.RunTransformations (); Step ("Translating C# to TypeScript"); new CsToTs ().Run (builder.SyntaxTree); Step ("Writing"); using (var outputWriter = new StreamWriter (outPath)) { var output = new PlainTextOutput (outputWriter); builder.GenerateCode (output, (s, e) => new TsOutputVisitor (s, e)); } Step ("Done"); }
public static DecompilerContext CreateTestContext(ModuleDef currentModule) { var ctx = new DecompilerContext(currentModule); ctx.Settings.InitializeForTest(); return ctx; }
Dictionary<int, Action<XamlContext, XElement>> ExtractConnectionId(XamlContext ctx, MethodDef method) { var context = new DecompilerContext(method.Module) { CurrentType = method.DeclaringType, CurrentMethod = method, CancellationToken = ctx.CancellationToken }; var body = new ILBlock(new ILAstBuilder().Build(method, true, context)); new ILAstOptimizer().Optimize(context, body); var sw = body.GetSelfAndChildrenRecursive<ILSwitch>().FirstOrDefault(); if (sw == null) return null; var connIds = new Dictionary<int, Action<XamlContext, XElement>>(); foreach (var cas in sw.CaseBlocks) { if (cas.Values == null) continue; Action<XamlContext, XElement> cb = null; foreach (var node in cas.Body) { var expr = node as ILExpression; if (expr == null) continue; switch (expr.Code) { case ILCode.Stfld: cb += new FieldAssignment { FieldName = ((IField)expr.Operand).Name }.Callback; break; case ILCode.Call: case ILCode.Callvirt: var operand = (IMethod)expr.Operand; if (operand.Name == "AddHandler" && operand.DeclaringType.FullName == "System.Windows.UIElement") { // Attached event var re = expr.Arguments[1]; var ctor = expr.Arguments[2]; var reField = re.Operand as IField; if (re.Code != ILCode.Ldsfld || ctor.Code != ILCode.Newobj || ctor.Arguments.Count != 2 || ctor.Arguments[1].Code != ILCode.Ldftn) { cb += new Error { Msg = "Attached event '" + reField.Name + "'." }.Callback; break; } var handler = (IMethod)ctor.Arguments[1].Operand; string evName = reField.Name; if (evName.EndsWith("Event")) evName = evName.Substring(0, evName.Length - 5); cb += new EventAttachment { AttachedType = reField.DeclaringType.ResolveTypeDefThrow(), EventName = evName, MethodName = handler.Name }.Callback; } else { // CLR event var add = operand.ResolveMethodDefThrow(); var ev = add.DeclaringType.Events.FirstOrDefault(e => e.AddMethod == add); var ctor = expr.Arguments[1]; if (ev == null || ctor.Code != ILCode.Newobj || ctor.Arguments.Count != 2 || ctor.Arguments[1].Code != ILCode.Ldftn) { cb += new Error { Msg = "Attached event '" + add.Name + "'." }.Callback; break; } var handler = (IMethod)ctor.Arguments[1].Operand; cb += new EventAttachment { EventName = ev.Name, MethodName = handler.Name }.Callback; } break; } } if (cb != null) { foreach (var id in cas.Values) connIds[id] = cb; } } return connIds.Count == 0 ? null : connIds; }
public string GetClass(TypeIdentity identity) { // Before we attempt to fetch it just try a decompilation. GetAssembly(identity.AssemblyPath); ModuleDefinition moduleDef; if (!this.loadedModules.TryGetValue(identity.AssemblyPath, out moduleDef)) { // Can't find the assembly, just return nothing. return string.Empty; } TypeDefinition typeDef = moduleDef.GetType(identity.FullyQualifiedName); if (typeDef == null) { // If we can't find our type just return as well. return string.Empty; } DecompilerContext context = new DecompilerContext(moduleDef); AstBuilder astBuilder = new AstBuilder(context); astBuilder.AddType(typeDef); PlainTextOutput textOutput = new PlainTextOutput(); astBuilder.GenerateCode(textOutput); return textOutput.ToString(); }