///
/// <summary>
/// Fetch the Code Provider for the language specified by the 'language' members.
/// </summary>
///
private CodeDomProvider GetProvider()
{
CodeDomProvider provider;
Type type;
switch (language.ToUpper())
{
case "CS":
provider = new CSharpCodeProvider();
break;
case "VB":
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
case "BOO":
type = Type.GetType("Boo.Lang.CodeDom.BooCodeProvider, Boo.Lang.CodeDom, Version=1.0.0.0, Culture=neutral, PublicKeyToken=32c39770e9a21a67");
if (type != null)
{
return((CodeDomProvider)Activator.CreateInstance(type));
}
throw new Exception("Boo.Lang.CodeDom.BooCodeProvider not available");
default:
type = Type.GetType(language);
if (type != null)
{
return((CodeDomProvider)Activator.CreateInstance(type));
}
throw new Exception("Unknown language");
}
return(provider);
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
if (_csStatement != null)
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromStatement(_csStatement, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
if (_vbStatement != null)
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromStatement(_vbStatement, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("continue;");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Continue For");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
// public ���\�b�h
public void CompileFile(string filePath)
{
if(!File.Exists(filePath)){
throw new Exception("�t�@�C��������܂��� : " + filePath);
}
CodeDomProvider myCompiler;
string ext = Path.GetExtension(filePath).ToLower();
switch(ext){
case JsExt:
myCompiler = new Microsoft.JScript.JScriptCodeProvider();
break;
case CsExt:
myCompiler = new Microsoft.CSharp.CSharpCodeProvider();
break;
case VbExt:
myCompiler = new Microsoft.VisualBasic.VBCodeProvider();
break;
default:
throw new Exception("���Ή��̃t�@�C���g���q�ł�: " + filePath);
}
myPluginDllPath = mySetting.TemplateDir + Path.GetFileNameWithoutExtension(filePath) + ".dll";
string code = Util.LoadFile(filePath);
CompilerParameters cp = new CompilerParameters();
cp.GenerateExecutable = true;
cp.OutputAssembly = myPluginDllPath;
CompilerResults cr = myCompiler.CompileAssemblyFromSource(cp, code);
foreach(string s in cr.Output){
Console.WriteLine(s);
}
myCompiler.Dispose();
}
public void GeneratesVBCodeWithoutLocalizer(string file, string fileNamespace, string resourceNamespace, MemberAttributes accessModifiers, Type customToolType)
#endif
{
var provider = new Microsoft.VisualBasic.VBCodeProvider( );
var builder = GenerateBuilder(provider,
file,
fileNamespace,
resourceNamespace,
accessModifiers,
customToolType);
builder.Settings.ConfigureWithoutLocalizer(resourceNamespace + '.' + builder.Settings.ClassName);
#if NET461
var compiler = new VBCodeProvider(new XunitCompilerSettings(Language.VisualBasic));
var parameters = GenerateCompilerParameters("System.dll",
"System.Drawing.dll",
"System.Web.dll");
var compilation = GenerateCodeThenCompile(builder,
provider,
compiler,
parameters);
Assert.Empty(compilation.Errors);
#else
Assert.NotEmpty(GenerateCode(builder, provider));
#endif
}
public void GeneratesVBCodeForXamarinForms(string file, string fileNamespace, string resourceNamespace, MemberAttributes accessModifiers, Type customToolType)
#endif
{
var provider = new Microsoft.VisualBasic.VBCodeProvider( );
var builder = GenerateBuilder(provider,
file,
fileNamespace,
resourceNamespace,
accessModifiers,
customToolType);
builder.Settings.ConfigureResourceManager(resourceNamespace + '.' + Path.GetFileNameWithoutExtension(file));
builder.Settings.Extension = ResourceTypeExtension.XamarinForms;
#if NET461
var compiler = new VBCodeProvider(new XunitCompilerSettings(Language.VisualBasic));
var parameters = GenerateCompilerParameters("netstandard.dll",
"System.dll",
"System.Drawing.dll",
"System.Web.dll",
"Xamarin.Forms.Core.dll",
"Linguist.dll",
"Linguist.Xamarin.Forms.dll");
var compilation = GenerateCodeThenCompile(builder,
provider,
compiler,
parameters);
Assert.Empty(compilation.Errors);
#else
Assert.NotEmpty(GenerateCode(builder, provider));
#endif
}
public void GeneratesVBCodeForWPF(string file, string fileNamespace, string resourceNamespace, MemberAttributes accessModifiers, Type customToolType)
#endif
{
var provider = new Microsoft.VisualBasic.VBCodeProvider( );
var builder = GenerateBuilder(provider,
file,
fileNamespace,
resourceNamespace,
accessModifiers,
customToolType);
builder.Settings.ConfigureResourceManager(resourceNamespace + '.' + builder.Settings.ClassName);
builder.Settings.Extension = ResourceTypeExtension.WPF;
#if NET461
var compiler = new VBCodeProvider(new XunitCompilerSettings(Language.VisualBasic));
var parameters = GenerateCompilerParameters("System.dll",
"System.Drawing.dll",
"System.Web.dll",
"System.Xaml.dll",
PresentationCoreDll,
PresentationFrameworkDll,
WindowsBaseDll,
"Linguist.dll",
"Linguist.WPF.dll");
var compilation = GenerateCodeThenCompile(builder,
provider,
compiler,
parameters);
Assert.Empty(compilation.Errors);
#else
Assert.NotEmpty(GenerateCode(builder, provider));
#endif
}
/// <summary>
/// Writes the code to string in the specific language
/// and returns the string
/// </summary>
public static string Create(Language language, string expression, RegexOptions options)
{
CodeCompileUnit unit = Create(expression, options);
System.Text.StringBuilder builder = new System.Text.StringBuilder();
using (System.IO.StringWriter stringWriter = new System.IO.StringWriter(builder))
{
System.CodeDom.Compiler.ICodeGenerator generator;
switch (language)
{
case Language.CSharp:
System.CodeDom.Compiler.CodeGeneratorOptions genOptions = new System.CodeDom.Compiler.CodeGeneratorOptions();
genOptions.BracingStyle = "C";
generator = new Microsoft.CSharp.CSharpCodeProvider().CreateGenerator();
generator.GenerateCodeFromCompileUnit(unit, stringWriter, genOptions);
break;
case Language.VisualBasic:
generator = new Microsoft.VisualBasic.VBCodeProvider().CreateGenerator();
generator.GenerateCodeFromCompileUnit(unit, stringWriter, null);
break;
}
return(builder.ToString());
}
}
/// <summary>
/// Creates a function to be evaluated.
/// </summary>
/// <param name="_input"></param>
/// <returns></returns>
public static FunctionBaseCore CreateFunction(string _input)
{
Microsoft.VisualBasic.VBCodeProvider codecompiler = new Microsoft.VisualBasic.VBCodeProvider();
CodeCompileUnit ccu = new System.CodeDom.CodeCompileUnit();
CodeNamespace dom_namespace = pGetNameSpace();
CodeTypeDeclaration dom_class = pGetClass();
CodeMemberMethod dom_func = pGetFunc(_input);
dom_class.Members.Add(dom_func);
dom_namespace.Types.Add(dom_class);
ccu.Namespaces.Add(dom_namespace);
CompilerParameters paras = pGetPara();
CompilerResults output = codecompiler.CompileAssemblyFromDom(paras, ccu);
foreach (CompilerError CE in output.Errors)
{
}
//pGetCompileCode(codecompiler, ccu);
Assembly codebase = output.CompiledAssembly;
object classbase = codebase.CreateInstance("DOMSpace.DOMClass");
Type func_class = codebase.GetModules()[0].GetType("DOMSpace.DOMClass");
Type[] temp = codebase.GetModules()[0].GetTypes();
MethodInfo invoker = func_class.GetMethod("DOMfunc");
pGetCompileCode(codecompiler, ccu);
return new FunctionBaseCore(classbase, invoker);
}
public TomoFormula CreateFromString(string source)
{
TomoFormula retVal = null;
bool isCsharpCode = IsCsharpCode(source);
if (isCsharpCode)
{ // Expected Language: C#
Microsoft.CSharp.CSharpCodeProvider csProviderOnEarlyNodeCode = null;
CompileCS(source, out csProviderOnEarlyNodeCode);
if (csProviderOnEarlyNodeCode == null)
{
return(null);
}
if (results == null)
{
return(null);
}
System.Reflection.Assembly mCAssembly = null;
mCAssembly = results.CompiledAssembly;
retVal = (TomoFormula)mCAssembly.CreateInstance("CSTomoFormula");
}
else
{ // Exprected Language VB
Microsoft.VisualBasic.VBCodeProvider vbProviderOnEarlyNodeCode = null;
CompileVB(source, out vbProviderOnEarlyNodeCode);
if (vbProviderOnEarlyNodeCode == null)
{
return(null);
}
System.Reflection.Assembly mCAssembly = null;
mCAssembly = results.CompiledAssembly;
retVal = (TomoFormula)mCAssembly.CreateInstance("VBTomoFormula");
}
return(retVal);
}
static void CompileCode(CodeCompileUnit ccu, string sourceName)
{
CodeDomProvider provider = null;
FileInfo sourceFile = new FileInfo(sourceName);
// Select the code provider based on the input file extension, either C# or Visual Basic.
if (sourceFile.Extension.ToUpper(CultureInfo.InvariantCulture) == ".CS")
{
provider = new Microsoft.CSharp.CSharpCodeProvider();
}
else if (sourceFile.Extension.ToUpper(CultureInfo.InvariantCulture) == ".VB")
{
provider = new Microsoft.VisualBasic.VBCodeProvider();
}
else
{
Console.WriteLine("Source file must have a .cs or .vb extension");
}
if (provider != null)
{
CodeGeneratorOptions options = new CodeGeneratorOptions();
// Set code formatting options to your preference.
options.BlankLinesBetweenMembers = true;
options.BracingStyle = "C";
StreamWriter sw = new StreamWriter(sourceName);
provider.GenerateCodeFromCompileUnit(ccu, sw, options);
sw.Close();
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("var {0} = ", provider.CreateEscapedIdentifier(VariableName));
provider.GenerateCodeFromExpression(InitExpression, tw, opts);
tw.Write(";");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Dim {0} = ", provider.CreateEscapedIdentifier(VariableName));
provider.GenerateCodeFromExpression(InitExpression, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
protected override void RefreshValue()
{
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("SyncLock ");
if (LockExpression != null)
{
provider.GenerateCodeFromExpression(LockExpression, tw, opts);
}
tw.WriteLine();
tw.Indent++;
if (Statements != null)
{
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
}
tw.Indent--;
tw.Write("End SyncLock");
Value = tw.InnerWriter.ToString();
}
}
}
private void GenerateVB()
{
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringWriter sw = new StringWriter();
if (_method.Statements.Count > 0)
{
_method.Attributes = MemberAttributes.Private;
provider.GenerateCodeFromMember(_method, sw, opts);
Text = sw.GetStringBuilder().ToString();
}
else
{
provider.GenerateCodeFromMember(_method, sw, opts);
StringReader sr = new StringReader(sw.GetStringBuilder().ToString());
string line = sr.ReadLine();
while (string.IsNullOrEmpty(line))
{
line = sr.ReadLine();
}
int idx = line.IndexOf(" " + _method.Name + "(");
idx = line.LastIndexOf(' ', idx - 1);
Text = "Partial Private" + line.Remove(0, idx);
Text = sw.GetStringBuilder().Replace(line, Text).ToString();
}
}
}
private void GenerateVB()
{
IMemberOperatorGenerator gen = null;
switch (Operator)
{
case OperatorType.Explicit:
gen = new ExplicitOperatorGeneratorVB();
break;
case OperatorType.Implicit:
gen = new ImplicitOperatorGeneratorVB();
break;
default:
throw new NotImplementedException(string.Format("Какая-то несанкционированная xуйня"));
}
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new IndentedTextWriter(new StringWriter(), opts.IndentString))
{
gen.GenerateDeclaration(tw, provider, opts, ReturnType, Parameters);
tw.Indent++;
gen.GenerateStatemets(tw, provider, opts, Statements);
tw.Indent--;
tw.WriteLine("End Operator");
Text = tw.InnerWriter.ToString();
}
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("var {0} = ", provider.CreateEscapedIdentifier(VariableName));
provider.GenerateCodeFromExpression(InitExpression, tw, opts);
tw.Write(";");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Dim {0} = ", provider.CreateEscapedIdentifier(VariableName));
provider.GenerateCodeFromExpression(InitExpression, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
private static Assembly CompileWithReferences(string sourcecode,CompileLanguage language, string[] references)
{
CodeDomProvider comp =null;
switch (language ){
case CompileLanguage.VisualBasic:
comp = new Microsoft.VisualBasic.VBCodeProvider();
break;
case CompileLanguage.CSharp:
default:
comp = new CSharpCodeProvider();
break;
}
CompilerParameters cp = new CompilerParameters();
foreach (string reference in references)
{
cp.ReferencedAssemblies.Add(reference);
}
cp.GenerateInMemory = true;
CompilerResults cr = comp.CompileAssemblyFromSource(cp, sourcecode);
if (cr.Errors.HasErrors)
{
string error = string.Empty;
foreach (CompilerError err in cr.Errors)
{
error += err.ErrorText + System.Environment.NewLine;
}
System.Diagnostics.Trace.WriteLine(error);
return null;
}
return cr.CompiledAssembly;
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("break;");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Exit Do");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
/// <summary>
/// Writes the code to string in the specific language
/// and returns the string
/// </summary>
public static string Create(Language language, string expression, RegexOptions options)
{
CodeCompileUnit unit = Create(expression, options);
System.Text.StringBuilder builder = new System.Text.StringBuilder();
using (System.IO.StringWriter stringWriter = new System.IO.StringWriter(builder))
{
System.CodeDom.Compiler.ICodeGenerator generator;
switch (language)
{
case Language.CSharp:
System.CodeDom.Compiler.CodeGeneratorOptions genOptions = new System.CodeDom.Compiler.CodeGeneratorOptions();
genOptions.BracingStyle = "C";
generator = new Microsoft.CSharp.CSharpCodeProvider().CreateGenerator();
generator.GenerateCodeFromCompileUnit(unit, stringWriter, genOptions);
break;
case Language.VisualBasic:
generator = new Microsoft.VisualBasic.VBCodeProvider().CreateGenerator();
generator.GenerateCodeFromCompileUnit(unit, stringWriter, null);
break;
}
return builder.ToString();
}
}
/// <summary>
/// 编译指定脚本源码,返回编译结果
/// </summary>
/// <param name="source">源码</param>
/// <param name="language">语言</param>
/// <param name="outputFile">输出程序集文件</param>
/// <returns>ScriptAgent的编译结果对象(永不为null)</returns>
public CompileResults CompileScript(string source, ScriptLanguage language, string outputFile)
{
CodeDomProvider provider = null;
switch (language)
{
case ScriptLanguage.VBNET:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
case ScriptLanguage.CSharp:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
CompilerParameters param = this.GetCompilerParameters(outputFile);
if (param == null)
{
return(new CompileResults());
}
string szAssemblyDescriptor = this.GetScriptAssemblyDescriptor(language);
CompilerResults results = null;
try
{
source = this.FormatScript(source, language);
results = provider.CompileAssemblyFromSource(param, szAssemblyDescriptor, source);
}
catch (Exception ex)
{
LogManager.Instance.WriteLog("ScriptCompiler.CompileScript", ex);
}
return(this.GetCompileResults(results));
}
private static CodeDomProvider GetCodeDomProvider(string fileExtension)
{
CodeDomProvider cdp;
switch (fileExtension)
{
case ".fsx":
cdp = CodeDomProvider.CreateProvider("f#");
break;
case ".csx":
cdp = new Microsoft.CSharp.CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v3.5" } });
break;
case ".vbx":
cdp = new Microsoft.VisualBasic.VBCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v3.5" } });
break;
case ".jsx":
// Have to figure out better JS support
cdp = CodeDomProvider.CreateProvider("js");
break;
default:
if (CodeDomProvider.IsDefinedExtension(fileExtension))
{
cdp = CodeDomProvider.CreateProvider(CodeDomProvider.GetLanguageFromExtension(fileExtension));
}
else
{
throw new ScriptDoesNotCompileException("Unknown extension.");
}
break;
}
return cdp;
}
/// <summary>
/// Compile a script, using the source and reference assemblies specified. The return value will have the executable object
/// and any errors encountered.
/// </summary>
/// <param name="Source">The source to compile as a string.</param>
/// <param name="Reference">array of strings, each representing an assebmly or namespace to include.</param>
/// <param name="Language">The Languages enumeration value for the code language.</param>
/// <param name="DebugInformation">Whether to include debug information in the compiled object.</param>
/// <returns></returns>
public static CompilerResults CompileScript(string Source, string[] Reference, Languages Language, bool DebugInformation)
{
CodeDomProvider provider = null;
CompilerResults results;
switch (Language)
{
case Languages.VBnet:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
case Languages.CSharp:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
// Configure parameters
CompilerParameters parms = new CompilerParameters();
parms.GenerateExecutable = false;
parms.GenerateInMemory = true;
parms.IncludeDebugInformation = DebugInformation;
if (Reference != null)
{
foreach (string r in Reference)
{
parms.ReferencedAssemblies.Add(r);
}
}
// Compile
results = provider.CompileAssemblyFromSource(parms, Source);
return(results);
}
private void GenerateVB()
{
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringWriter sw = new StringWriter();
provider.GenerateCodeFromMember(_property, sw, opts);
StringReader sr = new StringReader(sw.GetStringBuilder().ToString());
string line = sr.ReadLine();
while (string.IsNullOrEmpty(line))
{
line = sr.ReadLine();
}
int idx = line.IndexOf(" " + _property.Name + "(");
int asIdx = line.LastIndexOf(" As ");
StringBuilder sb = new StringBuilder();
sb.Append((IsDefault?"Default ":string.Empty) + line.Substring(0, idx + _property.Name.Length + 2));
foreach (CodeParameterDeclarationExpression parameter in Parameters)
{
provider.GenerateCodeFromExpression(parameter, new StringWriter(sb), opts);
sb.Append(", ");
}
sb.Length -= 2;
sb.Append(")").Append(line.Substring(asIdx));
Text = sw.GetStringBuilder().Replace(line, sb.ToString()).ToString();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeProvider" />
/// for the specified <see cref="CodeLanguage" />.
/// </summary>
/// <param name="assemblyInfoTask">The <see cref="AssemblyInfoTask" /> for which an instance of the <see cref="CodeProvider" /> class should be initialized.</param>
/// <param name="codeLanguage">The <see cref="CodeLanguage" /> for which an instance of the <see cref="CodeProvider" /> class should be initialized.</param>
public CodeProvider(AssemblyInfoTask assemblyInfoTask, CodeLanguage codeLanguage)
{
CodeDomProvider provider = null;
switch (codeLanguage)
{
case CodeLanguage.CSharp:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case CodeLanguage.JScript:
throw new NotSupportedException(ResourceUtils.GetString("NA2008"));
case CodeLanguage.VB:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
default:
throw new NotSupportedException(ResourceUtils.GetString("NA2007"));
}
_generator = provider.CreateGenerator();
_language = codeLanguage;
_assemblyInfoTask = assemblyInfoTask;
}
/// <summary>
/// This method compiles the source given to it dynamically for use in plugins, etc...
///
/// --== History of Changes ==--
/// 11/05/2006 - Mike : Removed the compiler variable and called the provider method
/// CompilerAssemblyFromFile directly. I did this to remove a warning.
/// </summary>
/// <param name="strFile">The file we wish to compile</param>
/// <param name="strReferenceAssembliesToAdd">Assemblies that need to be included in the compile</param>
/// <returns>The results of the compile</returns>
public System.CodeDom.Compiler.CompilerResults CompileSourceCode(string strFile, string[] strReferenceAssembliesToAdd) // [DC]
{
//Currently only csharp scripting is supported
CodeDomProvider provider;
string extension = Path.GetExtension(strFile);
switch (extension)
{
case ".tmp": // default tmp files to .cs
case ".cs":
case ".ncs":
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case ".vb":
case ".nvb":
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
case ".njs":
case ".js":
provider = (CodeDomProvider)Activator.CreateInstance("Microsoft.JScript", "Microsoft.JScript.JScriptCodeProvider").Unwrap();
break;
default:
throw new UnsupportedLanguageExecption(extension);
}
System.CodeDom.Compiler.CompilerParameters compilerparams = new System.CodeDom.Compiler.CompilerParameters();
compilerparams.GenerateInMemory = true;
compilerparams.GenerateExecutable = true;
// manually add references (since he nfr bellow system will need to be implemented a diferent way)
compilerparams.ReferencedAssemblies.Add("System.dll");
compilerparams.ReferencedAssemblies.Add("System.Windows.Forms.Dll");
foreach (string strReferenceAssemblyToAdd in strReferenceAssembliesToAdd)
{
compilerparams.ReferencedAssemblies.Add(strReferenceAssemblyToAdd);
}
// we don't use this (since the extra references are retrieved from the Xml file
/*
* //Add assembly references from nscript.nrf or <file>.nrf
* string nrfFile = Path.ChangeExtension(strFile, "nrf");
*
* if (File.Exists(nrfFile))
* AddReferencesFromFile(compilerparams, nrfFile);
* else
* {
* //Use nscript.nrf
* nrfFile = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "nscript.nrf");
*
* if (File.Exists(nrfFile))
* AddReferencesFromFile(compilerparams, nrfFile);
* }
* */
System.CodeDom.Compiler.CompilerResults crResults = provider.CompileAssemblyFromFile(compilerparams, strFile);
return(crResults);
}
/// <summary>
/// Generates an Assembly from a script filename
/// </summary>
/// <param name="filename">The filename of the script</param>
/// <param name="references">Assembly references for the script</param>
/// <returns>The generated assembly</returns>
public Assembly CreateAssembly(string filename, IList references)
{
// ensure that compilerErrors is null
compilerErrors = null;
string extension = Path.GetExtension(filename);
// Select the correct CodeDomProvider based on script file extension
CodeDomProvider codeProvider;
switch (extension)
{
case ".cs":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case ".vb":
codeProvider = new Microsoft.VisualBasic.VBCodeProvider();
break;
case ".js":
codeProvider = new Microsoft.JScript.JScriptCodeProvider();
break;
default:
throw new InvalidOperationException("Script files must have a .cs, .vb, or .js extension, for C#, Visual Basic.NET, or JScript respectively.");
}
//ICodeCompiler compiler = codeProvider.CreateCompiler();
// Set compiler parameters
var compilerParams = new CompilerParameters {
CompilerOptions = "/target:library /optimize", GenerateExecutable = false, GenerateInMemory = true, IncludeDebugInformation = false
};
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
// Add custom references
foreach (string reference in references.Cast <string>().Where(reference => !compilerParams.ReferencedAssemblies.Contains(reference)))
{
compilerParams.ReferencedAssemblies.Add(reference);
}
// Do the compilation
CompilerResults results = codeProvider.CompileAssemblyFromFile(compilerParams, filename);
//Do we have any compiler errors
if (results.Errors.Count > 0)
{
compilerErrors = results.Errors;
throw new Exception(
"Compiler error(s) encountered and saved to AssemblyFactory.CompilerErrors");
}
Assembly createdAssembly = results.CompiledAssembly;
return(createdAssembly);
}
private bool LoadScript(string filename)
{
var compilerOptions = new System.CodeDom.Compiler.CompilerParameters();
compilerOptions.CompilerOptions = "/optimize";
compilerOptions.GenerateInMemory = true;
compilerOptions.IncludeDebugInformation = true;
compilerOptions.ReferencedAssemblies.Add("System.dll");
compilerOptions.ReferencedAssemblies.Add("System.Core.dll");
compilerOptions.ReferencedAssemblies.Add("System.Drawing.dll");
compilerOptions.ReferencedAssemblies.Add("System.Windows.Forms.dll");
compilerOptions.ReferencedAssemblies.Add("System.XML.dll");
compilerOptions.ReferencedAssemblies.Add("System.XML.Linq.dll");
compilerOptions.ReferencedAssemblies.Add(typeof(Script).Assembly.Location);
string extension = Path.GetExtension(filename);
System.CodeDom.Compiler.CodeDomProvider compiler = null;
if (extension.Equals(".cs", StringComparison.OrdinalIgnoreCase))
{
compiler = new Microsoft.CSharp.CSharpCodeProvider();
compilerOptions.CompilerOptions += " /unsafe";
}
else if (extension.Equals(".vb", StringComparison.OrdinalIgnoreCase))
{
compiler = new Microsoft.VisualBasic.VBCodeProvider();
}
else
{
return(false);
}
System.CodeDom.Compiler.CompilerResults compilerResult = compiler.CompileAssemblyFromFile(compilerOptions, filename);
if (!compilerResult.Errors.HasErrors)
{
Log("[INFO]", "Successfully compiled '", Path.GetFileName(filename), "'.");
return(LoadAssembly(filename, compilerResult.CompiledAssembly));
}
else
{
var errors = new System.Text.StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError error in compilerResult.Errors)
{
errors.Append(" at line ");
errors.Append(error.Line);
errors.Append(": ");
errors.Append(error.ErrorText);
errors.AppendLine();
}
Log("[ERROR]", "Failed to compile '", Path.GetFileName(filename), "' with ", compilerResult.Errors.Count.ToString(), " error(s):", Environment.NewLine, errors.ToString());
return(false);
}
}
/// <summary>
/// Compiles and load scripts from a C# or VB.NET source code file.
/// </summary>
/// <param name="filename">The path to the code file to load.</param>
/// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
bool LoadScriptsFromSource(string filename)
{
var compilerOptions = new System.CodeDom.Compiler.CompilerParameters();
compilerOptions.CompilerOptions = "/optimize";
compilerOptions.GenerateInMemory = true;
compilerOptions.IncludeDebugInformation = true;
compilerOptions.ReferencedAssemblies.Add("System.dll");
compilerOptions.ReferencedAssemblies.Add("System.Core.dll");
compilerOptions.ReferencedAssemblies.Add("System.Drawing.dll");
compilerOptions.ReferencedAssemblies.Add("System.Windows.Forms.dll");
compilerOptions.ReferencedAssemblies.Add("System.XML.dll");
compilerOptions.ReferencedAssemblies.Add("System.XML.Linq.dll");
// Reference the oldest scripting API to stay compatible with existing scripts
compilerOptions.ReferencedAssemblies.Add(scriptApis.First().Location);
compilerOptions.ReferencedAssemblies.Add(typeof(ScriptDomain).Assembly.Location);
string extension = Path.GetExtension(filename);
System.CodeDom.Compiler.CodeDomProvider compiler = null;
if (extension.Equals(".cs", StringComparison.OrdinalIgnoreCase))
{
compiler = new Microsoft.CSharp.CSharpCodeProvider();
compilerOptions.CompilerOptions += " /unsafe";
}
else if (extension.Equals(".vb", StringComparison.OrdinalIgnoreCase))
{
compiler = new Microsoft.VisualBasic.VBCodeProvider();
}
else
{
return(false);
}
System.CodeDom.Compiler.CompilerResults compilerResult = compiler.CompileAssemblyFromFile(compilerOptions, filename);
if (!compilerResult.Errors.HasErrors)
{
Log.Message(Log.Level.Debug, "Successfully compiled ", Path.GetFileName(filename), ".");
return(LoadScriptsFromAssembly(compilerResult.CompiledAssembly, filename));
}
else
{
var errors = new System.Text.StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError error in compilerResult.Errors)
{
errors.Append(" at line ");
errors.Append(error.Line);
errors.Append(": ");
errors.Append(error.ErrorText);
errors.AppendLine();
}
Log.Message(Log.Level.Error, "Failed to compile ", Path.GetFileName(filename), " with ", compilerResult.Errors.Count.ToString(), " error(s):", Environment.NewLine, errors.ToString());
return(false);
}
}
//Compiler du code VB.net
public static bool BuildVB(string Code, string OutputPath, string References = "none")
{
Debug.Logs.Write("[Plugin.Builder] Compilling with Visual Basic compilator.", Debug.LogType.Info);
Microsoft.VisualBasic.VBCodeProvider Provider = new Microsoft.VisualBasic.VBCodeProvider();
return(BuildCode(Code, OutputPath, Provider, References));
}
static void CompileScripts( Dictionary<string, Script> scripts, Dictionary<string, CommandDelegate> commands, ClassicBot main )
{
foreach( var keypair in scripts ) {
Script script = keypair.Value;
if( String.IsNullOrEmpty( script.Code ) ) continue;
CodeDomProvider compiler;
if( script.IsCSharp ) {
compiler = new Microsoft.CSharp.CSharpCodeProvider( new Dictionary<string, string>{ { "CompilerVersion", "v2.0" } } );
} else {
compiler = new Microsoft.VisualBasic.VBCodeProvider( new Dictionary<string, string>{ { "CompilerVersion", "v2.0" } } );
}
CompilerParameters cParams = new CompilerParameters {
GenerateExecutable = false,
GenerateInMemory = true,
//CompilerOptions = "/unsafe", Causes errors with the Visual Basic Compiler.
TreatWarningsAsErrors = false,
WarningLevel = 4,
};
if( script.KnownReferences == null || script.KnownReferences.Length == 0 ) { // Add defalt references.
cParams.ReferencedAssemblies.Add( "System.dll" );
cParams.ReferencedAssemblies.Add( "LibClassicBot.dll" );
} else {
cParams.ReferencedAssemblies.AddRange( script.KnownReferences );
}
CompilerResults results = compiler.CompileAssemblyFromSource( cParams, script.Code );
if( results.Errors.Count != 0 ) {
try {
foreach( CompilerError error in results.Errors ) {
string errorMsg = String.Format( "{0} Line: {1} {2}", error.ErrorNumber, error.Line, error.ErrorText );
if( error.IsWarning ) {
main.Log( LogType.Error, "Warning while compiling script " + keypair.Key, errorMsg );
} else {
main.Log( LogType.Error, "Error while compiling script " + keypair.Key, errorMsg );
}
}
} catch( Exception e ) {
main.Log( LogType.Error, "Error while trying to display errors. " , e.ToString() );
}
continue;
}
compiler.Dispose();
Type[] types = results.CompiledAssembly.GetTypes();
for( int i = 0; i < types.Length; i++ ) {
Type type = types[i];
if( type.IsSubclassOf( typeof( Plugin ) ) ) {
Plugin plugin = (Plugin)Activator.CreateInstance( type );
plugin.Initialize( main );
if( !commands.ContainsKey( plugin.CommandName ) ) {
main.Log( LogType.BotActivity, "Loaded command " + plugin.CommandName );
commands.Add( plugin.CommandName, plugin.Command );
}
}
}
}
}
public void MakeModule()
{
try
{
CompilerParameters cp = new CompilerParameters();
cp.GenerateExecutable = false;
cp.IncludeDebugInformation = false;
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
cp.ReferencedAssemblies.Add(asm.Location);
}
string code = codestart + Regex.Replace(txtCode.Text, "VbCrLf", "\"/r/n\"", RegexOptions.IgnoreCase) + "\r\n" + codeend;
CompilerResults results;
if (cmboLang.SelectedIndex == 0)
{
Microsoft.CSharp.CSharpCodeProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
results = codeProvider.CompileAssemblyFromSource(cp, code);
}
else
{
Microsoft.VisualBasic.VBCodeProvider codeProvider = new Microsoft.VisualBasic.VBCodeProvider();
results = codeProvider.CompileAssemblyFromSource(cp, code);
}
if (results.Errors.Count > 0)
{
StringBuilder builder = new StringBuilder("Compilation failed:");
foreach (CompilerError err in results.Errors)
{
builder.AppendLine(String.Format("Error: {0}\r\nLine: {1}\r\nNumber: {2}\r\n", err.ErrorText, err.Line, err.ErrorNumber));
}
MessageBox.Show(this, builder.ToString(), "Compilation errors");
Module = null;
return;
}
Type[] types = results.CompiledAssembly.GetTypes();
foreach (Type t in types)
{
Type g = t.GetInterface("IModule");
if (g != null)
{
Module = (IModule)Activator.CreateInstance(t);
}
}
}
catch (Exception ex)
{
Module = null;
ErrorHandler.Handle(ex);
}
}
public string GenEntitiesEx(Assembly ass, int outLang)
{
CodeCompileUnit unit = new CodeCompileUnit();
CodeNamespace ns;
//ns = new CodeNamespace(GetOutputNamespace(type));
//unit.Namespaces.Add(ns);
int i = 0;
foreach (Type type in ass.GetTypes())
{
if (typeof(IEntity).IsAssignableFrom(type) && typeof(IEntity) != type && advOpt.IsEntityEnabled(type.Name))
{
ns = new CodeNamespace(outNs);
unit.Namespaces.Add(ns);
ns.Imports.Add(new CodeNamespaceImport("System"));
//ns.Imports.Add(new CodeNamespaceImport("MySoft.Data"));
//ns.Imports.Add(new CodeNamespaceImport("MySoft.Data.Design"));
//sb.Append("namespace " + GetOutputNamespace(type) + "\r\n{\r\n");
GenEntityEx(ns, type, outLang);
//sb.Append("}\r\n\r\n");
++i;
}
}
CodeDomProvider provider = null;
switch (outLang)
{
case 0: provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case 1: provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
//case 2: provider = new Microsoft.VisualC.CppCodeProvider();
// break;
//case 3: provider = new Microsoft.VisualC.CppCodeProvider7();
// break;
//case 4: provider = new Microsoft.JScript.JScriptCodeProvider();
// break;
default: provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
StringBuilder codeBuilder = new StringBuilder();
StringWriter stringWriter = new StringWriter(codeBuilder);
IndentedTextWriter indentedWriter = new IndentedTextWriter(stringWriter, " ");
indentedWriter.Indent = 2;
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = true;
options.IndentString = "\t";
provider.GenerateCodeFromCompileUnit(unit, indentedWriter, options);
return(codeBuilder.ToString());
}
public static object CompileCode(string _input)
{
Microsoft.VisualBasic.VBCodeProvider codecompiler = new Microsoft.VisualBasic.VBCodeProvider();
CodeCompileUnit ccu = new System.CodeDom.CodeCompileUnit();
CodeNamespace dom_namespace = pGetNameSpace();
CodeTypeDeclaration dom_class = pGetClass();
return null;
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("new ");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(TypeReference.ArrayElementType), tw, opts);
tw.Write("[");
for (int i = 0; i < Dimensions.Count; i++)
{
if (i > 0)
{
tw.Write(",");
}
provider.GenerateCodeFromExpression(Dimensions[i], tw, opts);
}
tw.Write("]");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("(");
for (int i = 0; i < Dimensions.Count; i++)
{
if (i > 0)
{
tw.Write(",");
}
tw.Write("(");
provider.GenerateCodeFromExpression(Dimensions[i], tw, opts);
tw.Write(")-1");
}
tw.Write(") as ");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(TypeReference), tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
private void OutputGeneratedCode(CodeCompileUnit compileUnit)
{
CodeDomProvider generator = null;
switch (options.Language)
{
case SupportedLanguage.CS:
generator = new Microsoft.CSharp.CSharpCodeProvider();
break;
case SupportedLanguage.VB:
generator = new Microsoft.VisualBasic.VBCodeProvider();
break;
case SupportedLanguage.PY:
generator = new PythonProvider();
break;
default:
Console.WriteLine("Unknown language detected. Falling back to default C#");
generator = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
var genOptions = new CodeGeneratorOptions()
{
BlankLinesBetweenMembers = true,
VerbatimOrder = false,
ElseOnClosing = false,
BracingStyle = "C",
IndentString = " "
};
if (options.UseFolders)
{
foreach (var file in MetaFacade.SplitCompileUnit(compileUnit))
{
var fileInfo = new FileInfo(Path.Combine(options.OutputFile, file.Key) + "." + generator.FileExtension);
CheckDirectoryExists(fileInfo.Directory);
using (var sw = new StreamWriter(fileInfo.Create()))
{
generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions);
}
}
}
else
{
using (var sw = new StreamWriter(options.OutputFile))
{
generator.GenerateCodeFromCompileUnit(compileUnit, sw, genOptions);
}
}
}
/// <include file='doc\DesignerService.uex' path='docs/doc[@for="DesignerService.IVSMDCodeDomCreator.CreateCodeDomProvider"]/*' />
/// <devdoc>
/// Creates a code dom provider around the given hierarchy and itemid.
/// </devdoc>
IVSMDCodeDomProvider IVSMDCodeDomCreator.CreateCodeDomProvider(object pHier, int itemid)
{
// Extract the project item
//
ProjectItem projectItem = null;
if (itemid != __VSITEMID.VSITEMID_NIL && pHier != null)
{
object o;
((IVsHierarchy)pHier).GetProperty(itemid, __VSHPROPID.VSHPROPID_ExtObject, out o);
projectItem = (ProjectItem)o;
if (projectItem == null)
{
throw new Exception(SR.GetString(SR.DESIGNERLOADERNoFileCodeModel));
}
}
// Extract the type GUID of the hierarchy.
//
Guid typeCSharp = new Guid("{FAE04EC0-301F-11d3-BF4B-00C04F79EFBC}");
Guid typeVB = new Guid("{F184B08F-C81C-45f6-A57F-5ABD9991F28F}");
Guid typeGuid;
if (NativeMethods.Failed(((IVsHierarchy)pHier).GetGuidProperty(__VSITEMID.VSITEMID_ROOT, __VSHPROPID.VSHPROPID_TypeGuid, out typeGuid)))
{
throw new NotSupportedException();
}
CodeDomProvider provider = null;
if (typeGuid.Equals(typeCSharp))
{
provider = new Microsoft.CSharp.CSharpCodeProvider();
}
else if (typeGuid.Equals(typeVB))
{
provider = new Microsoft.VisualBasic.VBCodeProvider();
}
else
{
provider = CreateProviderFromRegistry(typeGuid);
}
if (provider == null)
{
// Unsupported language
//
throw new NotSupportedException(SR.GetString(SR.DESIGNERLOADERNoLanguageSupport));
}
return(new VSMDCodeDomProvider(new VsCodeDomProvider(this, projectItem, provider)));
}
public CompilerResults ExeCuteCode(string Source, Client client)
{
CompilerResults Results = null;
try
{
if (CompiledScripts.ContainsKey(Source))
{
/* Thread t = new Thread(() => RunScript(CompiledScripts[Source]));
* t.Start();*/
RunScript(CompiledScripts[Source]);
}
else
{
CodeDomProvider P = default(CodeDomProvider);
P = new Microsoft.VisualBasic.VBCodeProvider();
CompilerParameters CP = new CompilerParameters();
CP.GenerateExecutable = false;
CP.GenerateInMemory = true;
CP.IncludeDebugInformation = false;
//CP.CompilerOptions = "/optimize"
CP.TreatWarningsAsErrors = false;
CP.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
CP.ReferencedAssemblies.Add("System.Windows.Forms.dll");
CP.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll");
CP.ReferencedAssemblies.Add("System.Xml.dll");
CP.ReferencedAssemblies.Add("System.Drawing.dll");
CP.ReferencedAssemblies.Add("System.dll");
// CP.ReferencedAssemblies.Add(System.Application.StartupPath + "\\\\TibiaAPI.dll");
Results = P.CompileAssemblyFromSource(CP, Source);
IScript script = (IScript)FindInterface(Results.CompiledAssembly, "IScript");
CompiledScripts.Add(Source, script);
/* Thread t = new Thread(() => RunScript(script));
* t.Start();
*/
RunScript(script);
// RunScript(script)
}
return(null);
}
catch (Exception ex)
{
return(Results);
}
}
/// <summary>
/// Generates an Assembly from a script filename
/// </summary>
/// <param name="filename">The filename of the script</param>
/// <param name="references">Assembly references for the script</param>
/// <returns>The generated assembly</returns>
public Assembly CreateAssembly(string filename, IList references)
{
// ensure that compilerErrors is null
compilerErrors = null;
string extension = Path.GetExtension(filename);
// Select the correct CodeDomProvider based on script file extension
CodeDomProvider codeProvider;
switch (extension)
{
case ".cs":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case ".vb":
codeProvider = new Microsoft.VisualBasic.VBCodeProvider();
break;
case ".js":
codeProvider = new Microsoft.JScript.JScriptCodeProvider();
break;
default:
throw new InvalidOperationException("Script files must have a .cs, .vb, or .js extension, for C#, Visual Basic.NET, or JScript respectively.");
}
//ICodeCompiler compiler = codeProvider.CreateCompiler();
// Set compiler parameters
var compilerParams = new CompilerParameters { CompilerOptions = "/target:library /optimize", GenerateExecutable = false, GenerateInMemory = true, IncludeDebugInformation = false };
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
// Add custom references
foreach (string reference in references.Cast<string>().Where(reference => !compilerParams.ReferencedAssemblies.Contains(reference)))
{
compilerParams.ReferencedAssemblies.Add(reference);
}
// Do the compilation
CompilerResults results = codeProvider.CompileAssemblyFromFile(compilerParams, filename);
//Do we have any compiler errors
if (results.Errors.Count > 0)
{
compilerErrors = results.Errors;
throw new Exception(
"Compiler error(s) encountered and saved to AssemblyFactory.CompilerErrors");
}
Assembly createdAssembly = results.CompiledAssembly;
return createdAssembly;
}
public static string ConvertCodeDomToPInvokeCodeImpl(LanguageType type, CodeTypeDeclarationCollection col, ErrorProvider ep)
{
ThrowIfNull(col);
ThrowIfNull(ep);
StringWriter writer = new StringWriter();
CodeDomProvider provider = default(CodeDomProvider);
string commentStart = null;
// Generate based on the language
switch (type)
{
case Transform.LanguageType.VisualBasic:
commentStart = "'";
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
case Transform.LanguageType.CSharp:
commentStart = "//";
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
default:
ThrowInvalidEnumValue(type);
return(string.Empty);
}
foreach (string warning in ep.Warnings)
{
writer.WriteLine("{0} Warning: {1}", commentStart, warning);
}
foreach (string err in ep.Errors)
{
writer.WriteLine("{0} Error: {1}", commentStart, err);
}
foreach (CodeTypeDeclaration ctd in col)
{
provider.GenerateCodeFromMember(ctd, writer, new CodeGeneratorOptions());
}
if (type == Transform.LanguageType.CSharp)
{
// CSharp specific fixup
return(FixupCSharpCode(writer.ToString()));
}
else
{
return(writer.ToString());
}
}
private void GenerateVB()
{
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringBuilder sb = new StringBuilder();
using (IndentedTextWriter tw = new IndentedTextWriter(new StringWriter(sb), opts.IndentString))
{
provider.GenerateCodeFromMember(Field, tw, opts);
sb.Replace(" " + Field.Name, " ReadOnly " + Field.Name);
}
Text = sb.ToString();
}
}
private void GenerateVB()
{
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringBuilder sb = new StringBuilder();
using (IndentedTextWriter tw = new IndentedTextWriter(new StringWriter(sb), opts.IndentString))
{
provider.GenerateCodeFromMember(Field, tw, opts);
sb.Replace(" " + Field.Name, " ReadOnly " + Field.Name);
}
Text = sb.ToString();
}
}
/// <summary>
/// Compiles the Visual Basic code in assembly.
/// </summary>
protected void CompileVB(string code, out Microsoft.VisualBasic.VBCodeProvider provider)
{
System.CodeDom.Compiler.CompilerParameters parameters = new System.CodeDom.Compiler.CompilerParameters();
parameters.GenerateInMemory = true; // 'Assembly is created in memory
parameters.TreatWarningsAsErrors = false;
parameters.WarningLevel = 4;
string[] refs = { "System.dll", System.Reflection.Assembly.GetExecutingAssembly().Location };
parameters.ReferencedAssemblies.AddRange(refs);
provider = new Microsoft.VisualBasic.VBCodeProvider();
string tomoSource = @"
Imports System
Imports Fractrace.TomoGeometry
Public Class VBTomoFormula
Inherits TomoFormula
" + code + @"
End Class
";
try
{
results = provider.CompileAssemblyFromSource(parameters, tomoSource);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
FormulaEditor.AddError(ex.ToString(), 0, 0);
return;
}
if (results.Errors.Count != 0)
{
foreach (System.CodeDom.Compiler.CompilerError cerror in results.Errors)
{
if (!cerror.IsWarning)
{
provider = null;
Console.WriteLine(cerror.ErrorText + "Line " + cerror.Line + " " + cerror.Column + " in \"" + tomoSource + "\"");
FormulaEditor.AddError(cerror.ErrorText + "Line " + cerror.Line + " " + cerror.Column + " in \"" + tomoSource + "\"", cerror.Line, cerror.Column);
return;
}
}
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("new ");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(TypeReference.ArrayElementType), tw, opts);
tw.Write("[");
for (int i = 0; i < Dimensions.Count; i++)
{
if (i > 0)
tw.Write(",");
provider.GenerateCodeFromExpression(Dimensions[i], tw, opts);
}
tw.Write("]");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("(");
for (int i = 0; i < Dimensions.Count; i++)
{
if (i > 0)
tw.Write(",");
tw.Write("(");
provider.GenerateCodeFromExpression(Dimensions[i], tw, opts);
tw.Write(")-1");
}
tw.Write(") as ");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(TypeReference), tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
internal string GenerateSource(string language)
{
CodeDomProvider codeProvider=null;
if (language == "cs")
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
else if (language == "vb")
codeProvider = new Microsoft.VisualBasic.VBCodeProvider();
else
{
throw new Exception("make sure you are trying to load a CodeDomProvider assembly");
}
return GenerateSource(codeProvider);
}
public static CompilerResults CompileScript(string Source, string Reference, Languages Language)
{
CodeDomProvider provider = null;
switch (Language)
{
case Languages.VB:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
case Languages.CSharp:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
return CompileScript(Source, Reference, provider);
}
/// <summary>
/// Compile a set of source files written in a specified language
/// </summary>
/// <param name="files">Array of source files</param>
/// <param name="referencedAssemblies">Array of refered assemblies</param>
/// <param name="outputFilePath">Output assembly file path</param>
/// <param name="language">Language of source files</param>
/// <returns>Compiler results</returns>
public static CompilerResults Compile(List<string> files, List<string> referencedAssemblies, List<string> embeddedResourcesFiles, string outputFilePath, Languages language)
{
CodeDomProvider provider = null;
switch (language)
{
case Languages.VB:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
case Languages.CSharp:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
return Compile(files, referencedAssemblies, embeddedResourcesFiles, outputFilePath, provider);
}
public static CompilerResults CompilacionDinamica(string Codigo, bool CodigoesRuta, bool CompilarEnMemoria, string ArchivoResultado, bool CompilarCS)
{
//Creamos una instancia de la clase VBCodeProvider o CSharpCodeProvider
//que usaremos para obtener una referencia a una interfaz ICodeCompiler
System.CodeDom.Compiler.CodeDomProvider proveedor;
if (CompilarCS == true)
{
proveedor = new CSharpCodeProvider();
}
else
{
proveedor = new Microsoft.VisualBasic.VBCodeProvider();
}
//Usamos la clase CompilerParameters para pasar parámetros al compilador
//En particular, definimos que el assembly sea compilado en memoria.
CompilerParameters ParametrosCompilacion = new CompilerParameters();
if (CompilarEnMemoria == true)
{
ParametrosCompilacion.GenerateInMemory = true;
ParametrosCompilacion.GenerateExecutable = false;
}
else
{
ParametrosCompilacion.GenerateExecutable = true;
ParametrosCompilacion.GenerateInMemory = false;
ParametrosCompilacion.OutputAssembly = ArchivoResultado;
}
ParametrosCompilacion.CompilerOptions = "/target:library";
ParametrosCompilacion.ReferencedAssemblies.Add("System.dll");
ParametrosCompilacion.ReferencedAssemblies.Add("System.Drawing.dll");
ParametrosCompilacion.ReferencedAssemblies.Add("System.Windows.Forms.dll");
//Creamos un objeto CompilerResult que obtendrá los resultados de la compilación
CompilerResults ResultadosCompilacion;
if (CodigoesRuta == true)
{
ResultadosCompilacion = proveedor.CompileAssemblyFromFile(ParametrosCompilacion, Codigo);
}
else
{
ResultadosCompilacion = proveedor.CompileAssemblyFromSource(ParametrosCompilacion, Codigo);
}
return ResultadosCompilacion;
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromExpression(Parameter, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
StringBuilder sb = new StringBuilder();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(sb), opts.IndentString))
{
provider.GenerateCodeFromExpression(Parameter, tw, opts);
switch (Option)
{
case ParamOption.Optional:
sb.Replace("ByVal " + Parameter.Name, "Optional ByVal " + Parameter.Name);
break;
case ParamOption.ParamArray:
sb.Replace("ByVal " + Parameter.Name, "ByVal ParamArray " + Parameter.Name);
break;
default:
throw new NotSupportedException(Option.ToString());
}
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("(");
provider.GenerateCodeFromExpression(Expression, tw, opts);
tw.Write(" is ");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(TypeReference), tw, opts);
tw.Write(")");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("( TypeOf ");
provider.GenerateCodeFromExpression(Expression, tw, opts);
tw.Write(" Is ");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(TypeReference), tw, opts);
tw.Write(")");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
private bool IsLanguageSupported(string language)
{
_language = language;
_isLangCSharp = string.Compare(language, CSHARP, StringComparison.OrdinalIgnoreCase) == 0;
if (IsLanguageCSharp)
{
_codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
return true;
}
else
{
_isLangVB = string.Compare(language, VB, StringComparison.OrdinalIgnoreCase) == 0;
if (IsLanguageVB)
{
_codeProvider = new Microsoft.VisualBasic.VBCodeProvider();
return true;
}
}
if (CodeDomProvider.IsDefinedLanguage(language))
{
CompilerInfo = CodeDomProvider.GetCompilerInfo(language);
return (CompilerInfo != null);
}
return false;
}
private void GenerateVB()
{
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringWriter sw = new StringWriter();
provider.GenerateCodeFromMember(_property, sw, opts);
StringReader sr = new StringReader(sw.GetStringBuilder().ToString());
string line = sr.ReadLine();
while (string.IsNullOrEmpty(line))
line = sr.ReadLine();
int idx = line.IndexOf(" " + _property.Name + "(");
int asIdx = line.LastIndexOf(" As ");
StringBuilder sb = new StringBuilder();
sb.Append((IsDefault?"Default ":string.Empty) + line.Substring(0, idx+_property.Name.Length+2));
foreach (CodeParameterDeclarationExpression parameter in Parameters)
{
provider.GenerateCodeFromExpression(parameter, new StringWriter(sb), opts);
sb.Append(", ");
}
sb.Length -= 2;
sb.Append(")").Append(line.Substring(asIdx));
Text = sw.GetStringBuilder().Replace(line, sb.ToString()).ToString();
}
}
///
/// <summary>
/// Fetch the Code Provider for the language specified by the 'language' members.
/// </summary>
///
private CodeDomProvider GetProvider()
{
CodeDomProvider provider;
Type type;
switch (language.ToUpper ()) {
case "CS":
provider = new CSharpCodeProvider ();
break;
case "VB":
provider = new Microsoft.VisualBasic.VBCodeProvider ();
break;
case "BOO":
type = Type.GetType("Boo.Lang.CodeDom.BooCodeProvider, Boo.Lang.CodeDom, Version=1.0.0.0, Culture=neutral, PublicKeyToken=32c39770e9a21a67");
if (type != null){
return (CodeDomProvider) Activator.CreateInstance (type);
}
throw new Exception ("Boo.Lang.CodeDom.BooCodeProvider not available");
default:
type = Type.GetType(language);
if (type != null) {
return (CodeDomProvider) Activator.CreateInstance (type);
}
throw new Exception ("Unknown language");
}
return provider;
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeProvider" />
/// for the specified <see cref="CodeLanguage" />.
/// </summary>
/// <param name="assemblyInfoTask">The <see cref="AssemblyInfoTask" /> for which an instance of the <see cref="CodeProvider" /> class should be initialized.</param>
/// <param name="codeLanguage">The <see cref="CodeLanguage" /> for which an instance of the <see cref="CodeProvider" /> class should be initialized.</param>
public CodeProvider(AssemblyInfoTask assemblyInfoTask, CodeLanguage codeLanguage) {
CodeDomProvider provider = null;
switch (codeLanguage) {
case CodeLanguage.CSharp:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case CodeLanguage.JScript:
throw new NotSupportedException(ResourceUtils.GetString("NA2008"));
case CodeLanguage.VB:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
default:
throw new NotSupportedException(ResourceUtils.GetString("NA2007"));
}
_generator = provider.CreateGenerator();
_language = codeLanguage;
}
/// <summary>
/// Generates a strongly typed assembly from the resources
///
/// UNDER CONSTRUCTION.
/// Doesn't work correctly for Web forms due to hard coded resource managers.
/// </summary>
/// <param name="ResourceSetName"></param>
/// <param name="Namespace"></param>
/// <param name="Classname"></param>
/// <param name="FileName"></param>
/// <returns></returns>
public bool CreateStronglyTypedResource(string ResourceSetName,string Namespace, string Classname, string FileName)
{
try
{
//wwDbResourceDataManager Data = new wwDbResourceDataManager();
//IDictionary ResourceSet = Data.GetResourceSet("", ResourceSetName);
// Use the custom ResourceManage to retrieve a ResourceSet
DbResourceManager Man = new DbResourceManager(ResourceSetName);
ResourceSet rs = Man.GetResourceSet(CultureInfo.InvariantCulture, false, false);
IDictionaryEnumerator Enumerator = rs.GetEnumerator();
// We have to turn into a concret Dictionary
Dictionary<string, object> Resources = new Dictionary<string, object>();
while (Enumerator.MoveNext())
{
DictionaryEntry Item = (DictionaryEntry) Enumerator.Current;
Resources.Add(Item.Key as string, Item.Value);
}
string[] UnmatchedElements;
CodeDomProvider CodeProvider = null;
string FileExtension = Path.GetExtension(FileName).TrimStart('.').ToLower();
if (FileExtension == "cs")
CodeProvider = new Microsoft.CSharp.CSharpCodeProvider();
else if(FileExtension == "vb")
CodeProvider = new Microsoft.VisualBasic.VBCodeProvider();
CodeCompileUnit Code = StronglyTypedResourceBuilder.Create(Resources,
ResourceSetName, Namespace, CodeProvider, false, out UnmatchedElements);
StreamWriter writer = new StreamWriter(FileName);
CodeProvider.GenerateCodeFromCompileUnit(Code, writer, new CodeGeneratorOptions());
writer.Close();
}
catch (Exception ex)
{
this.ErrorMessage = ex.Message;
return false;
}
return true;
}
public string CompileVB()
{
OnChangeCompilerState(this, CompilerState.CompilationStarting, CompilerOptions.SourceFileName);
OnChangeCompilerState(this,CompilerState.BeginCompileFile,CompilerOptions.SourceFileName);
Reset();
Microsoft.VisualBasic.VBCodeProvider vbcp = new Microsoft.VisualBasic.VBCodeProvider();
List<string> sources = new List<string>();
sources.Add(CompilerOptions.SourceFileName);
System.CodeDom.Compiler.CompilerParameters comp_opt = new System.CodeDom.Compiler.CompilerParameters();
comp_opt.OutputAssembly = CompilerOptions.OutputFileName;
comp_opt.WarningLevel = 3;
comp_opt.ReferencedAssemblies.Add("System.Windows.Forms.dll");
comp_opt.ReferencedAssemblies.Add("System.Drawing.dll");
comp_opt.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll");
comp_opt.IncludeDebugInformation = CompilerOptions.Debug;
comp_opt.GenerateExecutable = true;
string fname = Path.Combine(Path.GetDirectoryName(CompilerOptions.SourceFileName),"_temp$"+Path.GetFileName(CompilerOptions.SourceFileName));
File.Copy(CompilerOptions.SourceFileName,fname,true);
string source = GetSourceFileText(CompilerOptions.SourceFileName);
IParser parser = ICSharpCode.NRefactory.ParserFactory.CreateParser(ICSharpCode.NRefactory.SupportedLanguage.VBNet,new StringReader(source));
parser.Parse();
ProgInfo info = get_programm_info(parser.CompilationUnit, source);
parser.Dispose();
if (info != null)
sources.AddRange(info.addit_project_files);
string redirect_base_fname = FindSourceFileInDirectories("__RedirectIOMode.vb",Path.Combine(this.CompilerOptions.SystemDirectory,"Lib"),Path.Combine(this.CompilerOptions.SystemDirectory,"LibSource"));
string system_unit_name = FindSourceFileInDirectories("VBSystem.vb",Path.Combine(this.CompilerOptions.SystemDirectory,"lib"),Path.Combine(this.CompilerOptions.SystemDirectory,"LibSource"));
string redirect_fname = Path.Combine(Path.GetDirectoryName(CompilerOptions.SourceFileName),"_RedirectIOMode.vb");
StreamReader sr = File.OpenText(redirect_base_fname);
string redirect_module = sr.ReadToEnd();
sr.Close();
if (info != null)
{
System.Text.StringBuilder tmp_sb = new System.Text.StringBuilder();
if (info.modules.Count > 0)
{
tmp_sb.AppendLine("GetType(Fictive.Fictive).Assembly.GetType(\"PABCSystem_implementation$.PABCSystem_implementation$\").GetMethod(\"$Initialization\").Invoke(Nothing,Nothing)");
}
for (int i=0; i<info.modules.Count; i++)
{
tmp_sb.AppendLine("GetType(Fictive.Fictive).Assembly.GetType(\""+info.modules[i]+"_implementation$."+info.modules[i]+
"_implementation$\").GetMethod(\"$Initialization\").Invoke(Nothing,Nothing)");
}
tmp_sb.AppendLine(info.entry_module+"."+"___Main()");
for (int i=0; i<info.modules.Count; i++)
{
tmp_sb.AppendLine("GetType(Fictive.Fictive).Assembly.GetType(\""+info.modules[i]+"_implementation$."+info.modules[i]+
"_implementation$\").GetMethod(\"$Finalization\").Invoke(Nothing,Nothing)");
}
redirect_module = redirect_module.Replace("%MAIN%",tmp_sb.ToString());
}
StreamWriter sw = new StreamWriter(redirect_fname, false);
if (info != null)
{
sw.WriteLine(redirect_module);
}
else
{
sw.WriteLine("Module _RedirectIOMode");
sw.WriteLine("End Module");
}
sw.Close();
sw = new StreamWriter(CompilerOptions.SourceFileName,false);
if (info != null && info.entry_method_name_pos != -1)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
int start_pos = 0;
if (info.using_pos != -1)
{
start_pos = info.using_pos;
sb.Append(source.Substring(0,info.using_pos));
for (int i=0; i<info.addit_imports.Count; i++)
{
sb.Append(","+info.addit_imports[i]);
}
sb.Append(",System.Collections.Generic");
sb.Append(",Microsoft.VisualBasic.Strings");
sb.Append(",Microsoft.VisualBasic.Constants");
sb.Append(",Microsoft.VisualBasic.VBMath");
sb.Append(",Microsoft.VisualBasic.Information");
sb.Append(",Microsoft.VisualBasic.Interaction");
sb.Append(",Microsoft.VisualBasic.FileSystem");
sb.Append(",Microsoft.VisualBasic.Financial");
sb.Append(",Microsoft.VisualBasic.DateAndTime");
}
else
{
start_pos = 0;
sb.Append("Imports System");
sb.Append(",System.Collections.Generic");
sb.Append(",Microsoft.VisualBasic.Strings");
sb.Append(",Microsoft.VisualBasic.Constants");
sb.Append(",Microsoft.VisualBasic.VBMath");
sb.Append(",Microsoft.VisualBasic.Information");
sb.Append(",Microsoft.VisualBasic.Interaction");
sb.Append(",Microsoft.VisualBasic.FileSystem");
sb.Append(",Microsoft.VisualBasic.Financial");
sb.Append(",Microsoft.VisualBasic.DateAndTime");
sb.Append(":");
}
sb.Append(source.Substring(start_pos,info.entry_method_name_pos-start_pos));
sb.Append("___");
sb.Append(source.Substring(info.entry_method_name_pos));
sw.Write(sb.ToString());
}
else
{
sw.Write(source);
}
sw.Close();
if (info != null && info.modules.Count > 0)
{
comp_opt.ReferencedAssemblies.Add(Path.Combine(Path.GetDirectoryName(CompilerOptions.SourceFileName),PascalABCCompiler.TreeConverter.compiler_string_consts.pabc_rtl_dll_name));
string mod_file_name = FindSourceFileInDirectories("PABCRtl.dll",Path.Combine(this.CompilerOptions.SystemDirectory,"Lib"));
File.Copy(mod_file_name,Path.Combine(Path.GetDirectoryName(CompilerOptions.SourceFileName),"PABCRtl.dll"),true);
/*foreach (string mod in info.modules)
{
comp_opt.ReferencedAssemblies.Add(Path.Combine(Path.GetDirectoryName(CompilerOptions.SourceFileName),mod+".dll"));
string mod_file_name = FindSourceFileInDirectories(mod+".mod",Path.Combine(this.CompilerOptions.SystemDirectory,"lib"));
File.Copy(mod_file_name,Path.Combine(Path.GetDirectoryName(CompilerOptions.SourceFileName),mod+".dll"),true);
}*/
}
sources.Add(redirect_fname);
sources.Add(system_unit_name);
System.CodeDom.Compiler.CompilerResults res = vbcp.CompileAssemblyFromFile(comp_opt,sources.ToArray());
if (res.Errors.Count > 0)
{
for (int i=0; i<res.Errors.Count; i++)
{
if (!res.Errors[i].IsWarning && errorsList.Count == 0 /*&& res.Errors[i].FileName != redirect_fname*/)
{
if (File.Exists(res.Errors[i].FileName))
errorsList.Add(new Errors.CommonCompilerError(res.Errors[i].ErrorText, res.Errors[i].FileName,res.Errors[i].Line!=0?res.Errors[i].Line:1,1));
else
errorsList.Add(new Errors.CommonCompilerError(res.Errors[i].ErrorText, CompilerOptions.SourceFileName,res.Errors[i].Line!=0?res.Errors[i].Line:1,1));
}
else if (res.Errors[i].IsWarning)
{
warnings.Add(new Errors.CommonWarning(res.Errors[i].ErrorText, res.Errors[i].FileName, res.Errors[i].Line,1));
}
}
}
linesCompiled = get_compiled_lines(CompilerOptions.SourceFileName);
if (info != null)
{
beginOffset = info.entry_method_line;
//if (info.using_pos == -1)
// beginOffset -= 1;
}
OnChangeCompilerState(this, CompilerState.CompilationFinished, CompilerOptions.SourceFileName);
ClearAll();
File.Copy(fname,CompilerOptions.SourceFileName,true);
File.Delete(fname);
File.Delete(redirect_fname);
OnChangeCompilerState(this, CompilerState.Ready, null);
if (errorsList.Count > 0)
return null;
else
return res.PathToAssembly;
}
public void MakeModule()
{
try
{
CompilerParameters cp = new CompilerParameters();
cp.GenerateExecutable = false;
cp.IncludeDebugInformation = false;
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
cp.ReferencedAssemblies.Add(asm.Location);
}
string code = codestart + Regex.Replace(txtCode.Text, "VbCrLf", "\"/r/n\"", RegexOptions.IgnoreCase) + "\r\n" + codeend;
CodeDomProvider codeProvider;
if (cmboLang.SelectedIndex == 0)
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
else
codeProvider = new Microsoft.VisualBasic.VBCodeProvider();
CompilerResults results = codeProvider.CompileAssemblyFromSource(cp, code);
if (results.Errors.Count > 0)
{
StringBuilder builder = new StringBuilder("Compilation failed:\r\n");
foreach (CompilerError err in results.Errors)
{
builder.AppendLine(String.Format("Error: {0}\r\nLine: {1}\r\nNumber: {2}\r\n", err.ErrorText, err.Line, err.ErrorNumber));
}
MessageBox.Show(this, builder.ToString(), "Compilation errors");
Module = null;
return;
}
foreach (Type t in results.CompiledAssembly.GetTypes())
{
if (t.GetInterface("IModule") != null)
Module = (IModule)Activator.CreateInstance(t, Program.AWB);
}
}
catch (Exception ex)
{
Module = null;
ErrorHandler.Handle(ex);
}
}
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] //For Path.GetTempPath method.
//We use tha path to create a temp file stream which is consistent with the resource consumption of machine.
internal void GenerateCode(LazyTextWriterCreator target, string targetLocation)
{
Debug.Assert(target != null, "target parameter is null");
IndentedTextWriter indentedTextWriter = null;
System.IO.Stream tempFileStream = null;
System.IO.StreamReader reader = null;
System.IO.StreamWriter writer = null;
TempFileCollection tempFiles = null;
try
{
CodeDomProvider provider = null;
switch (Language)
{
case LanguageOption.GenerateCSharpCode:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case LanguageOption.GenerateVBCode:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
}
_isLanguageCaseSensitive = (provider.LanguageOptions & LanguageOptions.CaseInsensitive) == 0;
new NamespaceEmitter(this, _codeNamespace, target.TargetFilePath).Emit();
// if there were errors we don't need the output file
if (RealErrorsExist)
{
return;
}
if (FixUps.Count == 0 || !FixUpCollection.IsLanguageSupported(Language))
{
indentedTextWriter = new IndentedTextWriter(target.GetOrCreateTextWriter(), "\t");
}
else
{
// need to write to a temporary file so we can do fixups...
tempFiles = new TempFileCollection(Path.GetTempPath());
string filename = Path.Combine(tempFiles.TempDir, "EdmCodeGenFixup-" + Guid.NewGuid().ToString() + ".tmp");
tempFiles.AddFile(filename, false);
tempFileStream = new System.IO.FileStream(filename, System.IO.FileMode.CreateNew, System.IO.FileAccess.ReadWrite,
System.IO.FileShare.None);
indentedTextWriter = new IndentedTextWriter(new System.IO.StreamWriter(tempFileStream), "\t");
}
CodeGeneratorOptions styleOptions = new CodeGeneratorOptions();
styleOptions.BracingStyle = "C";
styleOptions.BlankLinesBetweenMembers = false;
styleOptions.VerbatimOrder = true;
provider.GenerateCodeFromCompileUnit(CompileUnit, indentedTextWriter, styleOptions);
// if we wrote to a temp file need to post process the file...
if (tempFileStream != null)
{
indentedTextWriter.Flush();
tempFileStream.Seek(0, System.IO.SeekOrigin.Begin);
reader = new System.IO.StreamReader(tempFileStream);
FixUps.Do(reader, target.GetOrCreateTextWriter(), Language, SourceObjectNamespaceName != string.Empty);
}
}
catch (System.UnauthorizedAccessException ex)
{
AddError(ModelBuilderErrorCode.SecurityError, EdmSchemaErrorSeverity.Error, ex);
}
catch (System.IO.FileNotFoundException ex)
{
AddError(ModelBuilderErrorCode.FileNotFound, EdmSchemaErrorSeverity.Error, ex);
}
catch (System.Security.SecurityException ex)
{
AddError(ModelBuilderErrorCode.SecurityError, EdmSchemaErrorSeverity.Error, ex);
}
catch (System.IO.DirectoryNotFoundException ex)
{
AddError(ModelBuilderErrorCode.DirectoryNotFound, EdmSchemaErrorSeverity.Error, ex);
}
catch (System.IO.IOException ex)
{
AddError(ModelBuilderErrorCode.IOException, EdmSchemaErrorSeverity.Error, ex);
}
finally
{
if (indentedTextWriter != null)
{
indentedTextWriter.Close();
}
if (tempFileStream != null)
{
tempFileStream.Close();
}
if (tempFiles != null)
{
tempFiles.Delete();
((IDisposable)tempFiles).Dispose();
}
if (reader != null)
{
reader.Close();
}
if (writer != null)
{
writer.Close();
}
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("foreach (");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(IterationItemType), tw, opts);
tw.Write(" {0} in ", provider.CreateValidIdentifier(IterationItemName));
provider.GenerateCodeFromExpression(IterExpression, tw, opts);
tw.WriteLine(")");
tw.WriteLine("{");
tw.Indent++;
if (Statements != null)
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.WriteLine("}");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("For Each {0} As ", provider.CreateValidIdentifier(IterationItemName));
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(IterationItemType), tw, opts);
tw.Write(" in ");
provider.GenerateCodeFromExpression(IterExpression, tw, opts);
tw.WriteLine();
tw.Indent++;
if (Statements != null)
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.WriteLine("Next");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
private void GetViewsAndCodeDomProvider(StorageMappingItemCollection mappingCollection, out CodeDomProvider provider, out IList<EdmSchemaError> schemaErrors, out Dictionary<EntitySetBase, string> generatedViews)
{
//Create a CodeDomProvider based on options.
provider = null;
switch (m_languageOption)
{
case LanguageOption.GenerateCSharpCode:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case LanguageOption.GenerateVBCode:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
}
//Get the views for the Entity Sets and Association Sets in the mapping item collection
GetEntitySetViews(mappingCollection, out schemaErrors, out generatedViews);
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
if (!_eq)
{
tw.Write("!");
}
tw.Write("ReferenceEquals(");
provider.GenerateCodeFromExpression(_left, tw, opts);
tw.Write(", ");
provider.GenerateCodeFromExpression(_right, tw, opts);
tw.Write(")");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromExpression(_left, tw, opts);
if (_eq)
tw.Write(" Is ");
else
tw.Write(" IsNot ");
provider.GenerateCodeFromExpression(_right, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
