protected override string GenerateStringCode(string inputFileContent)
{
string globalNamespaceName;
string guidListClassName;
string cmdIdListClassName;
string supporterPostfix;
bool isPublic;
// get parameters passed as 'FileNamespace' inside properties of the file generator:
InterpreteArguments((string.IsNullOrEmpty(FileNamespace) ? null : FileNamespace.Split(';')),
out globalNamespaceName, out guidListClassName, out cmdIdListClassName,
out supporterPostfix, out isPublic);
// create support CodeDOM classes:
CodeNamespace globalNamespace = new CodeNamespace(globalNamespaceName);
CodeTypeDeclaration classGuideList = CreateClass(guidListClassName, VsctComments.ClassGuideListComment, isPublic);
CodeTypeDeclaration classPkgCmdIDList = CreateClass(cmdIdListClassName, VsctComments.ClassPkgCmdIDListComments, isPublic);
CodeModelLanguages currentLanguage = CodeHelper.GetCodeLanguage(GetProject().CodeModel.Language);
IList <NamedValue> guids;
IList <NamedValue> ids;
// retrieve the list GUIDs and IDs defined inside VSCT file:
VsctParser.Parse(inputFileContent, out guids, out ids);
// generate members describing GUIDs:
if (guids != null)
{
foreach (NamedValue s in guids)
{
s.Supporter = s.Name + supporterPostfix;
classGuideList.Members.Add(CreateConstField("System.String", s.Supporter, s.Value, true));
}
foreach (NamedValue g in guids)
{
classGuideList.Members.Add(CreateStaticField("Guid", g.Name, g.Supporter, true));
}
}
// generate members describing IDs:
if (ids != null)
{
foreach (NamedValue i in ids)
{
classPkgCmdIDList.Members.Add(CreateConstField("System.UInt32", i.Name,
ConversionHelper.ToHex(i.Value, currentLanguage),
false));
}
}
// add all members to final namespace:
globalNamespace.Imports.Add(new CodeNamespaceImport("System"));
globalNamespace.Types.Add(classGuideList);
globalNamespace.Types.Add(classPkgCmdIDList);
// generate source code:
return(CodeHelper.GenerateFromNamespace(GetCodeProvider(), globalNamespace, true));
}
/// <summary>
/// Generate corresponding XML code.
/// </summary>
protected override string GenerateStringCode(string inputFileContent)
{
try
{
BinaryFile file = new WindowsPortableExecutable();
WindowsPortableExecutableLoadArgs args = new WindowsPortableExecutableLoadArgs(false);
XmlDocumentWrapper xml;
XmlNode mainNode;
bool[] externalParams;
args.LoadImports = true;
args.LoadExports = true;
// load the file:
file.Load(InputFilePath, args);
// check integrity:
if (file.Count < 2)
{
return(string.Format(CoffComments.InvalidContent, InputFilePath));
}
// create output XML document:
xml = new XmlDocumentWrapper();
xml.DeclareDocument();
xml.Append(mainNode = DefineMainElement(xml));
// interprete extenal parameters:
InterpreteArguments((string.IsNullOrEmpty(FileNamespace.Trim()) ? null : FileNamespace.Split(';')),
out externalParams);
// serialize proper sections:
if (externalParams == null || externalParams.Length <= 1 || externalParams[1])
{
AppendSection(xml, mainNode, file[ExportFunctionSection.DefaultName] as ExportFunctionSection);
}
if (externalParams == null || externalParams.Length <= 2 || externalParams[2])
{
AppendSection(xml, mainNode, file[ImportFunctionSection.DefaultName] as ImportFunctionSection);
}
// and return data as a string:
return(XmlHelper.ToString(xml, true));
}
catch (Exception ex)
{
return(string.Format(CoffComments.InvalidOperation, InputFilePath, ex.Message));
}
}
protected override string GenerateStringCode(string inputFileContent)
{
// get parameters passed as 'FileNamespace' inside properties of the file generator:
InterpreteArguments(
string.IsNullOrEmpty(FileNamespace) ? null : FileNamespace.Split(';')
, out string globalNamespaceName
, out string guidListClassName
, out string cmdIdListClassName
, out string supporterPostfix
, out bool isPublic
);
string language = GetProject().CodeModel.Language;
var codeProvider = GetCodeProvider(language);
bool isCSharp = string.Equals(codeProvider.FileExtension, "cs", StringComparison.InvariantCultureIgnoreCase);
// create support CodeDOM classes:
var globalNamespace = new System.CodeDom.CodeNamespace(globalNamespaceName);
var classGuideList = CreateClass(guidListClassName, ClassGuideListComment, isPublic, true, !isCSharp);
var classPkgCmdIDList = CreateClass(cmdIdListClassName, ClassPkgCmdIDListComments, isPublic, true, !isCSharp);
// retrieve the list GUIDs and IDs defined inside VSCT file:
var guids = Parse(inputFileContent);
// generate members describing GUIDs:
if (guids != null)
{
var delayedMembers = new List <CodeTypeMember>();
foreach (var symbol in guids)
{
string nameString;
string nameGuid;
// for each GUID generate one string and one GUID field with similar names:
if (symbol.Name != null && symbol.Name.EndsWith(supporterPostfix, StringComparison.OrdinalIgnoreCase))
{
nameString = symbol.Name;
nameGuid = symbol.Name.Substring(0, symbol.Name.Length - supporterPostfix.Length);
}
else
{
nameString = symbol.Name + supporterPostfix;
nameGuid = symbol.Name;
}
classGuideList.Members.Add(CreateConstField(typeof(string), nameString, symbol.Value, true));
delayedMembers.Add(CreateStaticField(typeof(Guid), nameGuid, nameString, true));
if (symbol.Ids.Any())
{
if (classPkgCmdIDList.Members.Count > 0)
{
classPkgCmdIDList.Members.Add(new CodeSnippetTypeMember(string.Empty));
}
var classPkgCmdIDNested = CreateClass(nameGuid, string.Empty, isPublic, true, !isCSharp);
classPkgCmdIDList.Members.Add(classPkgCmdIDNested);
foreach (var id in symbol.Ids)
{
if (classPkgCmdIDNested.Members.Count > 0)
{
classPkgCmdIDNested.Members.Add(new CodeSnippetTypeMember(string.Empty));
}
classPkgCmdIDNested.Members.Add(CreateConstField(typeof(int), id.Item1, ToHex(id.Item2, language), false));
}
}
}
classGuideList.Members.Add(new CodeSnippetTypeMember(string.Empty));
foreach (var member in delayedMembers)
{
classGuideList.Members.Add(member);
}
}
globalNamespace.Comments.Add(new CodeCommentStatement("------------------------------------------------------------------------------"));
globalNamespace.Comments.Add(new CodeCommentStatement("<auto-generated>"));
globalNamespace.Comments.Add(new CodeCommentStatement($" This file was generated by {Vsix.Name} v{Vsix.Version}"));
globalNamespace.Comments.Add(new CodeCommentStatement("</auto-generated>"));
globalNamespace.Comments.Add(new CodeCommentStatement("------------------------------------------------------------------------------"));
globalNamespace.Types.Add(classGuideList);
globalNamespace.Types.Add(classPkgCmdIDList);
// generate source code:
return(GenerateFromNamespace(codeProvider, globalNamespace, false, isCSharp));
}
protected override string GenerateStringCode(string inputFileContent)
{
string globalNamespaceName;
string guidListClassName;
string cmdIdListClassName;
string supporterPostfix;
bool isPublic;
// get parameters passed as 'FileNamespace' inside properties of the file generator:
InterpreteArguments((string.IsNullOrEmpty(FileNamespace) ? null : FileNamespace.Split(';')),
out globalNamespaceName, out guidListClassName, out cmdIdListClassName,
out supporterPostfix, out isPublic);
// create support CodeDOM classes:
var globalNamespace = new System.CodeDom.CodeNamespace(globalNamespaceName);
var classGuideList = CreateClass(guidListClassName, ClassGuideListComment, isPublic, true);
var classPkgCmdIDList = CreateClass(cmdIdListClassName, ClassPkgCmdIDListComments, isPublic, true);
IList <KeyValuePair <string, string> > guids;
IList <KeyValuePair <string, string> > ids;
// retrieve the list GUIDs and IDs defined inside VSCT file:
Parse(inputFileContent, out guids, out ids);
// generate members describing GUIDs:
if (guids != null)
{
var delayedMembers = new List <CodeTypeMember>();
foreach (var symbol in guids)
{
string nameString;
string nameGuid;
// for each GUID generate one string and one GUID field with similar names:
if (symbol.Key != null && symbol.Key.EndsWith(supporterPostfix, StringComparison.OrdinalIgnoreCase))
{
nameString = symbol.Key;
nameGuid = symbol.Key.Substring(0, symbol.Key.Length - supporterPostfix.Length);;
}
else
{
nameString = symbol.Key + supporterPostfix;
nameGuid = symbol.Key;
}
classGuideList.Members.Add(CreateConstField("System.String", nameString, symbol.Value, true));
delayedMembers.Add(CreateStaticField("Guid", nameGuid, nameString, true));
}
foreach (var member in delayedMembers)
{
classGuideList.Members.Add(member);
}
}
// generate members describing IDs:
if (ids != null)
{
foreach (var i in ids)
{
classPkgCmdIDList.Members.Add(CreateConstField("System.Int32", i.Key, ToHex(i.Value, GetProject().CodeModel.Language), false));
}
}
globalNamespace.Comments.Add(new CodeCommentStatement("------------------------------------------------------------------------------"));
globalNamespace.Comments.Add(new CodeCommentStatement("<auto-generated>"));
globalNamespace.Comments.Add(new CodeCommentStatement($" This file was generated by {Vsix.Name} v{Vsix.Version}"));
globalNamespace.Comments.Add(new CodeCommentStatement("</auto-generated>"));
globalNamespace.Comments.Add(new CodeCommentStatement("------------------------------------------------------------------------------"));
// add all members to final namespace:
globalNamespace.Imports.Add(new CodeNamespaceImport("System"));
globalNamespace.Types.Add(classGuideList);
globalNamespace.Types.Add(classPkgCmdIDList);
// generate source code:
return(GenerateFromNamespace(GetCodeProvider(), globalNamespace, false));
}
