Example #1
0
        public void WriteEvent(EventDefinition definition, ISourceCodeOutput output, DecompilerOptions options)
        {
            output.WriteDefinition(".event ", definition);
            output.Write(definition.EventType.ToShortTypeName() + " ");
            output.Write(definition.Name + " ");

            OpenBlock(output);

            if (definition.HasCustomAttributes)
            {
                WriteCustomAttributes(definition.CustomAttributes, output);
            }

            if (definition.AddMethod != null)
            {
                var setter = definition.AddMethod;
                output.Write(".addon ");
                if (setter.HasThis)
                {
                    output.Write("instance ");
                }

                output.Write(
                    setter.ReturnType.IsPrimitive || setter.IsVoid()
          ? setter.ReturnType.Name.ToLowerInvariant()
          : setter.ReturnType.FullName);

                output.WriteSpace();
                //setter.ReturnType == setter.Module.TypeSystem.Void
                //setter.ReturnType.FullName + " " + (setter.DeclaringType.FullName + "::" + setter.Name) + MethodSignatureFullName(setter)
                output.WriteLine("{0}::{1}{2}", setter.DeclaringType.FullName, setter.Name, MethodSignatureFullName(setter));
            }

            if (definition.RemoveMethod != null)
            {
                var getter = definition.RemoveMethod;
                output.Write(".removeon ");
                if (getter.HasThis)
                {
                    output.Write("instance ");
                }

                output.Write(
                    getter.ReturnType.IsPrimitive || getter.IsVoid()
          ? getter.ReturnType.Name.ToLowerInvariant()
          : getter.ReturnType.FullName);

                output.WriteSpace();
                output.WriteLine("{0}::{1}{2}", getter.DeclaringType.FullName, getter.Name, MethodSignatureFullName(getter));
            }

            CloseBlock(output);
        }
Example #2
0
    private void WriteMethodName(MethodDefinition definition, ISourceCodeOutput output, DecompilerOptions options)
    {
      if (definition.IsAssembly) output.Write("assembly ");
      if (definition.IsFamily) output.Write("family ");
      if (definition.IsPublic) output.Write("public ");
      if (definition.IsPrivate) output.Write("private ");
      if (definition.IsHideBySig) output.Write("hidebysig ");
      if (definition.IsSpecialName) output.Write("specialname ");
      if (definition.IsNewSlot) output.Write("newslot ");
      if (definition.IsVirtual) output.Write("virtual ");
      if (definition.IsFinal) output.Write("final ");
      if (definition.IsRuntimeSpecialName) output.Write("rtspecialname ");
      output.Write(definition.IsStatic ? "static " : "instance ");
      output.Write(definition.ReturnType.ToShortTypeName() + " ");

      // Name
      output.Write(GetMethodName(definition));
      WriteMethodParameters(definition, output, options);

      output.WriteSpace();
      if (definition.IsIL) output.Write("cil ");
      if (definition.IsRuntime) output.Write("runtime ");
      if (definition.IsManaged) output.Write("managed ");
    }
Example #3
0
        private void WriteCustomAttributes(IEnumerable <CustomAttribute> attributes, ISourceCodeOutput output)
        {
            foreach (var attribute in attributes)
            {
                var canProceed = attribute.TryCheckConstructorArguments();
                if (!canProceed)
                {
                    Debug.WriteLine("Skipping custom attribute: '{0}'", attribute.Constructor.ToString());
                    continue;
                }

                output.Write(".custom ");

                var ctor = attribute.Constructor;
                if (ctor.HasThis)
                {
                    output.Write("instance ");
                }
                output.Write(ctor.ToString());

                output.Write(" = { ");

                if (attribute.HasConstructorArguments)
                {
                    for (int i = 0; i < attribute.ConstructorArguments.Count; i++)
                    {
                        if (i > 0)
                        {
                            output.WriteSpace();
                        }
                        var    argument    = attribute.ConstructorArguments[i];
                        string valueFormat = argument.Type == argument.Type.Module.TypeSystem.String ? "'{0}'" : "{0}";
                        output.Write("{0}({1})", argument.Type.Name, string.Format(valueFormat, argument.Value));
                    }
                }

                if (attribute.HasProperties)
                {
                    output.WriteSpace();
                    for (int i = 0; i < attribute.Properties.Count; i++)
                    {
                        var property = attribute.Properties[i];
                        if (string.IsNullOrWhiteSpace(property.Name))
                        {
                            continue;
                        }
                        if (i > 0)
                        {
                            output.WriteSpace();
                        }
                        var    argument    = property.Argument;
                        string valueFormat = argument.Type == argument.Type.Module.TypeSystem.String ? "'{0}'" : "{0}";
                        output.Write("{0}={1}({2})", property.Name, argument.Type.Name, string.Format(valueFormat, argument.Value));
                    }
                }

                if (attribute.HasFields)
                {
                    output.WriteSpace();
                    for (int i = 0; i < attribute.Fields.Count; i++)
                    {
                        var field = attribute.Fields[0];
                        if (string.IsNullOrWhiteSpace(field.Name))
                        {
                            continue;
                        }
                        if (i > 0)
                        {
                            output.WriteSpace();
                        }
                        var    argument    = field.Argument;
                        string valueFormat = argument.Type == argument.Type.Module.TypeSystem.String ? "'{0}'" : "{0}";
                        output.Write("{0}={1}({2})", field.Name, argument.Type.Name, string.Format(valueFormat, argument.Value));
                    }
                }

                output.Write(" }");
                output.WriteLine();
            }
        }
