void Compile(string Code, string Path, bool FormProgram, string MainClass)
{
Dictionary<string, string> providerOptions = new Dictionary<string, string>();
providerOptions.Add("CompilerVersion", "v2.0");
VBCodeProvider CodeProvider = new VBCodeProvider(providerOptions);
CompilerParameters Parameters = new CompilerParameters();
Parameters.GenerateExecutable = true;
Parameters.OutputAssembly = Path;
if (FormProgram) Parameters.CompilerOptions = "/target:winexe";
Parameters.MainClass = MainClass;
Parameters.IncludeDebugInformation = false;
Parameters.ReferencedAssemblies.Add("System.dll");
Parameters.ReferencedAssemblies.Add("System.Data.dll");
Parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
Parameters.ReferencedAssemblies.Add("System.Drawing.dll");
Parameters.ReferencedAssemblies.Add("System.XML.dll");
CompilerResults Results = CodeProvider.CompileAssemblyFromSource(Parameters, Code);
if (Results.Errors.Count > 0)
{
foreach (CompilerError E in Results.Errors)
{
MessageBox.Show(E.ErrorText);
}
}
}
public void Deny_Unrestricted ()
{
VBCodeProvider vbprov = new VBCodeProvider ();
Assert.AreEqual ("vb", vbprov.FileExtension, "FileExtension");
Assert.AreEqual (LanguageOptions.CaseInsensitive, vbprov.LanguageOptions, "LanguageOptions");
Assert.IsNotNull (vbprov.CreateCompiler (), "CreateCompiler");
Assert.IsNotNull (vbprov.CreateGenerator (), "CreateGenerator");
try {
Assert.IsNotNull (vbprov.GetConverter (typeof (string)), "GetConverter");
}
catch (NotImplementedException) {
// mono
}
#if NET_2_0
CodeTypeMember ctm = new CodeTypeMember ();
StringWriter sw = new StringWriter ();
CodeGeneratorOptions cgo = new CodeGeneratorOptions ();
try {
vbprov.GenerateCodeFromMember (ctm, sw, cgo);
}
catch (NotImplementedException) {
// mono
}
#endif
}
public void gen(string output, string source)
{
ICodeCompiler Compiler = new VBCodeProvider().CreateCompiler();
var Parameters = new CompilerParameters();
CompilerResults cResults;
Parameters.GenerateExecutable = true;
Parameters.OutputAssembly = output;
Parameters.ReferencedAssemblies.Add("System.dll");
Parameters.ReferencedAssemblies.Add("System.Data.dll");
Parameters.ReferencedAssemblies.Add("System.Drawing.dll");
Parameters.ReferencedAssemblies.Add("System.Design.dll");
Parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
Parameters.ReferencedAssemblies.Add("System.XML.dll");
Parameters.ReferencedAssemblies.Add("System.Management.dll");
Parameters.ReferencedAssemblies.Add("System.Management.dll");
if (CheckBox26.Checked & (source == this._source))
Parameters.EmbeddedResources.Add(Application.StartupPath + "\\Process.resources");
var Version = new Dictionary<string, string>();
Version.Add("Windows", "v1.0");
Parameters.CompilerOptions = "/target:winexe";
cResults = Compiler.CompileAssemblyFromSource(Parameters, source);
if (cResults.Errors.Count > 0)
{
foreach (CompilerError error in cResults.Errors)
MessageBox.Show("Error: " + error.ErrorText, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public override bool Compile(string queryText, QueryCore query, TempFileRef dataContextAssembly)
{
bool flag;
StringBuilder builder = new StringBuilder(this.GetHeader(query));
base.LineOffset = builder.ToString().Count<char>(c => c == '\n');
builder.AppendLine(Regex.Replace(queryText.Trim(), "(?<!\r)\n", "\r\n"));
builder.Append(this.GetFooter(query));
string str = "v4.0";
Dictionary<string, string> providerOptions = new Dictionary<string, string>();
providerOptions.Add("CompilerVersion", str);
VBCodeProvider codeProvider = new VBCodeProvider(providerOptions);
if ((!(flag = base.Compile(codeProvider, builder.ToString(), dataContextAssembly, query.QueryKind, this.GetCompilerOptions(query))) && (query.QueryKind == QueryLanguage.VBExpression)) && (base.ErrorMessage == ") expected"))
{
base.ErrorMessage = ") or end of expression expected";
return flag;
}
if (!(flag || !base.ErrorMessage.ToLowerInvariant().Contains("predicatebuilder")))
{
base.ErrorMessage = base.ErrorMessage + QueryCompiler.PredicateBuilderMessage;
return flag;
}
if (!(((flag || (query.QueryKind != QueryLanguage.VBStatements)) || !(base.ErrorMessage == "Expression is not a method.")) || query.Source.TrimStart(new char[0]).StartsWith("dim", StringComparison.OrdinalIgnoreCase)))
{
base.ErrorMessage = base.ErrorMessage + "\r\n(Try setting the query language to 'VB Expression' rather than 'VB Statements')";
return flag;
}
if ((!flag && (query.QueryKind == QueryLanguage.VBExpression)) && (base.ErrorMessage == "Expression expected."))
{
base.ErrorMessage = base.ErrorMessage + "\r\n(Set the query language to 'VB Statement(s)' for a statement-based code)";
}
return flag;
}
/// <summary>
/// Creates a code DOM provider appropriate for the specified script language.
/// </summary>
/// <param name="scriptLanguage">The script language.</param>
/// <param name="compilerVersion">The compiler version.</param>
/// <returns>A code DOM provider.</returns>
public static CodeDomProvider Create(ScriptLanguage scriptLanguage, string compilerVersion)
{
if (compilerVersion == null)
{
throw new ArgumentNullException("compilerVersion");
}
else if (string.IsNullOrWhiteSpace(compilerVersion))
{
throw new ArgumentException(InternalExceptionStrings.ArgumentException_EmptyOrWhitespaceString, "compilerVersion");
}
CodeDomProvider instance;
Dictionary<string, string> providerOptions =
new Dictionary<string, string>()
{
{ "CompilerVersion", compilerVersion }
};
if (scriptLanguage == ScriptLanguage.CSharp)
{
instance = new CSharpCodeProvider(providerOptions);
}
else if (scriptLanguage == ScriptLanguage.VisualBasic)
{
instance = new VBCodeProvider(providerOptions);
}
else
{
throw new InvalidOperationException(InvalidOperationException_UnsupportedLanguage);
}
return instance;
}
public CompilerResults Compile()
{
Dictionary<string, string> dictionary = new Dictionary<string, string>();
dictionary.Add("CompilerVersion", "v4.0");
CodeDomProvider codeDomProvider;
switch (this.codeLang)
{
case CodeLang.CSharp:
codeDomProvider = new CSharpCodeProvider(dictionary);
break;
case CodeLang.VisualBasic:
codeDomProvider = new VBCodeProvider(dictionary);
break;
default:
throw new NotSupportedException(string.Format("Not supported code language - {0}", this.codeLang));
}
foreach (string reference in this.references)
this.parameters.ReferencedAssemblies.Add(reference);
if (this.codeLang == CodeLang.VisualBasic)
{
foreach (object obj in new List<string>()
{
"FreeQuant.FIX",
"FreeQuant.Instruments",
"FreeQuant.Series",
"FreeQuant.Charting"
})
this.parameters.ReferencedAssemblies.Add(Path.Combine(Framework.Installation.BinDir.FullName, string.Format("{0}.dll", obj)));
}
return codeDomProvider.CompileAssemblyFromFile(this.parameters, this.filenames.ToArray());
}
public void CreateCompiler_ReturnsSame()
{
VBCodeProvider provider = new VBCodeProvider();
#pragma warning disable 0618
Assert.Same(provider.CreateCompiler(), provider.CreateCompiler());
#pragma warning restore 0618
}
/// <summary>
/// Compiles the source to assembly.
/// </summary>
/// <param name="script">The SharpScript.</param>
/// <returns>Assembly.</returns>
public static Assembly CompileToAssembly(VBScript script)
{
var cdProvider = new VBCodeProvider();
var param = new CompilerParameters();
param.ReferencedAssemblies.Add("System.dll");
param.ReferencedAssemblies.Add("Sharpex2D.dll");
param.ReferencedAssemblies.Add(Application.ExecutablePath);
param.GenerateExecutable = false;
CompilerResults result = cdProvider.CompileAssemblyFromSource(param, script.Content);
bool flag = false;
foreach (CompilerError error in result.Errors)
{
if (error.IsWarning)
{
Logger.Warn("{0} -> {1} (Line {2})", script.Guid, error.ErrorText, error.Line);
}
else
{
Logger.Critical("{0} -> {1} (Line {2})", script.Guid, error.ErrorText, error.Line);
flag = true;
}
}
if (flag)
{
throw new ScriptException("Critical error while compiling script.");
}
return result.CompiledAssembly;
}
/// <summary>
/// Main executor function.
/// </summary>
/// <returns>A string of generated VB.net code.</returns>
public string Execute()
{
using (var codeProvider = new VBCodeProvider())
{
return CodeUnitToLanguage(codeProvider);
}
}
public void Ctor_IDictionaryStringString(IDictionary<string, string> providerOptions)
{
VBCodeProvider provider = new VBCodeProvider();
#pragma warning disable 0618
Assert.NotNull(provider.CreateGenerator());
Assert.Same(provider.CreateGenerator(), provider.CreateCompiler());
#pragma warning restore 0618
}
public override void SetUp ()
{
base.SetUp ();
_typeDeclaration = new CodeTypeDeclaration ();
CodeDomProvider provider = new VBCodeProvider ();
_codeGenerator = provider.CreateGenerator ();
}
public void Ctor_Default()
{
VBCodeProvider provider = new VBCodeProvider();
#pragma warning disable 0618
Assert.NotNull(provider.CreateGenerator());
Assert.Same(provider.CreateGenerator(), provider.CreateCompiler());
#pragma warning restore 0618
}
static TestUtilities()
{
cSharpCompiler = new CSharpCodeProvider();
compiler = cSharpCompiler.CreateCompiler();
compileParameters = new CompilerParameters();
vbCompilerProvider = new VBCodeProvider();
vbCompiler = vbCompilerProvider.CreateCompiler();
vbCompileParameters = new CompilerParameters();
}
public VisualBasicLanguage()
{
_codeProvider = new VBCodeProvider();
using (var fileStream = File.Open(Path.Combine(Application.StartupPath, "Languages", "Net", "VisualBasic.xml"), FileMode.Open, FileAccess.Read))
{
var serializer = new XmlSerializer(typeof(NetLanguageData));
_data = (NetLanguageData)serializer.Deserialize(fileStream);
}
_keywords = _data.Keywords.MergeWith(_data.Modifiers).MergeWith(_data.MemberIdentifiers);
}
public static string EscapeStringForLanguage(string input, QueryLanguage language)
{
CodeDomProvider provider;
StringWriter writer = new StringWriter();
if (language <= QueryLanguage.Program)
{
provider = new CSharpCodeProvider();
}
else
{
provider = new VBCodeProvider();
}
provider.GenerateCodeFromExpression(new CodePrimitiveExpression(input), writer, null);
return writer.GetStringBuilder().ToString();
}
internal static TemplateCompilationResult Compile(
Type templateType,
string templateBody,
IEnumerable<string> assemblyFileNames,
IEnumerable<string> namespaces,
string tempDirectory)
{
LoadRuntimeBinder();
string className;
var compileUnit = GetCodeCompileUnit(templateType, namespaces, templateBody, out className);
string sourceCode;
CodeDomProvider codeProvider;
switch (Language)
{
case TemplateCompilationLanguage.CSharp:
codeProvider = new CSharpCodeProvider();
break;
case TemplateCompilationLanguage.VisualBasic:
codeProvider = new VBCodeProvider();
break;
default:
throw new NotSupportedException("Language not supported.");
}
var builder = new StringBuilder();
using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture))
{
codeProvider.GenerateCodeFromCompileUnit(compileUnit, writer, new CodeGeneratorOptions());
sourceCode = builder.ToString();
}
var parameters = CreateCompilerParameters(tempDirectory, assemblyFileNames);
var compileResult = codeProvider.CompileAssemblyFromDom(parameters, compileUnit);
if (compileResult.Errors != null && compileResult.Errors.Count > 0)
throw new TemplateCompilationException(compileResult.Errors, sourceCode, templateBody);
var fullClassName = TEMPLATES_NAMESPACE + "." + className;
return new TemplateCompilationResult
{
Type = compileResult.CompiledAssembly.GetType(fullClassName),
SourceCode = sourceCode
};
}
public static void Load(PluginInterface.logprintf_t logprint, string indent)
{
LogPrint = logprint;
Indent = indent;
if (!Directory.Exists(WorkingDir))
Directory.CreateDirectory(WorkingDir);
ConvertIncludes();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = false;
parameters.ReferencedAssemblies.AddRange(Assembly.GetExecutingAssembly().GetReferencedAssemblies().Select(entry => entry.Name).ToArray());
parameters.WarningLevel = 4;
string[] csfiles = Directory.GetFiles(WorkingDir, "*.cs");
LogPrint(Indent + "Loading " + csfiles.Length + " CSharp files...");
foreach (string file in csfiles)
{
PrepCompilerParameters(file, parameters);
//if (csfiles.Length > 0)
//{
CSharpCodeProvider csprovider = new CSharpCodeProvider();
//CompilerResults results = csprovider.CompileAssemblyFromFile(parameters, csfiles);
CompilerResults results = csprovider.CompileAssemblyFromFile(parameters, file);
Parse(results);
//}
//parameters.ReferencedAssemblies.Add(file); //Hozzáadja az aktuális fájlt a következőhöz, hogy... - Csak a legutolsó kapná meg az összeset
}
LogPrint(Indent + "Loaded " + csfiles.Length + " CSharp files.");
string[] vbfiles = Directory.GetFiles(WorkingDir, "*.vb");
LogPrint(Indent + "Loading " + vbfiles.Length + " VisualBasic files...");
//if (vbfiles.Length > 0)
foreach (string file in vbfiles)
{
PrepCompilerParameters(file, parameters);
VBCodeProvider vbprovider = new VBCodeProvider();
CompilerResults results = vbprovider.CompileAssemblyFromFile(parameters, vbfiles);
Parse(results);
}
LogPrint(Indent + "Loaded " + vbfiles.Length + " VisualBasic files.");
}
protected virtual CodeDomProvider GetCodeProvider(string fileName)
{
CodeDomProvider provider = null;
string extension = Path.GetExtension(fileName);
if (String.Compare(extension, ".cs", true) == 0)
{
provider = new Microsoft.CSharp.CSharpCodeProvider();
}
else if (String.Compare(extension, ".vb", true) == 0)
{
provider = new Microsoft.VisualBasic.VBCodeProvider();
}
else
{
throw new InvalidOperationException("Programming language not supported for:" + fileName);
}
return(provider);
}
private static void GenerateHelloWorld(string outputDir)
{
// Generate Hello World using Brute Force
HelloWorldViaBruteForce.GenerateOutput(System.IO.Path.Combine(outputDir, "HelloWorldViaBruteForce.cs"));
// Generate Hello World in Visual Basic using the CodeDOM
System.CodeDom.CodeCompileUnit compileUnit;
System.CodeDom.Compiler.CodeDomProvider provider;
compileUnit = HelloWorldViaCodeDOM.BuildGraph();
provider = new Microsoft.CSharp.CSharpCodeProvider();
GenerateViaCodeDOM(System.IO.Path.Combine(outputDir, "HelloWorldViaCodeDOM.cs"), provider, compileUnit);
// Use same compile unit to generate VB Hello World
provider = new Microsoft.VisualBasic.VBCodeProvider();
GenerateViaCodeDOM(System.IO.Path.Combine(outputDir, "HelloWorldViaCodeDOM.vb"), provider, compileUnit);
// Generate Hello World via XSLT Template
GenerateViaXSLT(System.IO.Path.Combine(xsltDir, "HelloWorld.xslt"),
null,
System.IO.Path.Combine(outputDir, "HelloWorldViaXSLT.cs"));
}
public dynamic CompileAndRun(string engine, string expression, ScriptScope scope)
{
_eventHandler.BeforeCompilation(new BeforeDotNetCompilationContext(scope));
var parameters = new CompilerParameters { GenerateInMemory = true, TreatWarningsAsErrors = false };
foreach (var item in scope.Assemblies) parameters.ReferencedAssemblies.Add(item.Location);
CompilerResults result;
var providerOptions = new Dictionary<string, string>() { { "CompilerVersion", "v4.0" } };
switch (engine)
{
case "C#":
result = new CSharpCodeProvider(providerOptions).CompileAssemblyFromSource(parameters, expression);
break;
case "VB":
result = new VBCodeProvider(providerOptions).CompileAssemblyFromSource(parameters, expression);
break;
default:
throw new ArgumentException(T("Undefined .NET scripting engine.").ToString());
}
_eventHandler.AfterCompilation(new AfterDotNetCompilationContext(scope, result));
if (result.Errors.HasErrors)
{
var builder = new StringBuilder();
foreach (var item in result.Errors) builder.Append(Environment.NewLine + item);
throw new ScriptRuntimeException(Environment.NewLine + T("The following compile error(s) need to be fixed:") + builder.ToString());
}
var entryClass = result.CompiledAssembly.CreateInstance("DotNetScripting");
_eventHandler.BeforeExecution(new BeforeDotNetExecutionContext(scope));
var scriptResult = entryClass.GetType().GetMethod("Main").Invoke(entryClass, new object[] { });
_eventHandler.AfterExecution(new AfterDotNetExecutionContext(scope));
return scriptResult;
}
internal static CodeDomProvider CreateCodeProviderInstance(Type type, string compilerVersion)
{
CodeDomProvider provider = null;
if (string.IsNullOrEmpty(compilerVersion))
{
if (type == typeof(CSharpCodeProvider))
provider = new CSharpCodeProvider();
else if (type == typeof(VBCodeProvider))
provider = new VBCodeProvider();
else
provider = (CodeDomProvider)Activator.CreateInstance(type);
}
else
{
//otherwise pass the compiler version parameter into it
Dictionary<string, string> options = new Dictionary<string, string>();
options.Add(CompilerHelpers.CompilerVersionKeyword, compilerVersion);
provider = (CodeDomProvider)Activator.CreateInstance(type, new object[] { options });
}
return provider;
}
/// <summary>
/// Compile source code
/// </summary>
/// <param name="code">full source code to compile</param>
/// <param name="references">assembly references</param>
/// <param name="language">target language</param>
/// <param name="compilerVersion">compiler version</param>
public void Compile(string code, string[] references, ESupportedLanguage language, String compilerVersion)
{
var properties = new Dictionary<string, string> {{CompilerVersion, compilerVersion}};
CodeDomProvider provider;
switch (language)
{
case ESupportedLanguage.CSharp:
provider = new CSharpCodeProvider(properties);
break;
case ESupportedLanguage.VisualBasic:
provider = new VBCodeProvider(properties);
break;
default:
throw new ArgumentException();
}
var parameters = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = false,
IncludeDebugInformation = false
};
parameters.ReferencedAssemblies.AddRange(references);
if (language == ESupportedLanguage.CSharp)
{
parameters.CompilerOptions = "/unsafe";
}
var results = provider.CompileAssemblyFromSource(parameters, code);
AssemblyLocation = null;
Errors = results.Errors;
if (!results.Errors.HasErrors)
AssemblyLocation = results.CompiledAssembly.Location;
}
private Type CreateType(string className, string codeFragment, string statement)
{
CompilerParameters compilerParameters = CreateCompilerParameters();
statement = String.Format("{0}{2}{1}", BuildNameSpaces(), statement, Environment.NewLine);
CodeDomProvider codeDomProvider = null;
switch (_language)
{
case ChoCodeProviderLanguage.VB:
codeDomProvider = new Microsoft.VisualBasic.VBCodeProvider();
break;
default:
codeDomProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
using (codeDomProvider)
{
var res = codeDomProvider.CompileAssemblyFromSource(compilerParameters, statement);
if (res.Errors.Count > 0)
{
StringBuilder errors = new StringBuilder();
foreach (CompilerError CompErr in res.Errors)
{
errors.AppendFormat("Line number {0}, Error Number: {1}, {2}{3}", CompErr.Line, CompErr.ErrorNumber, CompErr.ErrorText, Environment.NewLine);
}
throw new ApplicationException("Exception compiling code fragment: {1}{1}{0}{1}{1}Exceptions:{1}{2}".FormatString(
codeFragment.Indent(1), Environment.NewLine, errors.ToString().Indent(1)));
}
return(res.CompiledAssembly.GetType(className));
}
}
public void BugFix_VBCallToParameterlessVBScriptSub()
{
var options = new CompilerParameters { GenerateInMemory = true };
options.ReferencedAssemblies.Add("ClearScript.dll");
var results = new VBCodeProvider().CompileAssemblyFromSource(options, new[] { @"
Module TestModule
Sub TestMethod
Using engine As New Microsoft.ClearScript.Windows.VBScriptEngine
engine.Execute(""sub main : end sub"")
engine.Script.main()
End Using
End Sub
End Module
"});
results.CompiledAssembly.GetType("TestModule").InvokeMember("TestMethod", BindingFlags.InvokeMethod, null, null, MiscHelpers.GetEmptyArray<object>());
}
/// <summary>
/// Compiles the scripts into an assembly
/// </summary>
/// <param name="compileVB">True if the source files will be in VB.NET</param>
/// <param name="path">Path to the source files</param>
/// <param name="dllName">Name of the assembly to be generated</param>
/// <param name="asm_names">References to other assemblies</param>
/// <returns>True if succeeded</returns>
public static bool CompileScripts(bool compileVB, string path, string dllName, string[] asm_names)
{
if (!path.EndsWith(@"\") && !path.EndsWith(@"/"))
path = path + "/";
//Reset the assemblies
m_compiledScripts.Clear();
//Check if there are any scripts, if no scripts exist, that is fine as well
IList<FileInfo> files = ParseDirectory(new DirectoryInfo(path), compileVB ? "*.vb" : "*.cs", true);
if (files.Count == 0)
{
return true;
}
//Recompile is required as standard
bool recompileRequired = true;
//This file should hold the script infos
FileInfo configFile = new FileInfo(dllName + ".xml");
//If the script assembly is missing, recompile is required
if (!File.Exists(dllName))
{
if (log.IsDebugEnabled)
log.Debug("Script assembly missing, recompile required!");
}
else
{
//Script assembly found, check if we have a file modify info
if (configFile.Exists)
{
//Ok, we have a config file containing the script file sizes and dates
//let's check if any script was modified since last compiling them
if (log.IsDebugEnabled)
log.Debug("Found script info file");
try
{
XMLConfigFile config = XMLConfigFile.ParseXMLFile(configFile);
//Assume no scripts changed
recompileRequired = false;
Dictionary<string, ConfigElement> precompiledScripts = new Dictionary<string, ConfigElement>(config.Children);
//Now test the files
foreach (FileInfo finfo in files)
{
if (config[finfo.FullName]["size"].GetInt(0) != finfo.Length
|| config[finfo.FullName]["lastmodified"].GetLong(0) != finfo.LastWriteTime.ToFileTime())
{
//Recompile required
recompileRequired = true;
break;
}
precompiledScripts.Remove(finfo.FullName);
}
recompileRequired |= precompiledScripts.Count > 0; // some compiled script was removed
if (recompileRequired && log.IsDebugEnabled)
{
log.Debug("At least one file was modified, recompile required!");
}
}
catch (Exception e)
{
if (log.IsErrorEnabled)
log.Error("Error during script info file to scripts compare", e);
}
}
else
{
if (log.IsDebugEnabled)
log.Debug("Script info file missing, recompile required!");
}
}
//If we need no compiling, we load the existing assembly!
if (!recompileRequired)
{
try
{
Assembly asm = Assembly.LoadFrom(dllName);
AddOrReplaceAssembly(asm);
if (log.IsDebugEnabled)
log.Debug("Precompiled script assembly loaded: " + asm.FullName);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
log.Error("Error loading precompiled script assembly, recompile required!", e);
recompileRequired = true;
}
if (!recompileRequired)
{
//Return success!
return true;
}
}
//We need a recompile, if the dll exists, delete it firsthand
if (File.Exists(dllName))
File.Delete(dllName);
CompilerResults res = null;
try
{
CodeDomProvider compiler;
if (compileVB)
{
compiler = new VBCodeProvider();
}
else
{
compiler = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } });
}
// Graveen: allow script compilation in debug or release mode
#if DEBUG
CompilerParameters param = new CompilerParameters(asm_names, dllName, true);
#else
CompilerParameters param = new CompilerParameters(asm_names, dllName, false);
#endif
param.GenerateExecutable = false;
param.GenerateInMemory = false;
param.WarningLevel = 2;
param.CompilerOptions = string.Format("/optimize /lib:.{0}lib", Path.DirectorySeparatorChar);
param.ReferencedAssemblies.Add("System.Core.dll");
string[] filepaths = new string[files.Count];
for (int i = 0; i < files.Count; i++)
filepaths[i] = ((FileInfo)files[i]).FullName;
res = compiler.CompileAssemblyFromFile(param, filepaths);
//After compiling, collect
GC.Collect();
if (res.Errors.HasErrors)
{
foreach (CompilerError err in res.Errors)
{
if (err.IsWarning) continue;
StringBuilder builder = new StringBuilder();
builder.Append(" ");
builder.Append(err.FileName);
builder.Append(" Line:");
builder.Append(err.Line);
builder.Append(" Col:");
builder.Append(err.Column);
if (log.IsErrorEnabled)
{
log.Error("Script compilation failed because: ");
log.Error(err.ErrorText);
log.Error(builder.ToString());
}
}
return false;
}
AddOrReplaceAssembly(res.CompiledAssembly);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
log.Error("CompileScripts", e);
m_compiledScripts.Clear();
}
//now notify our callbacks
bool ret = false;
if (res != null)
{
ret = !res.Errors.HasErrors;
}
if (ret == false)
return ret;
XMLConfigFile newconfig = new XMLConfigFile();
foreach (FileInfo finfo in files)
{
newconfig[finfo.FullName]["size"].Set(finfo.Length);
newconfig[finfo.FullName]["lastmodified"].Set(finfo.LastWriteTime.ToFileTime());
}
if (log.IsDebugEnabled)
log.Debug("Writing script info file");
newconfig.Save(configFile);
return true;
}
protected virtual string ScrubName(string name)
{
Check.NotEmpty(name, "name");
var invalidChars
= new Regex(@"[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Nl}\p{Mn}\p{Mc}\p{Cf}\p{Pc}\p{Lm}]");
name = invalidChars.Replace(name, string.Empty);
using (var codeProvider = new VBCodeProvider())
{
if ((!char.IsLetter(name[0]) && name[0] != '_')
|| !codeProvider.IsValidIdentifier(name))
{
name = "_" + name;
}
}
return name;
}
private void UpdateCodeWindows()
{
TabControl tc = this.host.GetService(typeof(TabControl)) as TabControl;
CodeGeneratorOptions o = new CodeGeneratorOptions();
o.BlankLinesBetweenMembers = true;
o.BracingStyle = "C";
o.ElseOnClosing = false;
o.IndentString = " ";
StringWriter sw = new StringWriter();
CSharpCodeProvider cs = new CSharpCodeProvider();
cs.CreateGenerator().GenerateCodeFromCompileUnit(this.codeCompileUnit, sw, o);
sw.Close();
sw = new StringWriter();
VBCodeProvider vb = new VBCodeProvider();
vb.CreateGenerator().GenerateCodeFromCompileUnit(this.codeCompileUnit, sw, o);
sw.Close();
sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw);
xtw.Formatting = Formatting.Indented;
this.xmlDocument.WriteTo(xtw);
string cleanup = sw.ToString().Replace("<DOCUMENT_ELEMENT>", "").Replace("</DOCUMENT_ELEMENT>", "");
sw.Close();
}
// http://stackoverflow.com/questions/2684278/why-does-microsoft-jscript-work-in-the-code-behind-but-not-within-a
public static object Eval(string vbCode)
{
object retValue;
System.Text.StringBuilder sb = new System.Text.StringBuilder("");
sb.Append("Imports System" + Constants.vbCrLf);
// sb.Append("Imports System.Xml" & vbCrLf)
// sb.Append("Imports System.Data" & vbCrLf)
// sb.Append("Imports System.Data.SqlClient" & vbCrLf)
// sb.Append("Imports System.Math" & vbCrLf)
sb.Append("Imports Microsoft.VisualBasic" + Constants.vbCrLf);
sb.Append("Namespace MyEvalNamespace_2C04AF0B_8EC8_4D84_AD83_51FFBBBBC8C6BFAC7762_5502_40C9_AE35_A545434012A4528B58FB_641E_4D61_BA15_E64C58CD8CFC " + Constants.vbCrLf);
sb.Append("Class MyEvalClass " + Constants.vbCrLf);
sb.Append("Public Function EvalCode() As Object " + Constants.vbCrLf);
// sb.Append("YourNamespace.YourBaseClass thisObject = New YourNamespace.YourBaseClass()")
sb.Append(vbCode + Constants.vbCrLf);
sb.Append("End Function " + Constants.vbCrLf);
sb.Append("End Class " + Constants.vbCrLf);
sb.Append("End Namespace " + Constants.vbCrLf);
// Debug.WriteLine(sb.ToString()) ' look at this to debug your eval string
string codeToCompile = sb.ToString();
sb.Clear();
sb = null;
// System.Console.WriteLine(codeToCompile)
using (Microsoft.VisualBasic.VBCodeProvider codeProvider = new Microsoft.VisualBasic.VBCodeProvider())
{
// System.CodeDom.Compiler.ICodeCompiler icc = codeProvider.CreateCompiler();
System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters();
cp.ReferencedAssemblies.Add("System.dll");
// cp.ReferencedAssemblies.Add("System.Xml.dll");
// cp.ReferencedAssemblies.Add("System.Data.dll");
// cp.ReferencedAssemblies.Add("Microsoft.JScript.dll");
// Sample code for adding your own referenced assemblies
// cp.ReferencedAssemblies.Add(@"C:\YourProjectDir\bin\YourBaseClass.dll");
// cp.ReferencedAssemblies.Add("YourBaseclass.dll");
cp.CompilerOptions = "/t:library";
cp.GenerateInMemory = true;
// System.CodeDom.Compiler.CompilerResults cr = icc.CompileAssemblyFromSource(cp, codeToCompile);
System.CodeDom.Compiler.CompilerResults cr = codeProvider.CompileAssemblyFromSource(cp, codeToCompile);
System.Reflection.Assembly a = cr.CompiledAssembly;
object o = a.CreateInstance("MyEvalNamespace_2C04AF0B_8EC8_4D84_AD83_51FFBBBBC8C6BFAC7762_5502_40C9_AE35_A545434012A4528B58FB_641E_4D61_BA15_E64C58CD8CFC.MyEvalClass");
System.Type t = o.GetType();
System.Reflection.MethodInfo mi = t.GetMethod("EvalCode");
retValue = mi.Invoke(o, null);
} // End Using codeProvider
return(retValue);
} // End Function Eval
private void CheckAssembly()
{
lbErrors.Items.Clear(); // clear out existing items
// Generate the proxy source code
List<string> lines = new List<string>(); // hold lines in array in case of error
VBCodeProvider vbcp = new VBCodeProvider();
StringBuilder sb = new StringBuilder();
// Generate code with the following general form
//Imports System
//Imports Microsoft.VisualBasic
//Imports System.Convert
//Imports System.Math
//Namespace ReportingCloud.vbgen
//Public Class MyClassn // where n is a uniquely generated integer
//Sub New()
//End Sub
// ' this is the code in the <Code> tag
//End Class
//End Namespace
string unique = Interlocked.Increment(ref CodeCtl.Counter).ToString();
lines.Add("Imports System");
lines.Add("Imports Microsoft.VisualBasic");
lines.Add("Imports System.Convert");
lines.Add("Imports System.Math");
lines.Add("Imports ReportingCloud.Engine");
lines.Add("Namespace ReportingCloud.vbgen");
string classname = "MyClass" + unique;
lines.Add("Public Class " + classname);
lines.Add("Private Shared _report As CodeReport");
lines.Add("Sub New()");
lines.Add("End Sub");
lines.Add("Sub New(byVal def As Report)");
lines.Add(classname + "._report = New CodeReport(def)");
lines.Add("End Sub");
lines.Add("Public Shared ReadOnly Property Report As CodeReport");
lines.Add("Get");
lines.Add("Return " + classname + "._report");
lines.Add("End Get");
lines.Add("End Property");
int pre_lines = lines.Count; // number of lines prior to user VB code
// Read and write code as lines
StringReader tr = new StringReader(this.tbCode.Text);
while (tr.Peek() >= 0)
{
string line = tr.ReadLine();
lines.Add(line);
}
tr.Close();
lines.Add("End Class");
lines.Add("End Namespace");
foreach (string l in lines)
{
sb.Append(l);
sb.Append(Environment.NewLine);
}
string vbcode = sb.ToString();
// Create Assembly
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("System.dll");
string re = AppDomain.CurrentDomain.BaseDirectory + "ReportingCloud.Engine.dll";
cp.ReferencedAssemblies.Add(re);
// also allow access to classes that have been added to report
XmlNode rNode = _Draw.GetReportNode();
XmlNode cNode = _Draw.GetNamedChildNode(rNode, "CodeModules");
if (cNode != null)
{
foreach (XmlNode xn in cNode.ChildNodes)
{
if (xn.Name != "CodeModule")
continue;
cp.ReferencedAssemblies.Add(xn.InnerText);
}
}
cp.GenerateExecutable = false;
cp.GenerateInMemory = true;
cp.IncludeDebugInformation = false;
CompilerResults cr = vbcp.CompileAssemblyFromSource(cp, vbcode);
if(cr.Errors.Count > 0)
{
StringBuilder err = new StringBuilder(string.Format("Code has {0} error(s).", cr.Errors.Count));
foreach (CompilerError ce in cr.Errors)
{
lbErrors.Items.Add(string.Format("Ln {0}- {1}", ce.Line - pre_lines, ce.ErrorText));
}
}
else
MessageBox.Show("No errors", "Code Verification");
return ;
}
public void SetUp ()
{
provider = new VBCodeProvider ();
generator = provider.CreateGenerator ();
options = new CodeGeneratorOptions ();
}
/// <summary>
/// Compiles a given string script
/// </summary>
/// <returns>True if compilation ok</returns>
public bool Compile()
{
// Already compiled ?
if (IsCompiled)
{
return(true);
}
IsCompiled = false;
IsModified = false;
HasErrors = false;
Errors = null;
CompiledAssembly = null;
// Generate the compiler provider
switch (Language)
{
case ScriptLanguage.CSharp:
{
ScriptProvider = new Microsoft.CSharp.CSharpCodeProvider();
if (ScriptProvider == null)
{
Trace.WriteLine("Failed to initialize a new instance of the CSharpCodeProvider class");
return(false);
}
}
break;
case ScriptLanguage.VBNet:
{
ScriptProvider = new Microsoft.VisualBasic.VBCodeProvider();
if (ScriptProvider == null)
{
Trace.WriteLine("Failed to initialize a new instance of the VBCodeProvider class");
return(false);
}
}
break;
default:
{
Trace.WriteLine("Unknown scripting language !!!");
return(false);
}
}
// Compile
CompilerResults results = ScriptProvider.CompileAssemblyFromSource(Params, sourceCode);
if (results.Errors.Count == 0)
{
CompiledAssembly = results.CompiledAssembly;
IsCompiled = true;
return(true);
}
Errors = results.Errors;
HasErrors = true;
Trace.WriteLine("Compile complete -- " + Errors.Count + " error(s).");
foreach (CompilerError error in Errors)
{
Trace.WriteLine("line " + error.Line + " : " + error.ErrorText);
}
return(IsCompiled);
}
/// <summary>
/// Creates a StronglyTyped class from a REsx file. Can be used after a Resx fi
/// </summary>
/// <param name="resxFile"></param>
/// <param name="resourceSetName"></param>
/// <param name="namespaceName"></param>
public void CreateResxDesignerClassFromResxFile(string resxFile, string resourceSetName, string namespaceName, bool vb = false)
{
string outfile;
CodeDomProvider provider;
if (!vb)
{
provider = new CSharpCodeProvider();
outfile = Path.ChangeExtension(resxFile, "designer.cs");
}
else
{
provider = new VBCodeProvider();
outfile = Path.ChangeExtension(resxFile, "designer.vb");
}
using (StreamWriter sw = new StreamWriter(outfile))
{
string[] errors = null;
var curPath = Environment.CurrentDirectory;
Directory.SetCurrentDirectory(Path.GetDirectoryName(resxFile));
var code = StronglyTypedResourceBuilder.Create(resxFile, resourceSetName, namespaceName, provider, false,
out errors);
Directory.SetCurrentDirectory(curPath);
if (errors.Length > 0)
{
foreach (var error in errors)
{
ErrorMessage += error + "\r\n";
}
throw new ApplicationException(ErrorMessage);
}
provider.GenerateCodeFromCompileUnit(code, sw, new CodeGeneratorOptions());
}
}
/////////////////////////////////////////////////////////////////////////////
public static string VbSourceFromCcu( CodeCompileUnit ccu )
{
//return SourceFromCcu( new VBCodeProvider(), ccu, false );
using( var provider = new VBCodeProvider() ) {
return SourceFromCcu( provider, ccu, false );
}
}
public static bool CompileVBScripts( bool debug, bool cache, out Assembly assembly )
{
Console.Write( "Scripts: Compiling VB.NET scripts..." );
string[] files = GetScripts( "*.vb" );
if( files.Length == 0 )
{
Console.WriteLine( "no files found." );
assembly = null;
return true;
}
if( File.Exists( "Scripts/Output/Scripts.VB.dll" ) )
{
if( cache && File.Exists( "Scripts/Output/Scripts.VB.hash" ) )
{
byte[] hashCode = GetHashCode( "Scripts/Output/Scripts.VB.dll", files, debug );
try
{
using( FileStream fs = new FileStream( "Scripts/Output/Scripts.VB.hash", FileMode.Open, FileAccess.Read, FileShare.Read ) )
{
using( BinaryReader bin = new BinaryReader( fs ) )
{
byte[] bytes = bin.ReadBytes( hashCode.Length );
if( bytes.Length == hashCode.Length )
{
bool valid = true;
for( int i = 0; i < bytes.Length; ++i )
{
if( bytes[i] != hashCode[i] )
{
valid = false;
break;
}
}
if( valid )
{
assembly = Assembly.LoadFrom( "Scripts/Output/Scripts.VB.dll" );
if( !m_AdditionalReferences.Contains( assembly.Location ) )
{
m_AdditionalReferences.Add( assembly.Location );
}
Console.WriteLine( "done (cached)" );
return true;
}
}
}
}
}
catch
{
}
}
}
DeleteFiles( "Scripts.VB*.dll" );
#if Framework_3_5
using ( VBCodeProvider provider = new VBCodeProvider( new Dictionary<string, string>() { { "CompilerVersion", "v3.5" } } ) )
#else
using ( VBCodeProvider provider = new VBCodeProvider() )
#endif
{
string path = GetUnusedPath( "Scripts.VB" );
CompilerParameters parms = new CompilerParameters( GetReferenceAssemblies(), path, debug );
string defines = GetDefines();
if( defines != null )
parms.CompilerOptions = String.Format( "/D:{0}", defines );
if( Core.HaltOnWarning )
parms.WarningLevel = 4;
CompilerResults results = provider.CompileAssemblyFromFile( parms, files );
m_AdditionalReferences.Add( path );
Display( results );
if( results.Errors.Count > 0 )
{
assembly = null;
return false;
}
if( cache && Path.GetFileName( path ) == "Scripts.VB.dll" )
{
try
{
byte[] hashCode = GetHashCode( path, files, debug );
using( FileStream fs = new FileStream( "Scripts/Output/Scripts.VB.hash", FileMode.Create, FileAccess.Write, FileShare.None ) )
{
using( BinaryWriter bin = new BinaryWriter( fs ) )
{
bin.Write( hashCode, 0, hashCode.Length );
}
}
}
catch
{
}
}
assembly = results.CompiledAssembly;
return true;
}
}
private static CompilerResults CompileVBScripts(ICollection fileColl,
string assemblyFile,
LibraryConfig libConfig,
bool debug)
{
VBCodeProvider provider = new VBCodeProvider();
ICodeCompiler compiler = provider.CreateCompiler();
string[] files = new string[fileColl.Count];
fileColl.CopyTo(files, 0);
Console.Write("{0}[VB,{1}", libConfig.Name, files.Length);
CompilerResults results = compiler.CompileAssemblyFromFileBatch( new CompilerParameters( GetReferenceAssemblies(), assemblyFile, true ), files );
m_AdditionalReferences.Add(assemblyFile);
if ( results.Errors.Count > 0 )
{
int errorCount = 0, warningCount = 0;
foreach ( CompilerError e in results.Errors )
{
if ( e.IsWarning )
++warningCount;
else
++errorCount;
}
Console.WriteLine();
if ( errorCount > 0 )
Console.WriteLine( "failed ({0} errors, {1} warnings)", errorCount, warningCount );
else
Console.WriteLine( "done ({0} errors, {1} warnings)", errorCount, warningCount );
foreach ( CompilerError e in results.Errors )
{
Console.WriteLine( " - {0}: {1}: {2}: (line {3}, column {4}) {5}", e.IsWarning ? "Warning" : "Error", e.FileName, e.ErrorNumber, e.Line, e.Column, e.ErrorText );
}
}
else
{
Console.Write("] ");
}
return results;
}
