Browse Source

change formatting settings to be consistent with the rest of ILSpy

pull/512/head
Siegfried Pammer 11 years ago
parent
commit
4725c17185
  1. 8
      .editorconfig
  2. 12
      ILSpy.AddIn/Guids.cs
  3. 225
      ILSpy.AddIn/ILSpyAddInPackage.cs
  4. 12
      ILSpy.AddIn/PkgCmdID.cs
  5. 4
      ILSpy.AddIn/Properties/AssemblyInfo.cs
  6. 193
      ILSpy.AddIn/Utils.cs

8
.editorconfig

@ -5,11 +5,6 @@ root = true
indent_style = tab indent_style = tab
indent_size = 4 indent_size = 4
# The indentation (and source formatting!) of the addin sources are different than the rest of the solution.
[ILSpy.AddIn/*]
indent_style = space
indent_size = 4
[*.il] [*.il]
indent_style = space indent_style = space
indent_size = 2 indent_size = 2
@ -23,3 +18,6 @@ indent_size = 2
[*.vsixmanifest] [*.vsixmanifest]
indent_style = space indent_style = space
indent_size = 2 indent_size = 2
[*.vsct]
indent_style = space
indent_size = 2

12
ILSpy.AddIn/Guids.cs

@ -4,11 +4,11 @@ using System;
namespace ICSharpCode.ILSpy.AddIn namespace ICSharpCode.ILSpy.AddIn
{ {
static class GuidList static class GuidList
{ {
public const string guidILSpyAddInPkgString = "a9120dbe-164a-4891-842f-fb7829273838"; public const string guidILSpyAddInPkgString = "a9120dbe-164a-4891-842f-fb7829273838";
public const string guidILSpyAddInCmdSetString = "85ddb8ca-a842-4b1c-ba1a-94141fdf19d0"; public const string guidILSpyAddInCmdSetString = "85ddb8ca-a842-4b1c-ba1a-94141fdf19d0";
public static readonly Guid guidILSpyAddInCmdSet = new Guid(guidILSpyAddInCmdSetString); public static readonly Guid guidILSpyAddInCmdSet = new Guid(guidILSpyAddInCmdSetString);
}; };
} }

225
ILSpy.AddIn/ILSpyAddInPackage.cs

@ -13,131 +13,128 @@ using System.IO;
namespace ICSharpCode.ILSpy.AddIn namespace ICSharpCode.ILSpy.AddIn
{ {
/// <summary> /// <summary>
/// This is the class that implements the package exposed by this assembly. /// This is the class that implements the package exposed by this assembly.
/// ///
/// The minimum requirement for a class to be considered a valid package for Visual Studio /// The minimum requirement for a class to be considered a valid package for Visual Studio
/// is to implement the IVsPackage interface and register itself with the shell. /// is to implement the IVsPackage interface and register itself with the shell.
/// This package uses the helper classes defined inside the Managed Package Framework (MPF) /// This package uses the helper classes defined inside the Managed Package Framework (MPF)
/// to do it: it derives from the Package class that provides the implementation of the /// to do it: it derives from the Package class that provides the implementation of the
/// IVsPackage interface and uses the registration attributes defined in the framework to /// IVsPackage interface and uses the registration attributes defined in the framework to
/// register itself and its components with the shell. /// register itself and its components with the shell.
/// </summary> /// </summary>
// This attribute tells the PkgDef creation utility (CreatePkgDef.exe) that this class is // This attribute tells the PkgDef creation utility (CreatePkgDef.exe) that this class is
// a package. // a package.
[PackageRegistration(UseManagedResourcesOnly = true)] [PackageRegistration(UseManagedResourcesOnly = true)]
// This attribute is used to register the information needed to show this package // This attribute is used to register the information needed to show this package
// in the Help/About dialog of Visual Studio. // in the Help/About dialog of Visual Studio.
[InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400)] [InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400)]
// This attribute is needed to let the shell know that this package exposes some menus. // This attribute is needed to let the shell know that this package exposes some menus.
[ProvideMenuResource("Menus.ctmenu", 1)] [ProvideMenuResource("Menus.ctmenu", 1)]
[Guid(GuidList.guidILSpyAddInPkgString)] [Guid(GuidList.guidILSpyAddInPkgString)]
[ProvideAutoLoad(VSConstants.UICONTEXT.SolutionExistsAndFullyLoaded_string)] [ProvideAutoLoad(VSConstants.UICONTEXT.SolutionExistsAndFullyLoaded_string)]
public sealed class ILSpyAddInPackage : Package public sealed class ILSpyAddInPackage : Package
{ {
/// <summary> /// <summary>
/// Default constructor of the package. /// Default constructor of the package.
/// Inside this method you can place any initialization code that does not require /// Inside this method you can place any initialization code that does not require
/// any Visual Studio service because at this point the package object is created but /// any Visual Studio service because at this point the package object is created but
/// not sited yet inside Visual Studio environment. The place to do all the other /// not sited yet inside Visual Studio environment. The place to do all the other
/// initialization is the Initialize method. /// initialization is the Initialize method.
/// </summary> /// </summary>
public ILSpyAddInPackage() public ILSpyAddInPackage()
{ {
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering constructor for: {0}", this.ToString())); Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering constructor for: {0}", this.ToString()));
} }
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Overridden Package Implementation // Overridden Package Implementation
#region Package Members #region Package Members
/// <summary> /// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place /// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio. /// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary> /// </summary>
protected override void Initialize() protected override void Initialize()
{ {
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString())); Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize(); base.Initialize();
// Add our command handlers for menu (commands must exist in the .vsct file) // Add our command handlers for menu (commands must exist in the .vsct file)
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (null != mcs) if (null != mcs) {
{ // Create the command for the menu item.
// Create the command for the menu item. CommandID menuCommandID = new CommandID(GuidList.guidILSpyAddInCmdSet, (int)PkgCmdIDList.cmdidOpenInILSpy);
CommandID menuCommandID = new CommandID(GuidList.guidILSpyAddInCmdSet, (int)PkgCmdIDList.cmdidOpenInILSpy); MenuCommand menuItem = new MenuCommand(OpenInILSpyCallback, menuCommandID);
MenuCommand menuItem = new MenuCommand(OpenInILSpyCallback, menuCommandID); mcs.AddCommand(menuItem);
mcs.AddCommand(menuItem);
// Create the command for the menu item. // Create the command for the menu item.
CommandID menuCommandID2 = new CommandID(GuidList.guidILSpyAddInCmdSet, (int)PkgCmdIDList.cmdidOpenILSpy); CommandID menuCommandID2 = new CommandID(GuidList.guidILSpyAddInCmdSet, (int)PkgCmdIDList.cmdidOpenILSpy);
MenuCommand menuItem2 = new MenuCommand(OpenILSpyCallback, menuCommandID2); MenuCommand menuItem2 = new MenuCommand(OpenILSpyCallback, menuCommandID2);
mcs.AddCommand(menuItem2); mcs.AddCommand(menuItem2);
} }
} }
#endregion #endregion
/// <summary> /// <summary>
/// This function is the callback used to execute a command when the a menu item is clicked. /// This function is the callback used to execute a command when the a menu item is clicked.
/// See the Initialize method to see how the menu item is associated to this function using /// See the Initialize method to see how the menu item is associated to this function using
/// the OleMenuCommandService service and the MenuCommand class. /// the OleMenuCommandService service and the MenuCommand class.
/// </summary> /// </summary>
private void OpenInILSpyCallback(object sender, EventArgs e) private void OpenInILSpyCallback(object sender, EventArgs e)
{ {
var explorer = ((EnvDTE80.DTE2)GetGlobalService(typeof(EnvDTE.DTE))).ToolWindows.SolutionExplorer; var explorer = ((EnvDTE80.DTE2)GetGlobalService(typeof(EnvDTE.DTE))).ToolWindows.SolutionExplorer;
var items = explorer.SelectedItems as EnvDTE.UIHierarchyItem[]; var items = explorer.SelectedItems as EnvDTE.UIHierarchyItem[];
foreach (var item in items) foreach (var item in items) {
{ dynamic obj = item.Object;
dynamic obj = item.Object; OpenAssemblyInILSpy(obj.Path);
OpenAssemblyInILSpy(obj.Path); }
}
} }
private void OpenILSpyCallback(object sender, EventArgs e) private void OpenILSpyCallback(object sender, EventArgs e)
{ {
Process.Start(GetILSpyPath()); Process.Start(GetILSpyPath());
} }
private string GetILSpyPath() private string GetILSpyPath()
{ {
var basePath = Path.GetDirectoryName(typeof(ILSpyAddInPackage).Assembly.Location); var basePath = Path.GetDirectoryName(typeof(ILSpyAddInPackage).Assembly.Location);
return Path.Combine(basePath, "ILSpy.exe"); return Path.Combine(basePath, "ILSpy.exe");
} }
private void OpenAssemblyInILSpy(string assemblyFileName) private void OpenAssemblyInILSpy(string assemblyFileName)
{ {
if (!File.Exists(assemblyFileName)) if (!File.Exists(assemblyFileName)) {
{ ShowMessage("Could not find assembly '{0}', please ensure the project and all references were built correctly!", assemblyFileName);
ShowMessage("Could not find assembly '{0}', please ensure the project and all references were built correctly!", assemblyFileName); return;
return; }
} Process.Start(GetILSpyPath(), Utils.ArgumentArrayToCommandLine(assemblyFileName));
Process.Start(GetILSpyPath(), Utils.ArgumentArrayToCommandLine(assemblyFileName)); }
}
private void ShowMessage(string format, params object[] items) private void ShowMessage(string format, params object[] items)
{ {
IVsUIShell uiShell = (IVsUIShell)GetService(typeof(SVsUIShell)); IVsUIShell uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
Guid clsid = Guid.Empty; Guid clsid = Guid.Empty;
int result; int result;
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure( Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(
uiShell.ShowMessageBox( uiShell.ShowMessageBox(
0, 0,
ref clsid, ref clsid,
"ILSpy.AddIn", "ILSpy.AddIn",
string.Format(CultureInfo.CurrentCulture, format, items), string.Format(CultureInfo.CurrentCulture, format, items),
string.Empty, string.Empty,
0, 0,
OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGBUTTON.OLEMSGBUTTON_OK,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
OLEMSGICON.OLEMSGICON_INFO, OLEMSGICON.OLEMSGICON_INFO,
0, // false 0, // false
out result out result
) )
); );
} }
} }
} }

12
ILSpy.AddIn/PkgCmdID.cs

@ -4,10 +4,10 @@ using System;
namespace ICSharpCode.ILSpy.AddIn namespace ICSharpCode.ILSpy.AddIn
{ {
static class PkgCmdIDList static class PkgCmdIDList
{ {
public const uint cmdidOpenILSpy = 0x100; public const uint cmdidOpenILSpy = 0x100;
public const uint cmdidOpenInILSpy = 0x200; public const uint cmdidOpenInILSpy = 0x200;
public const uint cmdidOpenDefinitionInILSpy = 0x300; public const uint cmdidOpenDefinitionInILSpy = 0x300;
}; };
} }

4
ILSpy.AddIn/Properties/AssemblyInfo.cs

@ -14,8 +14,8 @@ using System.Runtime.InteropServices;
[assembly: AssemblyProduct("ILSpy.AddIn")] [assembly: AssemblyProduct("ILSpy.AddIn")]
[assembly: AssemblyCopyright("")] [assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")] [assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")] [assembly: AssemblyCulture("")]
[assembly: ComVisible(false)] [assembly: ComVisible(false)]
[assembly: CLSCompliant(false)] [assembly: CLSCompliant(false)]
[assembly: NeutralResourcesLanguage("en-US")] [assembly: NeutralResourcesLanguage("en-US")]

193
ILSpy.AddIn/Utils.cs

@ -8,112 +8,97 @@ using System.Threading.Tasks;
namespace ICSharpCode.ILSpy.AddIn namespace ICSharpCode.ILSpy.AddIn
{ {
class Utils class Utils
{ {
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1060:MovePInvokesToNativeMethodsClass")] [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1060:MovePInvokesToNativeMethodsClass")]
[DllImport("shell32.dll", SetLastError = true, CharSet = CharSet.Unicode)] [DllImport("shell32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
static extern unsafe char** CommandLineToArgvW([MarshalAs(UnmanagedType.LPWStr)] string lpCmdLine, out int pNumArgs); static extern unsafe char** CommandLineToArgvW([MarshalAs(UnmanagedType.LPWStr)] string lpCmdLine, out int pNumArgs);
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1060:MovePInvokesToNativeMethodsClass")] [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1060:MovePInvokesToNativeMethodsClass")]
[DllImport("kernel32.dll")] [DllImport("kernel32.dll")]
static extern IntPtr LocalFree(IntPtr hMem); static extern IntPtr LocalFree(IntPtr hMem);
#region CommandLine <-> Argument Array
/// <summary>
/// Decodes a command line into an array of arguments according to the CommandLineToArgvW rules.
/// </summary>
/// <remarks>
/// Command line parsing rules:
/// - 2n backslashes followed by a quotation mark produce n backslashes, and the quotation mark is considered to be the end of the argument.
/// - (2n) + 1 backslashes followed by a quotation mark again produce n backslashes followed by a quotation mark.
/// - n backslashes not followed by a quotation mark simply produce n backslashes.
/// </remarks>
public static unsafe string[] CommandLineToArgumentArray(string commandLine)
{
if (string.IsNullOrEmpty(commandLine))
return new string[0];
int numberOfArgs;
char** arr = CommandLineToArgvW(commandLine, out numberOfArgs);
if (arr == null)
throw new Win32Exception();
try
{
string[] result = new string[numberOfArgs];
for (int i = 0; i < numberOfArgs; i++)
{
result[i] = new string(arr[i]);
}
return result;
}
finally
{
// Free memory obtained by CommandLineToArgW.
LocalFree(new IntPtr(arr));
}
}
static readonly char[] charsNeedingQuoting = { ' ', '\t', '\n', '\v', '"' }; #region CommandLine <-> Argument Array
/// <summary>
/// Decodes a command line into an array of arguments according to the CommandLineToArgvW rules.
/// </summary>
/// <remarks>
/// Command line parsing rules:
/// - 2n backslashes followed by a quotation mark produce n backslashes, and the quotation mark is considered to be the end of the argument.
/// - (2n) + 1 backslashes followed by a quotation mark again produce n backslashes followed by a quotation mark.
/// - n backslashes not followed by a quotation mark simply produce n backslashes.
/// </remarks>
public static unsafe string[] CommandLineToArgumentArray(string commandLine)
{
if (string.IsNullOrEmpty(commandLine))
return new string[0];
int numberOfArgs;
char** arr = CommandLineToArgvW(commandLine, out numberOfArgs);
if (arr == null)
throw new Win32Exception();
try {
string[] result = new string[numberOfArgs];
for (int i = 0; i < numberOfArgs; i++) {
result[i] = new string(arr[i]);
}
return result;
} finally {
// Free memory obtained by CommandLineToArgW.
LocalFree(new IntPtr(arr));
}
}
/// <summary> static readonly char[] charsNeedingQuoting = { ' ', '\t', '\n', '\v', '"' };
/// Escapes a set of arguments according to the CommandLineToArgvW rules.
/// </summary>
/// <remarks>
/// Command line parsing rules:
/// - 2n backslashes followed by a quotation mark produce n backslashes, and the quotation mark is considered to be the end of the argument.
/// - (2n) + 1 backslashes followed by a quotation mark again produce n backslashes followed by a quotation mark.
/// - n backslashes not followed by a quotation mark simply produce n backslashes.
/// </remarks>
public static string ArgumentArrayToCommandLine(params string[] arguments)
{
if (arguments == null)
return null;
StringBuilder b = new StringBuilder();
for (int i = 0; i < arguments.Length; i++)
{
if (i > 0)
b.Append(' ');
AppendArgument(b, arguments[i]);
}
return b.ToString();
}
static void AppendArgument(StringBuilder b, string arg) /// <summary>
{ /// Escapes a set of arguments according to the CommandLineToArgvW rules.
if (arg.Length > 0 && arg.IndexOfAny(charsNeedingQuoting) < 0) /// </summary>
{ /// <remarks>
b.Append(arg); /// Command line parsing rules:
} /// - 2n backslashes followed by a quotation mark produce n backslashes, and the quotation mark is considered to be the end of the argument.
else /// - (2n) + 1 backslashes followed by a quotation mark again produce n backslashes followed by a quotation mark.
{ /// - n backslashes not followed by a quotation mark simply produce n backslashes.
b.Append('"'); /// </remarks>
for (int j = 0; ; j++) public static string ArgumentArrayToCommandLine(params string[] arguments)
{ {
int backslashCount = 0; if (arguments == null)
while (j < arg.Length && arg[j] == '\\') return null;
{ StringBuilder b = new StringBuilder();
backslashCount++; for (int i = 0; i < arguments.Length; i++) {
j++; if (i > 0)
} b.Append(' ');
if (j == arg.Length) AppendArgument(b, arguments[i]);
{ }
b.Append('\\', backslashCount * 2); return b.ToString();
break; }
}
else if (arg[j] == '"') static void AppendArgument(StringBuilder b, string arg)
{ {
b.Append('\\', backslashCount * 2 + 1); if (arg.Length > 0 && arg.IndexOfAny(charsNeedingQuoting) < 0) {
b.Append('"'); b.Append(arg);
} } else {
else b.Append('"');
{ for (int j = 0; ; j++) {
b.Append('\\', backslashCount); int backslashCount = 0;
b.Append(arg[j]); while (j < arg.Length && arg[j] == '\\') {
} backslashCount++;
} j++;
b.Append('"'); }
} if (j == arg.Length) {
} b.Append('\\', backslashCount * 2);
#endregion break;
} else if (arg[j] == '"') {
} b.Append('\\', backslashCount * 2 + 1);
b.Append('"');
} else {
b.Append('\\', backslashCount);
b.Append(arg[j]);
}
}
b.Append('"');
}
}
#endregion
}
} }

Loading…
Cancel
Save