Example #4
0
        private void WriteMethodName(MethodDefinition definition, ISourceCodeOutput output, DecompilerOptions options)
        {
            if (definition.IsAssembly)
            {
                output.Write("assembly ");
            }
            if (definition.IsFamily)
            {
                output.Write("family ");
            }
            if (definition.IsPublic)
            {
                output.Write("public ");
            }
            if (definition.IsPrivate)
            {
                output.Write("private ");
            }
            if (definition.IsHideBySig)
            {
                output.Write("hidebysig ");
            }
            if (definition.IsSpecialName)
            {
                output.Write("specialname ");
            }
            if (definition.IsNewSlot)
            {
                output.Write("newslot ");
            }
            if (definition.IsVirtual)
            {
                output.Write("virtual ");
            }
            if (definition.IsFinal)
            {
                output.Write("final ");
            }
            if (definition.IsRuntimeSpecialName)
            {
                output.Write("rtspecialname ");
            }
            output.Write(definition.IsStatic ? "static " : "instance ");
            output.Write(definition.ReturnType.ToShortTypeName() + " ");

            // Name
            output.Write(GetMethodName(definition));
            WriteMethodParameters(definition, output, options);

            output.WriteSpace();
            if (definition.IsIL)
            {
                output.Write("cil ");
            }
            if (definition.IsRuntime)
            {
                output.Write("runtime ");
            }
            if (definition.IsManaged)
            {
                output.Write("managed ");
            }
        }
Example #5
0
    private void WriteCustomAttributes(IEnumerable<CustomAttribute> attributes, ISourceCodeOutput output)
    {
      foreach (var attribute in attributes)
      {
        var canProceed = attribute.TryCheckConstructorArguments();
        if (!canProceed)
        {
          Debug.WriteLine("Skipping custom attribute: '{0}'", attribute.Constructor.ToString());
          continue;
        }

        output.Write(".custom ");

        var ctor = attribute.Constructor;
        if (ctor.HasThis) output.Write("instance ");
        output.Write(ctor.ToString());

        output.Write(" = { ");

        if (attribute.HasConstructorArguments)
        {
          for (int i = 0; i < attribute.ConstructorArguments.Count; i++)
          {
            if (i > 0) output.WriteSpace();
            var argument = attribute.ConstructorArguments[i];
            string valueFormat = argument.Type == argument.Type.Module.TypeSystem.String ? "'{0}'" : "{0}";
            output.Write("{0}({1})", argument.Type.Name, string.Format(valueFormat, argument.Value));
          }
        }

        if (attribute.HasProperties)
        {
          output.WriteSpace();
          for (int i = 0; i < attribute.Properties.Count; i++)
          {
            var property = attribute.Properties[i];
            if (string.IsNullOrWhiteSpace(property.Name)) continue;
            if (i > 0) output.WriteSpace();
            var argument = property.Argument;
            string valueFormat = argument.Type == argument.Type.Module.TypeSystem.String ? "'{0}'" : "{0}";
            output.Write("{0}={1}({2})", property.Name, argument.Type.Name, string.Format(valueFormat, argument.Value));
          }
        }

        if (attribute.HasFields)
        {
          output.WriteSpace();
          for (int i = 0; i < attribute.Fields.Count; i++)
          {
            var field = attribute.Fields[0];
            if (string.IsNullOrWhiteSpace(field.Name)) continue;
            if (i > 0) output.WriteSpace();
            var argument = field.Argument;
            string valueFormat = argument.Type == argument.Type.Module.TypeSystem.String ? "'{0}'" : "{0}";
            output.Write("{0}={1}({2})", field.Name, argument.Type.Name, string.Format(valueFormat, argument.Value));
          }
        }

        output.Write(" }");
        output.WriteLine();
      }
    }
Example #6
0
    public void WriteEvent(EventDefinition definition, ISourceCodeOutput output, DecompilerOptions options)
    {
      output.WriteDefinition(".event ", definition);
      output.Write(definition.EventType.ToShortTypeName() + " ");
      output.Write(definition.Name + " ");

      OpenBlock(output);

      if (definition.HasCustomAttributes)
        WriteCustomAttributes(definition.CustomAttributes, output);

      if (definition.AddMethod != null)
      {
        var setter = definition.AddMethod;
        output.Write(".addon ");
        if (setter.HasThis) output.Write("instance ");

        output.Write(
          setter.ReturnType.IsPrimitive || setter.IsVoid()
          ? setter.ReturnType.Name.ToLowerInvariant()
          : setter.ReturnType.FullName);

        output.WriteSpace();
        //setter.ReturnType == setter.Module.TypeSystem.Void
        //setter.ReturnType.FullName + " " + (setter.DeclaringType.FullName + "::" + setter.Name) + MethodSignatureFullName(setter)
        output.WriteLine("{0}::{1}{2}", setter.DeclaringType.FullName, setter.Name, MethodSignatureFullName(setter));
      }

      if (definition.RemoveMethod != null)
      {
        var getter = definition.RemoveMethod;
        output.Write(".removeon ");
        if (getter.HasThis) output.Write("instance ");

        output.Write(
          getter.ReturnType.IsPrimitive || getter.IsVoid()
          ? getter.ReturnType.Name.ToLowerInvariant()
          : getter.ReturnType.FullName);

        output.WriteSpace();
        output.WriteLine("{0}::{1}{2}", getter.DeclaringType.FullName, getter.Name, MethodSignatureFullName(getter));
      }

      CloseBlock(output);
    }