/// <summary>
/// Verifies that <paramref name="source"/> compiles using the provided compiler.
/// </summary>
/// <param name="compiler">Compiler instance</param>
/// <param name="source">Source code to compile</param>
public static CompilerResults Compiles(CodeDomProvider provider, Stream source)
{
Assert.IsNotNull(provider);
Assert.IsNotNull(source);
CompilerParameters ps = new CompilerParameters();
return Compiles(provider, ps, source);
}
public static Assembly CompileScriptFromSource(string source, CodeDomProvider provider, ref string errors)
{
StringBuilder errorLog = new StringBuilder();
errors = "";
CompilerParameters compilerParameters = new CompilerParameters();
compilerParameters.GenerateExecutable = false;
compilerParameters.GenerateInMemory = true;
compilerParameters.IncludeDebugInformation = false;
compilerParameters.ReferencedAssemblies.Add("System.dll");
compilerParameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
compilerParameters.ReferencedAssemblies.Add("KedrahCore.dll");
compilerParameters.ReferencedAssemblies.Add("TibiaAPI.dll");
compilerParameters.ReferencedAssemblies.Add(System.Reflection.Assembly.GetExecutingAssembly().Location);
CompilerResults results = provider.CompileAssemblyFromSource(compilerParameters, source);
if (!results.Errors.HasErrors)
{
return results.CompiledAssembly;
}
else
{
foreach (CompilerError error in results.Errors)
{
errorLog.AppendLine(error.ErrorText);
}
}
errors = errorLog.ToString();
return null;
}
static ReflectionHelper()
{
UsingNamespaces = new List<String>();
ClearUsings();
// Create the C# Code Provider to compile C# Code
IDictionary<string, string> providerOptions = new Dictionary<string, string>();
providerOptions.Add("CompilerVersion", "v3.5");
CodeProvider = new CSharpCodeProvider(providerOptions);
CompilerParameters = new CompilerParameters();
// Generate aclass library instead of an executable
CompilerParameters.GenerateExecutable = false;
// Specify the assembly file name to generate.
CompilerParameters.OutputAssembly = "C:\\DummyAssembly.dll";
// Save the assembly as a physical file.
CompilerParameters.GenerateInMemory = false;
// Set whether to treat all warnings as errors.
CompilerParameters.TreatWarningsAsErrors = false;
// Add a reference to the game and System.dll and XNA
//CompilerParameters.ReferencedAssemblies.Add(typeof(Game).Assembly.FullName);
ClearReferencedAsseblies();
}
//***************************************************************************
// Class Constructors
//
/// <summary>
/// Provides a simple container and methods for building a CodeDOM-based application.
/// </summary>
/// <param name="ProviderType">A value of type CodeDomProviderType indicating the type of code provider to use to generate code within this AosDynaCode object.</param>
/// <param name="NameSpace">A string value indicating the namespace to use when generating code for this AosDynaCode object.</param>
public DynaCode(CodeDomProviderType ProviderType, string NameSpace)
{
provider = GetProvider(ProviderType);
nsMain = new CodeNamespace(NameSpace);
compileUnit.Namespaces.Add(nsMain);
nsMain.Imports.Add(new CodeNamespaceImport("System"));
}
public override CodeGeneratorOptions GetGeneratorOptions (CodeDomProvider provider) {
CodeGeneratorOptions generatorOptions = base.GetGeneratorOptions (provider);
#if WHIDBEY
generatorOptions.VerbatimOrder = true;
#endif
return generatorOptions;
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
if (!(provider is JScriptCodeProvider)) {
// GENERATES (C#):
//
// namespace Namespace1 {
//
// public class TEST {
//
// public static void Main() {
// // the following is repeated Char.MaxValue times
// System.Console.WriteLine(/* character value goes here */);
// }
// }
// }
CodeNamespace ns = new CodeNamespace ("Namespace1");
ns.Imports.Add (new CodeNamespaceImport ("System"));
cu.Namespaces.Add (ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration ("TEST");
cd.IsClass = true;
ns.Types.Add (cd);
CodeEntryPointMethod methodMain = new CodeEntryPointMethod ();
for (int i = 0; i < Char.MaxValue; i+=50)
methodMain.Statements.Add (CDHelper.ConsoleWriteLineStatement (new CodePrimitiveExpression (System.Convert.ToChar (i))));
cd.Members.Add (methodMain);
}
}
public FormulaEvaluator(IEnumerable<Sensor> sensors)
{
//Build the code provider
_codeProvider = new CSharpCodeProvider();
//Retrieve the sensor variables
_sensorVariables = sensors.Select(x => x.Variable).ToList();
//Create the compiler parameters
_compilerParameters = new CompilerParameters
{
CompilerOptions = "/target:library /optimize",
GenerateExecutable = false,
GenerateInMemory = true,
IncludeDebugInformation = false
};
//Add the needed references
_compilerParameters.ReferencedAssemblies.Add("System.dll");
_compilerParameters.ReferencedAssemblies.Add("System.Core.dll");
_compilerParameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
//Build Math Objects
_mathMembers = new ArrayList();
_mathMembersMap = new Hashtable();
//Populate Math Objects
GetMathMemberNames();
//Build String Builder
_source = new StringBuilder();
}
protected TemplateCompilationParameters(RazorCodeLanguage language, CodeDomProvider codeProvider, CompilerParameters compilerParameters = null)
{
Language = language;
CodeProvider = codeProvider;
CompilerParameters = compilerParameters ?? new CompilerParameters { GenerateInMemory = true };
AddAssemblyReference(typeof(TemplateBase));
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// GENERATES (C#):
//
// namespace NSPC {
//
// public class ClassWithMethod {
//
// public int MethodName() {
// This is a CODE SNIPPET #*$*@;
// return 3;
// }
// }
// }
AddScenario ("FindSnippet", "Find code snippet in the code.");
CodeNamespace nspace = new CodeNamespace ("NSPC");
cu.Namespaces.Add (nspace);
CodeTypeDeclaration class1 = new CodeTypeDeclaration ("ClassWithMethod");
class1.IsClass = true;
nspace.Types.Add (class1);
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "MethodName";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Statements.Add (new CodeExpressionStatement (new CodeSnippetExpression ("This is a CODE SNIPPET #*$*@")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (3)));
class1.Members.Add (cmm);
}
public static void Init(this IPersistentMemberInfo persistentMemberInfo, Type codeTemplateType, CodeDomProvider codeDomProvider)
{
persistentMemberInfo.CodeTemplateInfo.CodeTemplate =CodeTemplateBuilder.CreateDefaultTemplate(
persistentMemberInfo is IPersistentCollectionMemberInfo
? TemplateType.ReadOnlyMember
: TemplateType.ReadWriteMember, persistentMemberInfo.Session, codeTemplateType,codeDomProvider);
}
private void GenerateTestFile(SpecFlowFeatureFile featureFile, CodeDomProvider codeProvider, TextWriter outputWriter)
{
using(var reader = new StreamReader(featureFile.GetFullPath(project)))
{
GenerateTestFile(featureFile, codeProvider, reader, outputWriter);
}
}
public override void BuildTree(CodeDomProvider provider, CodeCompileUnit cu) {
//cu.UserData["AllowLateBound"] = true;
// GENERATES (C#):
// namespace Namespace1 {
// using System;
//
//
// public class Class1 {
//
// public virtual string Foo1(string format, [System.Runtime.InteropServices.OptionalAttribute()] params object[] array) {
// string str;
// str = format.Replace("{0}", array[0].ToString());
// str = str.Replace("{1}", array[1].ToString());
// str = str.Replace("{2}", array[2].ToString());
// return str;
// }
// }
// }
CodeNamespace ns = new CodeNamespace("Namespace1");
ns.Imports.Add(new CodeNamespaceImport("System"));
cu.Namespaces.Add(ns);
// Full Verification Objects
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
class1.Name = "Class1";
ns.Types.Add(class1);
AddScenario ("CheckFoo1");
CodeMemberMethod fooMethod1 = new CodeMemberMethod();
fooMethod1.Name = "Foo1";
fooMethod1.Attributes = MemberAttributes.Public ;
fooMethod1.ReturnType = new CodeTypeReference(typeof(string));
CodeParameterDeclarationExpression parameter1 = new CodeParameterDeclarationExpression();
parameter1.Name = "format";
parameter1.Type = new CodeTypeReference(typeof(string));
fooMethod1.Parameters.Add(parameter1);
CodeParameterDeclarationExpression parameter2 = new CodeParameterDeclarationExpression();
parameter2.Name = "array";
parameter2.Type = new CodeTypeReference(typeof(object[]));
if (Supports (provider, GeneratorSupport.ParameterAttributes)) {
parameter2.CustomAttributes.Add( new CodeAttributeDeclaration("System.ParamArrayAttribute"));
parameter2.CustomAttributes.Add( new CodeAttributeDeclaration("System.Runtime.InteropServices.OptionalAttribute"));
}
fooMethod1.Parameters.Add(parameter2);
class1.Members.Add(fooMethod1);
fooMethod1.Statements.Add( new CodeVariableDeclarationStatement(typeof(string), "str"));
fooMethod1.Statements.Add(CreateStatement(new CodeArgumentReferenceExpression ("format"), 0));
fooMethod1.Statements.Add(CreateStatement(new CodeVariableReferenceExpression ("str"), 1));
fooMethod1.Statements.Add(CreateStatement(new CodeVariableReferenceExpression ("str"), 2));
fooMethod1.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("str")));
}
public ContentTypeWriter(ICodeGenerationOptions options, CodeDomProvider codeDomProvider, IContentTypeCodeBuilder codeBuilder, MemberNameValidator memberNameValidator)
{
_options = options ?? (ICodeGenerationOptions)ComposerMigrationOptions.Default;
_codeDomProvider = codeDomProvider;
_codeBuilder = codeBuilder;
_memberNameValidator = memberNameValidator;
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
#if WHIDBEY
if (!(provider is JScriptCodeProvider)) {
cu.ReferencedAssemblies.Add("System.dll");
cu.UserData["AllowLateBound"] = true;
CodeNamespace ns = new CodeNamespace("Namespace1");
ns.Imports.Add(new CodeNamespaceImport("System"));
cu.Namespaces.Add(ns);
AddScenario ("FindPartialClass", "Attempt to find 'PartialClass'");
BuildClassesIntoNamespace (provider, ns, "PartialClass", ClassTypes.Class, TypeAttributes.Public);
AddScenario ("FindSealedPartialClass", "Attempt to find 'SealedPartialClass'");
BuildClassesIntoNamespace (provider, ns, "SealedPartialClass", ClassTypes.Class, TypeAttributes.Sealed);
BuildClassesIntoNamespace (provider, ns, "AbstractPartialClass", ClassTypes.Class, TypeAttributes.Abstract);
BuildClassesIntoNamespace (provider, ns, "PrivatePartialClass", ClassTypes.Class, TypeAttributes.NotPublic);
if (Supports (provider, GeneratorSupport.DeclareValueTypes)) {
AddScenario ("FindSealedPartialStruct", "Attempt to find 'SealedPartialStruct'");
BuildClassesIntoNamespace (provider, ns, "SealedPartialStruct", ClassTypes.Struct, TypeAttributes.Sealed);
BuildClassesIntoNamespace (provider, ns, "AbstractPartialStruct", ClassTypes.Struct, TypeAttributes.Abstract);
}
}
#endif
}
internal SchemaImporter(XmlSchemas schemas, CodeGenerationOptions options, CodeDomProvider codeProvider, System.Xml.Serialization.ImportContext context)
{
if (!schemas.Contains("http://www.w3.org/2001/XMLSchema"))
{
schemas.AddReference(XmlSchemas.XsdSchema);
schemas.SchemaSet.Add(XmlSchemas.XsdSchema);
}
if (!schemas.Contains("http://www.w3.org/XML/1998/namespace"))
{
schemas.AddReference(XmlSchemas.XmlSchema);
schemas.SchemaSet.Add(XmlSchemas.XmlSchema);
}
this.schemas = schemas;
this.options = options;
this.codeProvider = codeProvider;
this.context = context;
this.Schemas.SetCache(this.Context.Cache, this.Context.ShareTypes);
SchemaImporterExtensionsSection section = System.Configuration.PrivilegedConfigurationManager.GetSection(ConfigurationStrings.SchemaImporterExtensionsSectionPath) as SchemaImporterExtensionsSection;
if (section != null)
{
this.extensions = section.SchemaImporterExtensionsInternal;
}
else
{
this.extensions = new SchemaImporterExtensionCollection();
}
}
/////////////////////////////////////////////////////////////////////////////
protected CompilerResults Compile( CodeDomProvider codeProvider,
IEnumerable<string> compilerOptions,
IList<string> refAssemblies,
string assemblyName,
IList<string> filesIn,
IList<string> sourcesIn
)
{
// ******
if( forceDebug ) {
compilerOptions = ForceDebug( compilerOptions );
}
//
// ??if want debug info then have to make sure code is passed in as a
// file and library is on disk - currently no matter what we pass in
// for debug we get "/debug-" in the xxx.cmdline file passed to the
// compiler
//
// ******
using( var cb = new CodeCompileRunner(TempFilesDir, KeepTempFiles, codeProvider, compilerOptions) ) {
var result = cb.Compile( refAssemblies, assemblyName, filesIn, sourcesIn );
ErrorMessage = cb.ErrorMessage;
return result;
}
}
public static CodeExpression Is(CodeVariableReferenceExpression var,
CodeTypeReferenceExpression type, CodeDomProvider provider)
{
return new CodeSnippetExpression(
"((" + ExpressionToString(var, provider) + ") is " +
ExpressionToString(type, provider) + ")");
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
CodeNamespace ns = new CodeNamespace ("Namespace1");
cu.Namespaces.Add (ns);
// GENERATES (C#):
//
// namespace Namespace1 {
// public class Class1 {
// public int Method1 {
// #line 300 "LinedStatement"
// return 0;
//
// #line default
// #line hidden
// }
// }
// }
CodeTypeDeclaration class1 = new CodeTypeDeclaration ("Class1");
class1.IsClass = true;
class1.Attributes = MemberAttributes.Public;
ns.Types.Add (class1);
CodeMemberMethod method1 = new CodeMemberMethod ();
method1.ReturnType = new CodeTypeReference (typeof (int));
method1.Name = "Method1";
class1.Members.Add (method1);
AddScenario ("FindLinedStatement");
CodeMethodReturnStatement ret = new CodeMethodReturnStatement (new CodePrimitiveExpression (0));
ret.LinePragma = new CodeLinePragma ("LinedStatement", 300);
method1.Statements.Add (ret);
}
protected TemplateCompilationParameters(RazorCodeLanguage language, CodeDomProvider codeProvider, CompilerParameters compilerParameters = null)
{
Language = language;
CodeProvider = codeProvider;
CompilerParameters = compilerParameters ?? new CompilerParameters { GenerateInMemory = true };
CompilerParameters.ReferencedAssemblies.Add(AppDomain.CurrentDomain
.GetAssemblies().First(asm => asm.FullName.StartsWith("RazorPad.Web")).Location);
}
// courtesy of http://metasharp.net/index.php?title=More_technical_Csharp#Generating_the_.27is.27_operator
public static string ExpressionToString(CodeExpression expr, CodeDomProvider provider)
{
using (TextWriter m = new StringWriter())
{
provider.GenerateCodeFromExpression(expr, m, new CodeGeneratorOptions());
return m.ToString();
}
}
/// <summary>
/// Verifies that <paramref name="source"/> compiles using the provided compiler.
/// </summary>
/// <param name="compiler">Compiler instance</param>
/// <param name="source">Source code to compile</param>
public static CompilerResults Compiles(CodeDomProvider provider, string source)
{
Assert.IsNotNull(provider);
Assert.IsNotNull(source);
CompilerParameters ps = new CompilerParameters();
ps.GenerateInMemory = true;
return Compiles(provider, ps, source);
}
public MapCodeGenerator (CodeNamespace codeNamespace, CodeCompileUnit codeCompileUnit, CodeDomProvider codeProvider, CodeGenerationOptions options, Hashtable mappings)
{
// this.codeCompileUnit = codeCompileUnit;
this.codeNamespace = codeNamespace;
this.options = options;
this.codeProvider = codeProvider;
this.identifiers = new CodeIdentifiers ((codeProvider.LanguageOptions & LanguageOptions.CaseInsensitive) == 0);
// this.mappings = mappings;
}
public static ICodeTemplate FindDefaultTemplate(TemplateType templateType, Session session, Type codeTemplateType, CodeDomProvider codeDomProvider){
const ICodeTemplate template = null;
var binaryOperator = new BinaryOperator(template.GetPropertyName(x => x.TemplateType),templateType);
var isDefault = new BinaryOperator(template.GetPropertyName(x => x.IsDefault),true);
var provider = new BinaryOperator(template.GetPropertyName(x => x.CodeDomProvider),codeDomProvider);
return session.FindObject(PersistentCriteriaEvaluationBehavior.InTransaction,
codeTemplateType, new GroupOperator(binaryOperator, isDefault,provider))
as ICodeTemplate;
}
public void InitBase()
{
provider = new CSharpCodeProvider ();
generator = provider.CreateGenerator ();
options = new CodeGeneratorOptions ();
writer = new StringWriter ();
writer.NewLine = "\n";
}
public RuntimeCompiler()
{
compiler = CodeDomProvider.CreateProvider("CSharp");
parameters = new CompilerParameters();
AddRunningAssemblies();
parameters.GenerateInMemory = true;
parameters.GenerateExecutable = false;
parameters.OutputAssembly = "RuntimeCompiler";
}
public override void Search (CodeDomProvider provider, String output) {
int index;
// find the snippet
String str = "This is a CODE SNIPPET #*$*@";
index = output.IndexOf (str);
if (index >= 0 &&
String.Compare (str, 0, output, index, str.Length, false, CultureInfo.InvariantCulture) == 0)
VerifyScenario ("FindSnippet");
}
public override CompilerParameters GetCompilerParameters (CodeDomProvider provider) {
CompilerParameters parms = base.GetCompilerParameters (provider);
// some languages don't compile correctly if no executable is
// generated and an entry point is defined
if (Supports (provider, GeneratorSupport.EntryPointMethod)) {
parms.GenerateExecutable = true;
}
return parms;
}
public Wsdl()
{
proxyCode = "<NOT YET>";
proxyNamespace = "";
paths = new StringCollection();
codeProvider = null;
wsdls = new StringCollection();
xsds = new StringCollection();
cancelled = false;
}
/// <summary>
/// Verifies that <paramref name="source"/> compiles using the provided compiler.
/// </summary>
/// <param name="compiler">Compiler instance</param>
/// <param name="references">Referenced assemblies</param>
/// <param name="source">Source code to compile</param>
public static CompilerResults Compiles(CodeDomProvider provider, StringCollection references, string source)
{
Assert.IsNotNull(provider);
Assert.IsNotNull(references);
Assert.IsNotNull(source);
CompilerParameters ps = new CompilerParameters();
foreach (string ra in references)
ps.ReferencedAssemblies.Add(ra);
return Compiles(provider, ps, source);
}
// TODO: parse both and try to find the basetype of the partial codebehind
//
public CodeProvider (string fileName, string codeBehindFileName)
{
if (codeBehindFileName == null)
throw new ArgumentNullException ("codeBehindFileName");
if (fileName == null)
throw new ArgumentNullException ("fileName");
_codeBehindFileName = codeBehindFileName;
_fileName = fileName;
_provider = GetCodeProvider (fileName);
}
bool ProcessMarkupItem(ITaskItem markupItem, CodeDomProvider codeDomProvider)
{
string markupItemFileName = markupItem.ItemSpec;
XamlBuildTaskServices.PopulateModifiers(codeDomProvider);
XamlNodeList xamlNodes = ReadXamlNodes(markupItemFileName);
if (xamlNodes == null)
{
return(false);
}
ClassData classData = ReadClassData(xamlNodes, markupItemFileName);
string outputFileName = GetFileName(markupItemFileName);
string codeFileName = Path.ChangeExtension(outputFileName, GetGeneratedSourceExtension(codeDomProvider));
string markupFileName = Path.ChangeExtension(outputFileName, GeneratedSourceExtension + XamlBuildTaskServices.XamlExtension);
classData.EmbeddedResourceFileName = Path.GetFileName(markupFileName);
classData.HelperClassFullName = this.HelperClassFullName;
// Check if code file with partial class exists
classData.SourceFileExists = UserProvidedFileExists(markupItemFileName, codeDomProvider);
// Store the full type name as metadata on the markup item
string rootNamespacePrefix = null;
string namespacePrefix = null;
string typeFullName = null;
if (this.Language.Equals("VB") && !String.IsNullOrWhiteSpace(classData.RootNamespace))
{
rootNamespacePrefix = classData.RootNamespace + ".";
}
if (!String.IsNullOrWhiteSpace(classData.Namespace))
{
namespacePrefix = classData.Namespace + ".";
}
if (rootNamespacePrefix != null)
{
if (namespacePrefix != null)
{
typeFullName = rootNamespacePrefix + namespacePrefix + classData.Name;
}
else
{
typeFullName = rootNamespacePrefix + classData.Name;
}
}
else
{
if (namespacePrefix != null)
{
typeFullName = namespacePrefix + classData.Name;
}
else
{
typeFullName = classData.Name;
}
}
markupItem.SetMetadata("typeName", typeFullName);
// Execute extensions here to give them a chance to mutate the ClassData before we generate code.
if (this.SupportExtensions)
{
if (!ExecuteExtensions(classData, markupItem))
{
return(false);
}
}
// Generate code file
CodeCompileUnit codeUnit = new ClassGenerator(this.BuildLogger, codeDomProvider, this.Language).Generate(classData);
WriteCode(codeDomProvider, codeUnit, codeFileName);
this.GeneratedCodeFiles.Add(codeFileName);
// Generate resource file
if (!string.IsNullOrEmpty(this.AssemblyName))
{
// Generate xaml "implementation" file
XmlWriterSettings xmlSettings = new XmlWriterSettings {
Indent = true, IndentChars = " ", CloseOutput = true
};
using (XmlWriter xmlWriter = XmlWriter.Create(File.Open(markupFileName, FileMode.Create), xmlSettings))
{
XamlXmlWriterSettings xamlSettings = new XamlXmlWriterSettings()
{
CloseOutput = true
};
// Process EmbeddedResourceXaml to remove xml:space="preserve"
// due to a
RemoveXamlSpaceAttribute(classData);
using (XamlReader reader = classData.EmbeddedResourceXaml.GetReader())
{
using (XamlXmlWriter xamlWriter = new XamlXmlWriter(xmlWriter, reader.SchemaContext, xamlSettings))
{
XamlServices.Transform(reader, xamlWriter);
}
}
}
this.GeneratedResources.Add(markupFileName);
}
if (classData.RequiresCompilationPass2)
{
this.RequiresCompilationPass2 = true;
}
else
{
if (!this.SupportExtensions)
{
if (!ValidateXaml(xamlNodes, markupItemFileName))
{
this.RequiresCompilationPass2 = true;
}
}
else
{
// skip validation if we are doing in-proc compile
// OR if we have pass 2 extensions hooked up
// as we anyway need to run pass 2 in that case
if (!this.IsInProcessXamlMarkupCompile && !this.MarkupCompilePass2ExtensionsPresent)
{
if (!ValidateXaml(xamlNodes, markupItemFileName))
{
this.RequiresCompilationPass2 = true;
}
}
}
}
return(true);
}
bool UserProvidedFileExists(string markupItemPath, CodeDomProvider codeDomProvider)
{
string desiredSourceFilePath = Path.ChangeExtension(markupItemPath, "xaml." + codeDomProvider.FileExtension);
return(SourceFilePaths.Contains(desiredSourceFilePath));
}
private static String ConstructGeneratorCode(TemplateItem ti, Boolean lineNumbers, String namespaceName, CodeDomProvider provider)
{
// 准备类名和命名空间
var codeNamespace = new CodeNamespace(namespaceName);
// 加入引用的命名空间
foreach (var str in ti.Imports)
{
if (!String.IsNullOrEmpty(str))
{
codeNamespace.Imports.Add(new CodeNamespaceImport(str));
}
}
var typeDec = new CodeTypeDeclaration(ti.ClassName);
typeDec.IsClass = true;
codeNamespace.Types.Add(typeDec);
// 基类
if (!String.IsNullOrEmpty(ti.BaseClassName))
{
typeDec.BaseTypes.Add(new CodeTypeReference(ti.BaseClassName));
}
else if (!String.IsNullOrEmpty(BaseClassName))
{
typeDec.BaseTypes.Add(new CodeTypeReference(BaseClassName));
}
else
{
typeDec.BaseTypes.Add(new CodeTypeReference(typeof(TemplateBase)));
}
if (!String.IsNullOrEmpty(ti.Name))
{
typeDec.LinePragma = new CodeLinePragma(ti.Name, 1);
}
// Render方法
CreateRenderMethod(ti.Blocks, lineNumbers, typeDec);
// 代码生成选项
var options = new CodeGeneratorOptions();
options.VerbatimOrder = true;
options.BlankLinesBetweenMembers = false;
options.BracingStyle = "C";
// 其它类成员代码块
var firstMemberFound = false;
foreach (var block in ti.Blocks)
{
firstMemberFound = GenerateMemberForBlock(block, typeDec, lineNumbers, provider, options, firstMemberFound);
}
// 模版变量
if (ti.Vars != null && ti.Vars.Count > 0)
{
// 构建静态构造函数，初始化静态属性Vars
CreateCctorMethod(typeDec, ti.Vars);
//public Int32 VarName
//{
// get { return (Int32)GetData("VarName"); }
// set { Data["VarName"] = value; }
//}
foreach (var v in ti.Vars)
{
//var vtype = TypeX.Create(v.Value);
var codeName = v.Value.GetName(true);
var sb = new StringBuilder();
sb.AppendLine();
sb.AppendFormat("public {0} {1}", codeName, v.Key);
sb.AppendLine("{");
sb.AppendFormat(" get {{ return GetData<{0}>(\"{1}\"); }}", codeName, v.Key);
sb.AppendLine();
sb.AppendFormat(" set {{ Data[\"{0}\"] = value; }}", v.Key);
sb.AppendLine();
sb.AppendLine("}");
typeDec.Members.Add(new CodeSnippetTypeMember(sb.ToString()));
}
}
// 输出
using (var writer = new StringWriter())
{
provider.GenerateCodeFromNamespace(codeNamespace, new IndentedTextWriter(writer), options);
return(writer.ToString());
}
}
private static void GenerateEnumNamesCode(EnumNameTypeAsset enumNameTypeAsset, string targetFolder)
{
var targetUnit = new CodeCompileUnit();
var targetNamespace = new CodeNamespace(enumNameTypeAsset.namespaceName);
// targetNamespace.Imports.Add(new CodeNamespaceImport("System"));
var targetClass = new CodeTypeDeclaration(enumNameTypeAsset.className)
{
TypeAttributes = TypeAttributes.Public
};
for (var i = 0; i < enumNameTypeAsset.types.Count; i++)
{
var type = enumNameTypeAsset.types[i];
var intValue = new CodeMemberField
{
Attributes = MemberAttributes.Public | MemberAttributes.Static,
Name = type.name,
Type = new CodeTypeReference(typeof(int)),
InitExpression = new CodeSnippetExpression($"1 << {i}")
};
targetClass.Members.Add(intValue);
}
for (var i = 0; i < enumNameTypeAsset.groupTypes.Count; i++)
{
var groupType = enumNameTypeAsset.groupTypes[i];
var value = enumNameTypeAsset.MaskToString(groupType.value);
// var groupTypes = enumNameTypeAsset.GetMaskTypes(groupType.value);
// var strings = groupTypes.Select(t => t.name).ToArray();
// var value = string.Join(" | ", strings);
var intValue = new CodeMemberField
{
Attributes = MemberAttributes.Public | MemberAttributes.Static,
Name = groupType.name,
Type = new CodeTypeReference(typeof(int)),
InitExpression = new CodeSnippetExpression(value)
};
targetClass.Members.Add(intValue);
}
targetClass.Members.Add(new CodeMemberMethod()
{
Name = "MatchAny",
Attributes = MemberAttributes.Public | MemberAttributes.Static,
Parameters =
{
new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "a"),
new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "b")
},
ReturnType = new CodeTypeReference(typeof(bool)),
Statements =
{
new CodeSnippetExpression("return (a & b) != 0")
}
});
targetNamespace.Types.Add(targetClass);
targetUnit.Namespaces.Add(targetNamespace);
var provider = CodeDomProvider.CreateProvider("CSharp");
var options = new CodeGeneratorOptions
{
BlankLinesBetweenMembers = true,
BracingStyle = "C",
};
var generatedClassFile = $"{enumNameTypeAsset.className}.cs";
if (!Directory.Exists(targetFolder))
{
Directory.CreateDirectory(targetFolder);
}
using (var sourceWriter = new StreamWriter(Path.Combine(targetFolder, generatedClassFile)))
{
provider.GenerateCodeFromCompileUnit(targetUnit, sourceWriter, options);
}
AssetDatabase.Refresh();
}
/* goodB2G1() - use badsource and goodsink by changing second PRIVATE_CONST_TRUE to PRIVATE_CONST_FALSE */
private void GoodB2G1()
{
string data;
if (PRIVATE_CONST_TRUE)
{
data = ""; /* Initialize data */
{
/* read user input from console with ReadLine */
try
{
/* POTENTIAL FLAW: Read data from the console using ReadLine */
data = Console.ReadLine();
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
}
}
else
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run
* but ensure data is inititialized before the Sink to avoid compiler errors */
data = null;
}
if (PRIVATE_CONST_FALSE)
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
IO.WriteLine("Benign, fixed string");
}
else
{
int?parsedNum = null;
/* FIX: Validate user input prior to compiling */
try
{
parsedNum = int.Parse(data);
}
catch (FormatException exceptNumberFormat)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing number.");
}
if (parsedNum != null)
{
StringBuilder sourceCode = new StringBuilder("");
sourceCode.Append("public class Calculator \n{\n");
sourceCode.Append("\tpublic int Sum()\n\t{\n");
sourceCode.Append("\t\treturn (10 + " + data.ToString() + ");\n");
sourceCode.Append("\t}\n");
sourceCode.Append("}\n");
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters cp = new CompilerParameters();
CompilerResults cr = provider.CompileAssemblyFromSource(cp, sourceCode.ToString());
Assembly a = cr.CompiledAssembly;
object calculator = a.CreateInstance("Calculator");
Type calculatorType = calculator.GetType();
MethodInfo mi = calculatorType.GetMethod("Sum");
int s = (int)mi.Invoke(calculator, new object[] {});
IO.WriteLine("Result: " + s.ToString());
}
}
}
public string test()
{
List <Stream> lsstream = new List <Stream>();
List <ServiceDescription> lsdescription = new List <ServiceDescription>();
Dictionary <string, ServiceDescription> dicdescription = new Dictionary <string, ServiceDescription>();
XmlDocument doc = new XmlDocument();
doc.Load("DllConfig.xml");
string ServerURL = ((XmlElement)doc.SelectSingleNode("AutoCreate").SelectSingleNode("URLAddres")).GetAttribute("URL");
//CodeNamespace nmspace = new CodeNamespace();
CodeCompileUnit unit = new CodeCompileUnit();
//unit.Namespaces.Add(nmspace);
foreach (XmlNode xn in doc.SelectSingleNode("AutoCreate").SelectSingleNode("FileList").ChildNodes)
{
string _temp = ((XmlElement)xn).GetAttribute("Name");
if (!string.IsNullOrEmpty(_temp))
{
//nmspace.Name = string.Format("WebServices.{0}", _temp.Split('.')[0]);
//unit.Namespaces.Add(nmspace);
dicdescription.Add(string.Format("WebServices.{0}", _temp.Split('.')[0]), ServiceDescription.Read(web.OpenRead(string.Format("{0}{1}?WSDL", ServerURL, _temp))));
//lsdescription.Add(ServiceDescription.Read(web.OpenRead(string.Format("{0}{1}?WSDL", ServerURL, _temp))));
}
}
//int x = 0;
//foreach (ServiceDescription description in lsdescription)
//{
// ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
// importer.ProtocolName = "Soap";
// importer.Style = ServiceDescriptionImportStyle.Client;
// importer.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties | CodeGenerationOptions.GenerateNewAsync;
// importer.AddServiceDescription(description, null, null);
// //ServiceDescriptionImportWarnings warning = importer.Import(nmspace, unit);
// ServiceDescriptionImportWarnings warning = importer.Import(unit.Namespaces[x], unit);
// x++;
//}
foreach (string str in dicdescription.Keys)
{
CodeNamespace nmspace = new CodeNamespace();
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
importer.ProtocolName = "Soap";
importer.Style = ServiceDescriptionImportStyle.Client;
importer.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties | CodeGenerationOptions.GenerateNewAsync;
nmspace.Name = str;
unit.Namespaces.Add(nmspace);
importer.AddServiceDescription(dicdescription[str], null, null);
ServiceDescriptionImportWarnings warning = importer.Import(nmspace, unit);
}
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters parameter = new CompilerParameters();
parameter.GenerateExecutable = false;
parameter.OutputAssembly = "getWebServices.dll";
parameter.ReferencedAssemblies.Add("System.dll");
parameter.ReferencedAssemblies.Add("System.XML.dll");
parameter.ReferencedAssemblies.Add("System.Web.Services.dll");
parameter.ReferencedAssemblies.Add("System.Data.dll");
CompilerResults result = provider.CompileAssemblyFromDom(parameter, unit);
StringBuilder err = new StringBuilder(50000);
if (result.Errors.HasErrors)
{
for (int i = 0; i < result.Errors.Count; i++)
{
err.AppendLine(result.Errors[i].ErrorText);
}
}
return(err.ToString());
}
public DOLScriptCompiler()
{
compiler = new CSharpCodeProvider(new Dictionary <string, string> {
{ "CompilerVersion", "v4.0" }
});
}
public void CreateAllPointEstimateEvalObjects(Dictionary <string, string> dicFunction, Dictionary <string, string> dicSetupVariables)
{
try
{
if (dicPointEstimateMethodInfo != null)
{
dicPointEstimateMethodInfo.Clear();
}
else
{
dicPointEstimateMethodInfo = new Dictionary <string, object>();
}
foreach (KeyValuePair <string, string> k in dicFunction)
{
try
{
string strVariables = "";
int i = 0;
if (dicSetupVariables != null && dicSetupVariables.Count > 0 && dicSetupVariables.ContainsKey(k.Key))
{
while (i < dicSetupVariables.Count)
{
strVariables = dicSetupVariables.ToList()[i].Value; i++;
}
}
int icount = dicPointEstimateMethodInfo.Count;
CSharpCodeProvider csharpCodeProvider = new CSharpCodeProvider();
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("System.dll");
cp.CompilerOptions = "/t:library";
cp.GenerateInMemory = true;
Random rm = new Random();
cp.OutputAssembly = CommonClass.DataFilePath + "\\Tmp\\" + System.DateTime.Now.Year + System.DateTime.Now.Month + System.DateTime.Now.Day + DateTime.Now.Hour + DateTime.Now.Minute +
DateTime.Now.Second + DateTime.Now.Millisecond + rm.Next(2000) + ".dll";
StringBuilder myCode = new StringBuilder();
myCode.Append("using System;");
myCode.Append("namespace CoustomEval{");
myCode.Append("class myLibPointEstimate" + k.Key + " { public double myPow(double a) { return Math.Pow(a,2);} public double myMethod(double a, double b, double c, double beta, double deltaq, double q0, double q1, double incidence, double pop, double prevalence" + strVariables +
"){ try{" + k.Value + "} catch (Exception ex) { return -999999999; }}}");
myCode.Append("}");
CompilerResults cr = csharpCodeProvider.CompileAssemblyFromSource(cp, myCode.ToString());
Assembly assembly = cr.CompiledAssembly;
Type[] types = new Type[] { typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double) };
object tmp = assembly.CreateInstance("CoustomEval.myLibPointEstimate" + k.Key);
dicPointEstimateMethodInfo.Add(k.Key, tmp);
}
catch
{
}
}
}
catch (Exception ex)
{
}
}
public override bool RunTask()
{
// In Xamarin Studio, if the project name isn't a valid C# identifier
// then $(RootNamespace) is not set, and the generated Activity is
// placed into the "Application" namespace. VS just munges the project
// name to be a valid C# identifier.
// Use "Application" as the default namespace name to work with XS.
Namespace = Namespace ?? "Application";
if (!File.Exists(JavaResgenInputFile) && !UseManagedResourceGenerator)
{
return(true);
}
// ResourceDirectory may be a relative path, and
// we need to compare it to absolute paths
ResourceDirectory = Path.GetFullPath(ResourceDirectory);
var javaPlatformDirectory = Path.GetDirectoryName(JavaPlatformJarPath);
// Create our capitalization maps so we can support mixed case resources
foreach (var item in Resources)
{
if (!item.ItemSpec.StartsWith(ResourceDirectory))
{
continue;
}
var name = item.ItemSpec.Substring(ResourceDirectory.Length);
var logical_name = item.GetMetadata("LogicalName").Replace('\\', '/');
AddRename(name.Replace('/', Path.DirectorySeparatorChar), logical_name.Replace('/', Path.DirectorySeparatorChar));
}
if (AdditionalResourceDirectories != null)
{
foreach (var additionalDir in AdditionalResourceDirectories)
{
var file = Path.Combine(ProjectDir, Path.GetDirectoryName(additionalDir.ItemSpec), "__res_name_case_map.txt");
if (File.Exists(file))
{
foreach (var line in File.ReadAllLines(file).Where(l => !string.IsNullOrEmpty(l)))
{
string [] tok = line.Split(';');
AddRename(tok [1].Replace('/', Path.DirectorySeparatorChar), tok [0].Replace('/', Path.DirectorySeparatorChar));
}
}
}
}
// Parse out the resources from the R.java file
CodeTypeDeclaration resources;
if (UseManagedResourceGenerator)
{
var parser = new ManagedResourceParser()
{
Log = Log, JavaPlatformDirectory = javaPlatformDirectory, ResourceFlagFile = ResourceFlagFile
};
resources = parser.Parse(ResourceDirectory, AdditionalResourceDirectories?.Select(x => x.ItemSpec), IsApplication, resource_fixup);
}
else
{
var parser = new JavaResourceParser()
{
Log = Log
};
resources = parser.Parse(JavaResgenInputFile, IsApplication, resource_fixup);
}
var extension = Path.GetExtension(NetResgenOutputFile);
var language = string.Compare(extension, ".fs", StringComparison.OrdinalIgnoreCase) == 0 ? "F#" : CodeDomProvider.GetLanguageFromExtension(extension);
bool isVB = string.Equals(extension, ".vb", StringComparison.OrdinalIgnoreCase);
bool isFSharp = string.Equals(language, "F#", StringComparison.OrdinalIgnoreCase);
bool isCSharp = string.Equals(language, "C#", StringComparison.OrdinalIgnoreCase);
// Let VB put this in the default namespace
if (isVB)
{
Namespace = string.Empty;
}
List <string> aliases = new List <string> ();
// Create static resource overwrite methods for each Resource class in libraries.
if (IsApplication && References != null && References.Length > 0)
{
var assemblies = new List <ITaskItem> (References.Length);
foreach (var assembly in References)
{
var assemblyPath = assembly.ItemSpec;
var fileName = Path.GetFileName(assemblyPath);
if (MonoAndroidHelper.IsFrameworkAssembly(fileName) &&
!MonoAndroidHelper.FrameworkEmbeddedJarLookupTargets.Contains(fileName))
{
Log.LogDebugMessage($"Skipping framework assembly '{fileName}'.");
continue;
}
if (!File.Exists(assemblyPath))
{
Log.LogDebugMessage($"Skipping non-existent dependency '{assemblyPath}'.");
continue;
}
ITaskItem item = new TaskItem(assemblyPath);
assembly.CopyMetadataTo(item);
assemblies.Add(item);
string alias = assembly.GetMetadata("Aliases");
if (!string.IsNullOrEmpty(alias))
{
aliases.Add(alias);
}
Log.LogDebugMessage("Scan assembly {0} for resource generator", fileName);
}
new ResourceDesignerImportGenerator(Namespace, resources, Log)
.CreateImportMethods(assemblies);
}
AdjustConstructor(isFSharp, resources);
foreach (var member in resources.Members)
{
if (member is CodeTypeDeclaration)
{
AdjustConstructor(isFSharp, (CodeTypeDeclaration)member);
}
}
// Write out our Resources.Designer.cs file
WriteFile(NetResgenOutputFile, resources, language, isFSharp, isCSharp, aliases);
return(!Log.HasLoggedErrors);
}
/// <summary>
/// Initializes a new instance of the <see cref="LuaFileCodeModel"/> class.
/// </summary>
/// <param name="dte">Global DTE instance.</param>
/// <param name="provider">CodeDomProvider implementation.</param>
/// <param name="parent">Parent ProjectItem of FileCodeModel.</param>
/// <param name="filename">Code file name.</param>
public LuaFileCodeModel(DTE dte, ProjectItem parent, CodeDomProvider provider, string filename)
: base(dte, filename)
{
this.parent = parent;
this.provider = provider;
}
protected override string CreateProxyFile(DotNetProject dotNetProject, FilePath basePath, string proxyNamespace, string referenceName)
{
var ccu = new CodeCompileUnit();
var cns = new CodeNamespace(proxyNamespace);
ccu.Namespaces.Add(cns);
bool targetMoonlight = dotNetProject.TargetFramework.Id.Identifier == ("Silverlight");
bool targetMonoTouch = dotNetProject.TargetFramework.Id.Identifier == ("MonoTouch");
bool targetMonoDroid = dotNetProject.TargetFramework.Id.Identifier == ("MonoDroid");
bool targetCoreClr = targetMoonlight || targetMonoDroid || targetMonoTouch;
bool generateSyncMethods = targetMonoDroid | targetMonoTouch;
var generator = new ServiceContractGenerator(ccu);
generator.Options = ServiceContractGenerationOptions.ChannelInterface | ServiceContractGenerationOptions.ClientClass;
if (refGroup.ClientOptions.GenerateAsynchronousMethods || targetCoreClr)
{
generator.Options |= ServiceContractGenerationOptions.AsynchronousMethods;
}
if (refGroup.ClientOptions.GenerateEventBasedAsynchronousMethods)
{
generator.Options |= ServiceContractGenerationOptions.EventBasedAsynchronousMethods;
}
#if NET_4_5
if (refGroup.ClientOptions.GenerateTaskBasedAsynchronousMethod)
{
generator.Options |= ServiceContractGenerationOptions.TaskBasedAsynchronousMethod;
}
#endif
if (refGroup.ClientOptions.GenerateInternalTypes)
{
generator.Options |= ServiceContractGenerationOptions.InternalTypes;
}
if (refGroup.ClientOptions.GenerateMessageContracts)
{
generator.Options |= ServiceContractGenerationOptions.TypedMessages;
}
// if (targetMoonlight || targetMonoTouch)
// generator.Options |= ServiceContractGenerationOptions.EventBasedAsynchronousMethods;
MetadataSet mset;
mset = protocol != null?ToMetadataSet(protocol) : metadata;
CodeDomProvider code_provider = GetProvider(dotNetProject);
var list = new List <IWsdlImportExtension> ();
list.Add(new TransportBindingElementImporter());
list.Add(new XmlSerializerMessageContractImporter());
var importer = new WsdlImporter(mset);
try {
ConfigureImporter(importer);
} catch {
}
Collection <ContractDescription> contracts = importer.ImportAllContracts();
foreach (ContractDescription cd in contracts)
{
cd.Namespace = proxyNamespace;
if (targetCoreClr)
{
var moonctx = new MoonlightChannelBaseContext();
cd.Behaviors.Add(new MoonlightChannelBaseContractExtension(moonctx, generateSyncMethods));
foreach (var od in cd.Operations)
{
od.Behaviors.Add(new MoonlightChannelBaseOperationExtension(moonctx, generateSyncMethods));
}
generator.GenerateServiceContractType(cd);
moonctx.Fixup();
}
else
{
generator.GenerateServiceContractType(cd);
}
}
string fileSpec = Path.Combine(basePath, referenceName + "." + code_provider.FileExtension);
using (TextWriter w = File.CreateText(fileSpec)) {
code_provider.GenerateCodeFromCompileUnit(ccu, w, null);
}
return(fileSpec);
}
private static Assembly Compile(String outputAssembly, IEnumerable <String> references, CodeDomProvider provider, CompilerErrorCollection errors, Template tmp)
{
//String key = outputAssembly;
//if (String.IsNullOrEmpty(key)) key = Hash(String.Join(Environment.NewLine, sources));
var sb = new StringBuilder();
foreach (var item in tmp.Templates)
{
if (item.Included)
{
continue;
}
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.Append(item.Source);
}
String key = Hash(sb.ToString());
Assembly assembly = null;
if (asmCache.TryGetValue(key, out assembly))
{
return(assembly);
}
lock (asmCache)
{
if (asmCache.TryGetValue(key, out assembly))
{
return(assembly);
}
foreach (var str in references)
{
try
{
if (!String.IsNullOrEmpty(str) && File.Exists(str))
{
Assembly.LoadFrom(str);
}
}
catch { }
}
assembly = CompileInternal(outputAssembly, references, provider, errors, tmp);
if (assembly != null)
{
asmCache.Add(key, assembly);
}
return(assembly);
}
}
public CSharpCompiler(CodeDomProvider codeDomProvider, IProviderOptions providerOptions = null)
: base(codeDomProvider, providerOptions)
{
}
private static bool CompileAssembly(PlgxPluginInfo plgx,
out CompilerResults cr, string strCompilerVersion)
{
cr = null;
const string StrCoreRef = "System.Core";
const string StrCoreDll = "System.Core.dll";
bool bHasCore = false, bCoreAdded = false;
foreach (string strAsm in plgx.CompilerParameters.ReferencedAssemblies)
{
if (UrlUtil.AssemblyEquals(strAsm, StrCoreRef))
{
bHasCore = true;
break;
}
}
if ((strCompilerVersion != null) && strCompilerVersion.StartsWith(
"v", StrUtil.CaseIgnoreCmp))
{
ulong v = StrUtil.ParseVersion(strCompilerVersion.Substring(1));
if (!bHasCore && (v >= 0x0003000500000000UL))
{
plgx.CompilerParameters.ReferencedAssemblies.Add(StrCoreDll);
bCoreAdded = true;
}
}
bool bResult = false;
try
{
Dictionary <string, string> dictOpt = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(strCompilerVersion))
{
dictOpt.Add("CompilerVersion", strCompilerVersion);
}
// Windows 98 only supports the parameterless constructor;
// check must be separate from the instantiation method
if (WinUtil.IsWindows9x)
{
dictOpt.Clear();
}
CodeDomProvider cdp = null;
if (plgx.ProjectType == PlgxProjectType.CSharp)
{
cdp = ((dictOpt.Count == 0) ? new CSharpCodeProvider() :
CreateCscProvider(dictOpt));
}
// else if(plgx.ProjectType == PlgxProjectType.VisualBasic)
// cdp = ((dictOpt.Count == 0) ? new VBCodeProvider() :
// new VBCodeProvider(dictOpt));
else
{
throw new InvalidOperationException();
}
cr = cdp.CompileAssemblyFromFile(plgx.CompilerParameters,
plgx.SourceFiles.ToArray());
bResult = ((cr.Errors == null) || !cr.Errors.HasErrors);
}
catch (Exception) { }
if (bCoreAdded)
{
plgx.CompilerParameters.ReferencedAssemblies.Remove(StrCoreDll);
}
return(bResult);
}
public bool Execute()
{
try
{
if (this.ApplicationMarkup == null || this.ApplicationMarkup.Count == 0)
{
return(true);
}
if (!CodeDomProvider.IsDefinedLanguage(this.Language))
{
throw FxTrace.Exception.Argument("Language", SR.UnrecognizedLanguage(this.Language));
}
if (this.SupportExtensions)
{
this.xamlBuildTypeGenerationExtensions = XamlBuildTaskServices.GetXamlBuildTaskExtensions <IXamlBuildTypeGenerationExtension>(
this.XamlBuildTaskTypeGenerationExtensionNames,
this.BuildLogger,
this.MSBuildProjectDirectory);
}
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(XamlBuildTaskServices.ReflectionOnlyAssemblyResolve);
bool retVal = true;
// We load the assemblies for the real builds
// For intellisense builds, we load them the first time only
if (!IsInProcessXamlMarkupCompile || this.LoadedAssemblyList == null)
{
if (this.References != null)
{
try
{
this.LoadedAssemblyList = XamlBuildTaskServices.Load(this.References, IsInProcessXamlMarkupCompile);
}
catch (FileNotFoundException e)
{
XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, e.FileName, 0, 0);
retVal = false;
}
}
}
CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider(this.Language);
ProcessHelperClassGeneration(codeDomProvider);
foreach (ITaskItem app in ApplicationMarkup)
{
string inputMarkupFile = app.ItemSpec;
try
{
retVal &= ProcessMarkupItem(app, codeDomProvider);
}
catch (LoggableException e)
{
if (Fx.IsFatal(e))
{
throw;
}
XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, e.Source, e.LineNumber, e.LinePosition);
retVal = false;
}
catch (FileLoadException e)
{
if (Fx.IsFatal(e))
{
throw;
}
XamlBuildTaskServices.LogException(this.BuildLogger, SR.AssemblyCannotBeResolved(XamlBuildTaskServices.FileNotLoaded), inputMarkupFile, 0, 0);
retVal = false;
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, inputMarkupFile, 0, 0);
retVal = false;
}
}
// Add the files generated from extensions
if (this.SupportExtensions)
{
if (retVal)
{
foreach (string fileName in this.BuildContextForExtensions.GeneratedFiles)
{
this.GeneratedCodeFiles.Add(fileName);
}
foreach (string fileName in this.BuildContextForExtensions.GeneratedResourceFiles)
{
this.GeneratedResources.Add(fileName);
}
}
}
return(retVal);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
// Log unknown errors that do not originate from the task.
// Assumes that all known errors are logged when the exception is thrown.
if (!(e is LoggableException))
{
XamlBuildTaskServices.LogException(this.BuildLogger, e.Message);
}
return(false);
}
}
public VsCodeDomLoader(DesignerLoader loader, IVsHierarchy hier, int itemid, CodeDomProvider provider, TextBuffer buffer, IDesignerLoaderHost host) : base(loader, provider, buffer, host)
{
this.vsHierarchy = hier;
this.itemid = itemid;
}
private static Assembly CompileInternal(String outputAssembly, IEnumerable <String> references, CodeDomProvider provider, CompilerErrorCollection Errors, Template tmp)
{
var options = new CompilerParameters();
foreach (var str in references)
{
options.ReferencedAssemblies.Add(str);
}
options.WarningLevel = 4;
CompilerResults results = null;
if (Debug)
{
//var sb = new StringBuilder();
#region 调试状态，把生成的类文件和最终dll输出到XTemp目录下
var tempPath = XTrace.TempPath;
//if (!String.IsNullOrEmpty(outputAssembly)) tempPath = Path.Combine(tempPath, Path.GetFileNameWithoutExtension(outputAssembly));
if (!String.IsNullOrEmpty(outputAssembly) && !outputAssembly.EqualIgnoreCase(".dll"))
{
tempPath = Path.Combine(tempPath, Path.GetFileNameWithoutExtension(outputAssembly));
}
//if (!String.IsNullOrEmpty(tempPath) && !Directory.Exists(tempPath)) Directory.CreateDirectory(tempPath);
//var srcpath = tempPath.CombinePath("src").EnsureDirectory(false);
var files = new List <String>();
foreach (var item in tmp.Templates)
{
// 输出模版内容，为了调试使用
File.WriteAllText(tempPath.CombinePath(item.Name), item.Content);
if (item.Included)
{
continue;
}
var name = item.Name.EndsWithIgnoreCase(".cs") ? item.Name : item.ClassName;
// 猜测后缀
Int32 p = name.LastIndexOf("_");
if (p > 0 && name.Length - p <= 5)
{
name = name.Substring(0, p) + "." + name.Substring(p + 1, name.Length - p - 1);
}
else if (!name.EndsWithIgnoreCase(".cs"))
{
name += ".cs";
}
//name = Path.Combine(tempPath, name);
//name = srcpath.CombinePath(name);
// 必须放在同一个目录，编译时会搜索源码所在目录
name = tempPath.CombinePath(Path.GetFileNameWithoutExtension(name) + "_src" + Path.GetExtension(name));
File.WriteAllText(name, item.Source);
//sb.AppendLine(item.Source);
files.Add(name);
}
#endregion
if (!String.IsNullOrEmpty(outputAssembly) && !outputAssembly.EqualIgnoreCase(".dll"))
{
options.TempFiles = new TempFileCollection(tempPath, false);
options.OutputAssembly = Path.Combine(tempPath, outputAssembly);
//options.GenerateInMemory = true;
options.IncludeDebugInformation = true;
}
results = provider.CompileAssemblyFromFile(options, files.ToArray());
// 必须从内存字符串编译，否则pdb会定向到最终源代码文件
//results = provider.CompileAssemblyFromSource(options, new String[] { sb.ToString() });
}
else
{
options.GenerateInMemory = true;
results = provider.CompileAssemblyFromSource(options, tmp.Templates.Where(e => !e.Included).Select(e => e.Source).ToArray());
}
#region 编译错误处理
if (results.Errors.Count > 0)
{
Errors.AddRange(results.Errors);
var sb = new StringBuilder();
CompilerError err = null;
foreach (CompilerError error in results.Errors)
{
error.ErrorText = error.ErrorText;
//if (String.IsNullOrEmpty(error.FileName)) error.FileName = inputFile;
if (!error.IsWarning)
{
String msg = error.ToString();
if (sb.Length < 1)
{
String code = null;
// 屏蔽因为计算错误行而导致的二次错误
try
{
code = tmp.FindBlockCode(error.FileName, error.Line);
}
catch { }
if (code != null)
{
msg += Environment.NewLine;
msg += code;
}
err = error;
}
else
{
sb.AppendLine();
}
sb.Append(msg);
}
}
if (sb.Length > 0)
{
var ex = new TemplateException(sb.ToString());
ex.Error = err;
throw ex;
}
}
else
{
try
{
options.TempFiles.Delete();
}
catch { }
}
#endregion
if (!results.Errors.HasErrors)
{
try
{
return(results.CompiledAssembly);
}
catch { }
}
return(null);
}
private static void Json2Class(string fileName, string json, List <object> statements)
{
string structName = "";
structName = Path.GetFileName(fileName).ToLower().Replace(".xlsx", "");
//首字母大写
structName = structName.Substring(0, 1).ToUpper() + structName.Substring(1);
//输出目录控制
string outputFile = Path.Combine(Application.dataPath, "Code/Game@hotfix/Table");
if (Directory.Exists(outputFile) == false)
{
Directory.CreateDirectory(outputFile);
}
//输出目录
outputFile = Path.Combine(outputFile, Path.GetFileName(fileName).Replace(".xlsx", ".cs"));
//生成类服务
CodeCompileUnit compunit = new CodeCompileUnit();
CodeNamespace sample = new CodeNamespace("Game.Data");
compunit.Namespaces.Add(sample);
//引用命名空间
sample.Imports.Add(new CodeNamespaceImport("System"));
sample.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
sample.Imports.Add(new CodeNamespaceImport("Game.Data"));
sample.Imports.Add(new CodeNamespaceImport("SQLite4Unity3d"));
//在命名空间下添加一个类
CodeTypeDeclaration wrapProxyClass = new CodeTypeDeclaration(structName);
wrapProxyClass.IsClass = true;
wrapProxyClass.IsEnum = false;
wrapProxyClass.IsInterface = false;
wrapProxyClass.IsPartial = false;
wrapProxyClass.IsStruct = false;
//把这个类添加到命名空间
sample.Types.Add(wrapProxyClass);
CodeAttributeDeclaration attr = new CodeAttributeDeclaration("Serializable");
wrapProxyClass.CustomAttributes.Add(attr);
//
var jsonData = JsonMapper.ToObject(json)[0];
int i = 0;
foreach (var key in jsonData.Keys)
{
//字段
string memberContent =
@" public [type] [Name] {get;set;}";
CodeSnippetTypeMember member = new CodeSnippetTypeMember();
if (key.ToLower() == "id" && key != "Id")
{
Debug.LogErrorFormat("<color=yellow>表格{0}字段必须为Id[大小写],请修改后生成</color>", structName);
break;
}
else if (key == "Id")
{
//增加一个sqlite主键
//member.CustomAttributes.Add(new CodeAttributeDeclaration("PrimaryKey"));
memberContent =
@" [PrimaryKey]
public [type] [Name] {get;set;}";
}
var value = jsonData[key];
string type = null;
if (value.IsArray)
{
var str = value.ToJson();
if (str.IndexOf("\"") > 0)
{
type = "List<string>";
}
else
{
type = "List<double>";
}
}
else if (value.IsInt)
{
type = "int";
}
else if (value.IsDouble || value.IsLong)
{
type = "double";
}
else if (value.IsBoolean)
{
type = "bool";
}
else if (value.IsString)
{
type = "string";
}
//注释
member.Comments.Add(new CodeCommentStatement(statements[i].ToString()));
member.Text = memberContent.Replace("[type]", type).Replace("[Name]", key);
wrapProxyClass.Members.Add(member);
i++;
}
//生成代码
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
options.BlankLinesBetweenMembers = true;
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(outputFile))
{
provider.GenerateCodeFromCompileUnit(compunit, sw, options);
}
}
public void SetToVisualBasicNet()
{
compiler = new VBCodeProvider();
}
/// <summary>生成成员代码块</summary>
/// <param name="block"></param>
/// <param name="generatorType"></param>
/// <param name="lineNumbers"></param>
/// <param name="provider"></param>
/// <param name="options"></param>
/// <param name="firstMemberFound"></param>
/// <returns></returns>
private static Boolean GenerateMemberForBlock(Block block, CodeTypeDeclaration generatorType, Boolean lineNumbers, CodeDomProvider provider, CodeGeneratorOptions options, Boolean firstMemberFound)
{
CodeSnippetTypeMember member = null;
if (!firstMemberFound)
{
// 发现第一个<#!后，认为是类成员代码的开始，直到下一个<#!作为结束
if (block.Type == BlockType.Member)
{
firstMemberFound = true;
if (!String.IsNullOrEmpty(block.Text))
{
member = new CodeSnippetTypeMember(block.Text);
}
}
}
else
{
// 再次遇到<#!，此时，成员代码准备结束
if (block.Type == BlockType.Member)
{
firstMemberFound = false;
if (!String.IsNullOrEmpty(block.Text))
{
member = new CodeSnippetTypeMember(block.Text);
}
}
else if (block.Type == BlockType.Text)
{
var expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Write", new CodeExpression[] { new CodePrimitiveExpression(block.Text) });
var statement = new CodeExpressionStatement(expression);
using (var writer = new StringWriter())
{
provider.GenerateCodeFromStatement(statement, writer, options);
member = new CodeSnippetTypeMember(writer.ToString());
}
}
else if (block.Type == BlockType.Expression)
{
var expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Write", new CodeExpression[] { new CodeArgumentReferenceExpression(block.Text.Trim()) });
var statement = new CodeExpressionStatement(expression);
using (var writer = new StringWriter())
{
provider.GenerateCodeFromStatement(statement, writer, options);
member = new CodeSnippetTypeMember(writer.ToString());
}
}
else if (block.Type == BlockType.Statement)
{
member = new CodeSnippetTypeMember(block.Text);
}
}
if (member != null)
{
if (lineNumbers)
{
var flag = String.IsNullOrEmpty(block.Name);
var lineNumber = (block.StartLine > 0) ? block.StartLine : 1;
if (flag)
{
generatorType.Members.Add(new CodeSnippetTypeMember("#line " + lineNumber));
}
else
{
member.LinePragma = new CodeLinePragma(block.Name, lineNumber);
}
generatorType.Members.Add(member);
if (flag)
{
generatorType.Members.Add(new CodeSnippetTypeMember("#line default"));
}
}
else
{
generatorType.Members.Add(member);
}
}
return(firstMemberFound);
}
public object ValuationEval(string cCharpCode, double a, double b, double c, double d, double allgoodsindex, double medicalcostindex, double wageindex, double lagadjustment, Dictionary <string, double> dicSetupVariables)
{
try
{
MethodInfo mi = null;
object tmp = null;
List <object> lstParam = new List <object>()
{
a, b, c, d, allgoodsindex, medicalcostindex, wageindex, lagadjustment
};
if (dicSetupVariables != null && dicSetupVariables.Count > 0)
{
int j = 0;
while (j < dicSetupVariables.Count)
{
lstParam.Add(dicSetupVariables.ToList()[j].Value);
j++;
}
}
if (!dicValuationMethodInfo.Keys.Contains(cCharpCode))
{
string strVariables = "";
int i = 0;
if (dicSetupVariables != null && dicSetupVariables.Count > 0)
{
while (i < dicSetupVariables.Count)
{
strVariables = strVariables + ",double " + dicSetupVariables.ToList()[i].Key.ToLower();
i++;
}
}
if (a != 0)
{
}
_CharpCode = cCharpCode;
int icount = dicValuationMethodInfo.Count;
CSharpCodeProvider csharpCodeProvider = new CSharpCodeProvider();
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("system.dll");
cp.CompilerOptions = "/t:library";
cp.GenerateInMemory = true;
Random rm = new Random();
cp.OutputAssembly = CommonClass.DataFilePath + "\\Tmp\\" + System.DateTime.Now.Year + System.DateTime.Now.Month + System.DateTime.Now.Day + DateTime.Now.Hour + DateTime.Now.Minute +
DateTime.Now.Second + DateTime.Now.Millisecond + rm.Next(2000) + ".dll";
StringBuilder myCode = new StringBuilder();
myCode.Append("using System;");
myCode.Append("namespace CoustomEval{");
myCode.Append("class myLibValuation" + icount + " {public double myPow(double a) { return Math.Pow(a,2);} public double myMethod(double a, double b, double c, double d, double allgoodsindex, double medicalcostindex, double wageindex, double lagadjustment" + strVariables +
"){ try{" + cCharpCode + "} catch (Exception ex) { return -999999999; }}}");
myCode.Append("}");
CompilerResults cr = provider.CompileAssemblyFromSource(cp, myCode.ToString());
Assembly assembly = cr.CompiledAssembly;
Type[] types = new Type[] { typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double) };
tmp = assembly.CreateInstance("CoustomEval.myLibValuation" + icount);
dicValuationMethodInfo.Add(cCharpCode, tmp);
}
else
{
tmp = dicValuationMethodInfo[cCharpCode];
}
Type type = tmp.GetType();
mi = type.GetMethod("myMethod");
object result = mi.Invoke(tmp, lstParam.ToArray());
return(result);
}
catch (Exception ex)
{
return(-999999999);
}
}
public void GenerateCode()
{
// open the file for writing
string fileName = "FavSettings";
Stream s = File.Open(fileName + ".cs", FileMode.Create);
StreamWriter wrtr = new StreamWriter(s);
wrtr.WriteLine("// Dynamically created FavSettings class");
wrtr.WriteLine("using System.ComponentModel;");
wrtr.WriteLine("using NetCams;");
// create the class
string className = mSequenceNamed_sanitized + "_FavoriteSettings";
wrtr.WriteLine("class {0} : NetCams.FavoriteSettings", className);
wrtr.WriteLine("{");
// create the method
wrtr.WriteLine("\tpublic {0}(TestSequence seq)", className);
wrtr.WriteLine("\t\t: base(seq)");
wrtr.WriteLine("\t{");
wrtr.Write(ctorBody);
wrtr.WriteLine("\t}");
wrtr.WriteLine("\t");
//wrtr.WriteLine("\tpublic TestSequence mTestSequence;");
//wrtr.WriteLine("\t");
wrtr.Write(classBody);
wrtr.WriteLine("}"); // end class
// close the writer and the stream
wrtr.Close();
s.Close();
/*
* // Build the file
* ProcessStartInfo psi = new ProcessStartInfo();
*
* psi.FileName = "cmd.exe";
*
* string compileString = "/c C:\\WINDOWS\\Microsoft.NET\\Framework\\v2.0.50727\\csc /optimize+ ";
* compileString += "/r:\"UVision.exe\" ";
* compileString += "/target:library ";
* compileString += "{0}.cs > compile.out";
*
* psi.Arguments = String.Format(compileString, fileName);
*
* psi.WindowStyle = ProcessWindowStyle.Minimized;
*
* Process proc = Process.Start(psi);
*
* proc.WaitForExit(); // wait at most 2 seconds
*
* // Open the file, and get a pointer to the method info
* Assembly a = Assembly.LoadFrom(fileName + ".dll");
* mTestSequence.mFavoriteSettings = (FavoriteSettings)a.CreateInstance(className);
*/
CompilerParameters cp = new CompilerParameters();
// Generate an executable instead of a class library.
cp.GenerateExecutable = false;
// Specify the assembly file name to generate.
//cp.OutputAssembly = exeName;
// Save the assembly as a physical file.
cp.GenerateInMemory = true;
// Set whether to treat all warnings as errors.
cp.TreatWarningsAsErrors = false;
// Add an assembly reference.
cp.ReferencedAssemblies.Add("UVision.exe");
cp.ReferencedAssemblies.Add("System.dll");
// cp.ReferencedAssemblies.Add("System.ComponentModel.dll");// Copyright (c) 2004-2008 Userwise Solutions LLC. All rights reserved.
// Invoke compilation of the source file.
string sourceName = fileName + ".cs";
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceName);
if (cr.Errors.Count > 0)
{
// Display compilation errors.
Console.WriteLine("Errors building {0} into {1}", sourceName, cr.PathToAssembly);
foreach (CompilerError ce in cr.Errors)
{
Console.WriteLine(" {0}", ce.ToString());
Console.WriteLine();
}
}
else
{
// Display a successful compilation message.
Console.WriteLine("Source {0} built into {1} successfully.", sourceName, cr.PathToAssembly);
Assembly a = cr.CompiledAssembly;
object[] args = { mTestSequence };
mTestSequence.mFavoriteSettings = (FavoriteSettings)a.CreateInstance(className, false, BindingFlags.Default | BindingFlags.CreateInstance, null, args, null, null);
}
//File.Delete(fileName + ".cs"); // clean up
}
public static ICodeTemplate CreateDefaultTemplate(TemplateType templateType, Session session, Type codeTemplateType, CodeDomProvider codeDomProvider)
{
var defaultTemplate = CodeTemplateQuery.FindDefaultTemplate(templateType, session, codeTemplateType, codeDomProvider);
if (defaultTemplate == null)
{
defaultTemplate = (ICodeTemplate)ReflectionHelper.CreateObject(codeTemplateType, session);
defaultTemplate.IsDefault = true;
defaultTemplate.TemplateType = templateType;
defaultTemplate.CodeDomProvider = codeDomProvider;
defaultTemplate.SetDefaults();
}
return(defaultTemplate);
}
private void WriteFile(string file, CodeTypeDeclaration resources, string language, bool isFSharp, bool isCSharp, IEnumerable <string> aliases)
{
CodeDomProvider provider =
isFSharp ? new FSharp.Compiler.CodeDom.FSharpCodeProvider() :
CodeDomProvider.CreateProvider(language);
string code = null;
using (var o = new StringWriter()) {
var options = new CodeGeneratorOptions()
{
BracingStyle = "C",
IndentString = "\t",
};
var ns = string.IsNullOrEmpty(Namespace)
? new CodeNamespace()
: new CodeNamespace(Namespace);
if (resources != null)
{
ns.Types.Add(resources);
}
var unit = new CodeCompileUnit();
unit.Namespaces.Add(ns);
var resgenatt = new CodeAttributeDeclaration(new CodeTypeReference("Android.Runtime.ResourceDesignerAttribute", CodeTypeReferenceOptions.GlobalReference));
resgenatt.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(Namespace.Length > 0 ? Namespace + ".Resource" : "Resource")));
resgenatt.Arguments.Add(new CodeAttributeArgument("IsApplication", new CodePrimitiveExpression(IsApplication)));
unit.AssemblyCustomAttributes.Add(resgenatt);
// Add Pragma to disable warnings about no Xml documentation
if (isCSharp)
{
foreach (var alias in aliases)
{
provider.GenerateCodeFromStatement(new CodeSnippetStatement($"extern alias {alias};"), o, options);
}
provider.GenerateCodeFromCompileUnit(new CodeSnippetCompileUnit("#pragma warning disable 1591"), o, options);
}
provider.CreateGenerator(o).GenerateCodeFromCompileUnit(unit, o, options);
// Add Pragma to re-enable warnings about no Xml documentation
if (isCSharp)
{
provider.GenerateCodeFromCompileUnit(new CodeSnippetCompileUnit("#pragma warning restore 1591"), o, options);
}
code = o.ToString();
// post-processing for F#
if (isFSharp)
{
code = code.Replace("\r\n", "\n");
while (true)
{
int skipLen = " = class".Length;
int idx = code.IndexOf(" = class");
if (idx < 0)
{
break;
}
int end = code.IndexOf(" end");
string head = code.Substring(0, idx);
string mid = end < 0 ? code.Substring(idx) : code.Substring(idx + skipLen, end - idx - skipLen);
string last = end < 0 ? null : code.Substring(end + " end".Length);
code = head + @" () =
static do Android.Runtime.ResourceIdManager.UpdateIdValues()" + mid + "\n" + last;
}
}
}
if (MonoAndroidHelper.CopyIfStringChanged(code, file))
{
Log.LogDebugMessage($"Writing to: {file}");
}
}
// Get a code generator for the specified language. language can either be a known abbreviation
// for C#, VB or JScript. Or it can be a fully-qualified (with assembly) name for an ICodeGenerator
// or a CodeDomProvider.
void CreateCodeGenerator(string language, ref ICodeGenerator codeGen, ref string fileExtension)
{
CodeDomProvider codeProvider = null;
if ((string.Compare(language, "CSharp", true) == 0) ||
(string.Compare(language, "C#", true) == 0) ||
(string.Compare(language, "CS", true) == 0))
{
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
}
else if (string.Compare(language, "VB", true) == 0)
{
throw new Exception("VisualBasic not supported in the SSCLI");
}
else if ((string.Compare(language, "js", true) == 0) ||
(string.Compare(language, "jscript", true) == 0))
{
Type t = Type.GetType("Microsoft.JScript.JScriptCodeProvider, " + AssemblyRef.MicrosoftJScript);
codeProvider = (CodeDomProvider)Activator.CreateInstance(t);
}
else
{
//try to reflect a custom code generator
//ignore case when reflecting; language argument must specify the namespace
Type t = Type.GetType(language, false, true);
if (t == null)
{
throw new InvalidOperationException(Res.GetString(Res.ErrLanguage, language));
}
object o = Activator.CreateInstance(t);
if (o is CodeDomProvider)
{
codeProvider = (CodeDomProvider)o;
}
else if (o is ICodeGenerator)
{
codeGen = (ICodeGenerator)o;
}
else
{
throw new InvalidOperationException(Res.GetString(Res.ErrLanguage, language));
}
}
if (codeProvider != null)
{
codeGen = codeProvider.CreateGenerator();
fileExtension = codeProvider.FileExtension;
if (fileExtension == null)
{
fileExtension = string.Empty;
}
else if (fileExtension.Length > 0 && fileExtension[0] != '.')
{
fileExtension = "." + fileExtension;
}
}
else
{
fileExtension = ".src";
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LuaFileCodeModel"/> class.
/// </summary>
/// <param name="dte">Global DTE instance.</param>
/// <param name="buffer">IVsTextLines instance.</param>
/// <param name="provider">CodeDomProvider implementation.</param>
/// <param name="moniker">File moniker.</param>
public LuaFileCodeModel(DTE dte, IVsTextLines buffer, CodeDomProvider provider, string moniker)
: base(dte, moniker)
{
TextBuffer = buffer;
this.provider = provider;
}
// Module defining this command
// Optional custom code for this activity
/// <summary>
/// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run.
/// </summary>
/// <param name="context">The NativeActivityContext for the currently running activity.</param>
/// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns>
/// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks>
protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context)
{
System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create();
System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName);
// Initialize the arguments
if (CodeDomProvider.Expression != null)
{
targetCommand.AddParameter("CodeDomProvider", CodeDomProvider.Get(context));
}
if (CompilerParameters.Expression != null)
{
targetCommand.AddParameter("CompilerParameters", CompilerParameters.Get(context));
}
if (TypeDefinition.Expression != null)
{
targetCommand.AddParameter("TypeDefinition", TypeDefinition.Get(context));
}
if (Name.Expression != null)
{
targetCommand.AddParameter("Name", Name.Get(context));
}
if (MemberDefinition.Expression != null)
{
targetCommand.AddParameter("MemberDefinition", MemberDefinition.Get(context));
}
if (Namespace.Expression != null)
{
targetCommand.AddParameter("Namespace", Namespace.Get(context));
}
if (UsingNamespace.Expression != null)
{
targetCommand.AddParameter("UsingNamespace", UsingNamespace.Get(context));
}
if (Path.Expression != null)
{
targetCommand.AddParameter("Path", Path.Get(context));
}
if (LiteralPath.Expression != null)
{
targetCommand.AddParameter("LiteralPath", LiteralPath.Get(context));
}
if (AssemblyName.Expression != null)
{
targetCommand.AddParameter("AssemblyName", AssemblyName.Get(context));
}
if (Language.Expression != null)
{
targetCommand.AddParameter("Language", Language.Get(context));
}
if (ReferencedAssemblies.Expression != null)
{
targetCommand.AddParameter("ReferencedAssemblies", ReferencedAssemblies.Get(context));
}
if (OutputAssembly.Expression != null)
{
targetCommand.AddParameter("OutputAssembly", OutputAssembly.Get(context));
}
if (OutputType.Expression != null)
{
targetCommand.AddParameter("OutputType", OutputType.Get(context));
}
if (PassThru.Expression != null)
{
targetCommand.AddParameter("PassThru", PassThru.Get(context));
}
if (IgnoreWarnings.Expression != null)
{
targetCommand.AddParameter("IgnoreWarnings", IgnoreWarnings.Get(context));
}
return(new ActivityImplementationContext()
{
PowerShellInstance = invoker
});
}
private string GenerateCode(out string extension)
{
extension = null;
bool haveGeneratedContent = false;
CodeDomProvider provider;
try
{
provider = CodeDomProvider.CreateProvider(Language);
}
catch (System.Configuration.ConfigurationException ex)
{
Log.LogErrorWithCodeFromResources("WriteCodeFragment.CouldNotCreateProvider", Language, ex.Message);
return(null);
}
catch (SecurityException ex)
{
Log.LogErrorWithCodeFromResources("WriteCodeFragment.CouldNotCreateProvider", Language, ex.Message);
return(null);
}
extension = provider.FileExtension;
var unit = new CodeCompileUnit();
var globalNamespace = new CodeNamespace();
unit.Namespaces.Add(globalNamespace);
// Declare authorship. Unfortunately CodeDOM puts this comment after the attributes.
string comment = ResourceUtilities.GetResourceString("WriteCodeFragment.Comment");
globalNamespace.Comments.Add(new CodeCommentStatement(comment));
if (AssemblyAttributes == null)
{
return(String.Empty);
}
// For convenience, bring in the namespaces, where many assembly attributes lie
globalNamespace.Imports.Add(new CodeNamespaceImport("System"));
globalNamespace.Imports.Add(new CodeNamespaceImport("System.Reflection"));
foreach (ITaskItem attributeItem in AssemblyAttributes)
{
var attribute = new CodeAttributeDeclaration(new CodeTypeReference(attributeItem.ItemSpec));
// Some attributes only allow positional constructor arguments, or the user may just prefer them.
// To set those, use metadata names like "_Parameter1", "_Parameter2" etc.
// If a parameter index is skipped, it's an error.
IDictionary customMetadata = attributeItem.CloneCustomMetadata();
var orderedParameters = new List <CodeAttributeArgument>(new CodeAttributeArgument[customMetadata.Count + 1] /* max possible slots needed */);
var namedParameters = new List <CodeAttributeArgument>();
foreach (DictionaryEntry entry in customMetadata)
{
string name = (string)entry.Key;
string value = (string)entry.Value;
if (name.StartsWith("_Parameter", StringComparison.OrdinalIgnoreCase))
{
if (!Int32.TryParse(name.Substring("_Parameter".Length), out int index))
{
Log.LogErrorWithCodeFromResources("General.InvalidValue", name, "WriteCodeFragment");
return(null);
}
if (index > orderedParameters.Count || index < 1)
{
Log.LogErrorWithCodeFromResources("WriteCodeFragment.SkippedNumberedParameter", index);
return(null);
}
// "_Parameter01" and "_Parameter1" would overwrite each other
orderedParameters[index - 1] = new CodeAttributeArgument(String.Empty, new CodePrimitiveExpression(value));
}
else
{
namedParameters.Add(new CodeAttributeArgument(name, new CodePrimitiveExpression(value)));
}
}
bool encounteredNull = false;
for (int i = 0; i < orderedParameters.Count; i++)
{
if (orderedParameters[i] == null)
{
// All subsequent args should be null, else a slot was missed
encounteredNull = true;
continue;
}
if (encounteredNull)
{
Log.LogErrorWithCodeFromResources("WriteCodeFragment.SkippedNumberedParameter", i + 1 /* back to 1 based */);
return(null);
}
attribute.Arguments.Add(orderedParameters[i]);
}
foreach (CodeAttributeArgument namedParameter in namedParameters)
{
attribute.Arguments.Add(namedParameter);
}
unit.AssemblyCustomAttributes.Add(attribute);
haveGeneratedContent = true;
}
var generatedCode = new StringBuilder();
using (var writer = new StringWriter(generatedCode, CultureInfo.CurrentCulture))
{
provider.GenerateCodeFromCompileUnit(unit, writer, new CodeGeneratorOptions());
}
string code = generatedCode.ToString();
// If we just generated infrastructure, don't bother returning anything
// as there's no point writing the file
return(haveGeneratedContent ? code : String.Empty);
}
public Generator(CodeDomProvider codeProvider, string extension)
{
DefaultExtension = extension;
CodeProvider = codeProvider;
}
public override string ImportSchemaType(string name, string namespaceName, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider)
{
throw new NotImplementedException();
}
