public override CompilerResults CompileAssemblyFromFile(CompilerParameters options, params string[] fileNames)
{
var units = new CodeCompileUnit[fileNames.Length];
var errors = new CompilerErrorCollection();
var syntax = new Parser(options);
for (int i = 0; i < fileNames.Length; i++)
{
try
{
units[i] = syntax.Parse(new StreamReader(fileNames[i]), fileNames[i]);
}
#if !DEBUG
catch (ParseException e)
{
errors.Add(new CompilerError(e.Source, e.Line, 0, e.Message.GetHashCode().ToString(), e.Message));
}
catch (Exception e)
{
errors.Add(new CompilerError { ErrorText = e.Message });
}
#endif
finally
{
}
}
var results = CompileAssemblyFromDom(options, units);
results.Errors.AddRange(errors);
return results;
}
private void HandleException(Exception ex, ProjectFile file, SingleFileCustomToolResult result)
{
if (ex is SpecFlowParserException)
{
SpecFlowParserException sfpex = (SpecFlowParserException) ex;
if (sfpex.ErrorDetails == null || sfpex.ErrorDetails.Count == 0)
{
result.UnhandledException = ex;
}
else
{
var compilerErrors = new CompilerErrorCollection();
foreach (var errorDetail in sfpex.ErrorDetails)
{
var compilerError = new CompilerError(file.Name, errorDetail.ForcedLine, errorDetail.ForcedColumn, "0", errorDetail.Message);
compilerErrors.Add(compilerError);
}
result.Errors.AddRange(compilerErrors);
}
}
else
{
result.UnhandledException = ex;
}
}
public override void Done(CompilerErrorCollection result)
{
if (!FileSystemHelper.FileCompare(TempFilePath, FilePath))
{
string message = String.Format("Error during file generation. The target file '{0}' is read-only, but different from the transformation result. This problem can be a sign of an inconsistent source code package. Compile and check-in the current version of the file from the development environment or remove the read-only flag from the generation result. To compile a solution that contains messaging project on a build server, you can also exclude the messaging project from the build-server solution or set the <OverwriteReadOnlyFiles> msbuild project parameter to 'true' in the messaging project file.",
Path.GetFullPath(FilePath));
result.Add(new CompilerError(String.Empty, 0, 0, null, message));
}
base.Done(result);
}
internal static void LogicalSetData(string name, object value,
System.CodeDom.Compiler.CompilerErrorCollection errors)
{
//FIXME: CallContext.LogicalSetData not implemented in Mono
try {
System.Runtime.Remoting.Messaging.CallContext.LogicalSetData(name, value);
} catch (NotImplementedException) {
errors.Add(new System.CodeDom.Compiler.CompilerError(
null, -1, -1, null,
"Could not set " + name + " - CallContext.LogicalSetData not implemented in this Mono version"
)
{
IsWarning = true
});
}
}
/// <summary>
/// Creates an Assembly from DynamicAssembly definition
/// </summary>
/// <param name="assemblyDefinition">assembly description</param>
/// <returns>result with assembly or error info</returns>
public static CompileResult CompileDynamicAssembly(DynamicAssembly assemblyDefinition)
{
CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters compilerParameters = new CompilerParameters();
compilerParameters.CompilerOptions = "/t:library /platform:anycpu /lib:" + "\"" +
(String.IsNullOrWhiteSpace(assemblyDefinition.ReferencesPath) ? GetCurrentPath() : assemblyDefinition.ReferencesPath) + "\"";
compilerParameters.IncludeDebugInformation = false;
//compilerParameters.OutputAssembly = assemblyDefinition.Name;
compilerParameters.GenerateInMemory = true;
compilerParameters.GenerateExecutable = false;
foreach (var item in assemblyDefinition.References)
compilerParameters.ReferencedAssemblies.Add(item);
List<string> codeModules = new List<string>();
foreach (DynamicClass item in assemblyDefinition.Classes)
{
string code = DynamicClass.Template;
code = DynamicClass.AddUsingsToTemplate(item, code);
code = DynamicClass.AddInterfacesToTemplate(item, code);
code = DynamicClass.AddNamespaceToTemplate(String.IsNullOrWhiteSpace(item.Namespace) ? assemblyDefinition.Name : item.Namespace, code);
code = DynamicClass.AddNameToTemplate(item, code);
code = DynamicClass.AddPropertiesToTemplate(item, code);
code = DynamicClass.AddMethodsToTemplate(item, code);
codeModules.Add(code);
}
foreach (DynamicCustomClass item in assemblyDefinition.CustomClasses)
codeModules.Add(item.Code);
// we dont allow empty class definitions(fun fact: its okay for the c# compiler)
foreach (DynamicCustomClass item in assemblyDefinition.CustomClasses)
{
if (String.IsNullOrWhiteSpace(item.Code))
{
CompilerErrorCollection collection = new CompilerErrorCollection();
CompilerError customError = new CompilerError("CustomClass", 0, 0, "Custom", "Unable to compile an empty code module.");
collection.Add(customError);
return new CompileResult(codeModules.ToArray(), collection, null);
}
}
CompilerResults compilerResults = codeDomProvider.CompileAssemblyFromSource(compilerParameters, codeModules.ToArray());
codeDomProvider.Dispose();
return new CompileResult(codeModules.ToArray(), compilerResults.Errors, compilerResults.Errors.Count > 0 ? null : compilerResults.CompiledAssembly);
}
public void Constructor0_Deny_Unrestricted ()
{
CompilerErrorCollection coll = new CompilerErrorCollection ();
Assert.AreEqual (0, coll.Add (ce), "Add");
Assert.AreSame (ce, coll[0], "this[int]");
coll[0] = ce;
coll.CopyTo (array, 0);
coll.AddRange (array);
coll.AddRange (coll);
Assert.IsTrue (coll.Contains (ce), "Contains");
Assert.AreEqual (0, coll.IndexOf (ce), "IndexOf");
coll.Insert (0, ce);
coll.Remove (ce);
ce.IsWarning = false;
Assert.IsTrue (coll.HasErrors, "HasErrors");
Assert.IsFalse (coll.HasWarnings, "HasWarnings");
}
public string GenerateCode (out CompilerErrorCollection errors)
{
errors = new CompilerErrorCollection ();
// Create the engine
RazorTemplateEngine engine = new RazorTemplateEngine(this);
// Generate code
GeneratorResults results = null;
try
{
Stream stream = File.OpenRead(_fullPath);
using (var reader = new StreamReader(stream, Encoding.Default, detectEncodingFromByteOrderMarks: true))
{
results = engine.GenerateCode(reader, className: DefaultClassName, rootNamespace: DefaultNamespace, sourceFileName: _fullPath);
}
} catch (Exception e) {
errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ()));
//Returning null signifies that generation has failed
return null;
}
// Output errors
foreach (RazorError error in results.ParserErrors) {
errors.Add (new CompilerError (FullPath, error.Location.LineIndex + 1, error.Location.CharacterIndex + 1, null, error.Message));
}
try
{
using (StringWriter writer = new StringWriter()) {
//Generate the code
writer.WriteLine("#pragma warning disable 1591");
_codeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, writer, _codeGeneratorOptions);
writer.WriteLine("#pragma warning restore 1591");
return writer.ToString();
}
} catch (Exception e) {
errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ()));
//Returning null signifies that generation has failed
return null;
}
}
public string GenerateCode (out CompilerErrorCollection errors)
{
errors = new CompilerErrorCollection ();
var engine = new RewritingRazorTemplateEngine (this, new PreprocessedAttributeRewriter ());
// Generate code
GeneratorResults results;
try {
Stream stream = File.OpenRead (FullPath);
using (var reader = new StreamReader (stream, Encoding.Default, true)) {
results = engine.GenerateCode (reader, DefaultClassName, DefaultNamespace, FullPath);
}
} catch (Exception e) {
errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ()));
//Returning null signifies that generation has failed
return null;
}
// Output errors
foreach (RazorError error in results.ParserErrors) {
errors.Add (new CompilerError (FullPath, error.Location.LineIndex + 1, error.Location.CharacterIndex + 1, null, error.Message));
}
try {
using (var writer = new StringWriter ()) {
writer.WriteLine ("#pragma warning disable 1591");
_codeDomProvider.GenerateCodeFromCompileUnit (results.GeneratedCode, writer, codeGeneratorOptions);
writer.WriteLine ("#pragma warning restore 1591");
string s = writer.ToString ();
return MakeLineDirectivePathsRelative (Path.GetDirectoryName (FullPath), s);
}
} catch (Exception e) {
errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ()));
//Returning null signifies that generation has failed
return null;
}
}
public static void OnTransformationEnded(TextTransformation transformation)
{
try
{
if (transformation == null)
{
throw new ArgumentNullException("transformation");
}
if (TransformationContext.transformation != null && !TransformationContext.Errors.HasErrors)
{
//Update the files in the default AppDomain to avoid remoting errors on Database projects
//BindingFlags invokeInternalStaticMethod = BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.NonPublic;
//AppDomain defaultDomain = (AppDomain)typeof(AppDomain).InvokeMember("GetDefaultDomain", invokeInternalStaticMethod, null, null, null, CultureInfo.InvariantCulture);
//var bd1 = defaultDomain.BaseDirectory;
//var setup = new AppDomainSetup();
//setup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
//AppDomain serverAppDomain = AppDomain.CreateDomain("ServerAppDomain", null, setup);
//var udf = TransformationContext.outputManager;
//defaultDomain.DoCallBack(udf.UpdateFiles);
OutputProcessor.Host = Host;
outputManager.UpdateFiles();
}
TransformationContext.transformation = null;
TransformationContext.outputManager = null;
TransformationContext.project = null;
TransformationContext.projectItem = null;
TransformationContext.dte = null;
if (TransformationContext.TransformationEnded != null)
{
TransformationContext.TransformationEnded(null, EventArgs.Empty);
}
}
catch (TransformationException e)
{
// Display expected errors in the Error List window without the call stack
CompilerErrorCollection errors = new CompilerErrorCollection();
CompilerError error = new CompilerError();
error.ErrorText = e.Message;
error.FileName = Host.TemplateFile;
errors.Add(error);
TransformationContext.Host.LogErrors(errors);
}
finally
{
DestroyTraceListener();
}
}
public bool Run(string sourceCode, out CompilerErrorCollection compilationErrors)
{
bool compilationSucceeded = true;
compilationErrors = new CompilerErrorCollection();
CSharpCodeProvider provider = new CSharpCodeProvider();
// Build the parameters for source compilation.
CompilerParameters cp = new CompilerParameters();
cp.TreatWarningsAsErrors = false;
// Add assembly references.
cp.ReferencedAssemblies.AddRange(DEFAULT_ASSEMBLIES);
//cp.ReferencedAssemblies.AddRange(ReferencedAssemblies.ToArray());
cp.GenerateInMemory = true;
// Add using statements.
StringBuilder script = new StringBuilder();
foreach (var usingNamespace in DEFAULT_NAMESPACES)
script.AppendFormat("using {0};\n", usingNamespace);
// foreach (var additionalUsingNamespace in UsingNamespaces)
// script.AppendFormat("using {0};\n", additionalUsingNamespace);
// Create the script.
script.AppendLine();
script.AppendLine("namespace ScriptEngine");
script.AppendLine("{");
script.AppendLine(" public class Program");
script.AppendLine(" {");
script.AppendLine(" public void Run()");
script.AppendLine(" {");
script.AppendLine(" try");
script.AppendLine(" {");
script.AppendFormat(" {0}\n", sourceCode);
script.AppendLine(" }");
script.AppendLine(" catch (Exception e)");
script.AppendLine(" {");
// script.AppendLine(" Context.Error = _compilationException;");
script.AppendLine(" }");
script.AppendLine(" }");
script.AppendLine(" }");
script.AppendLine("}");
// Invoke compilation.
CompilerResults cr = provider.CompileAssemblyFromSource(cp, script.ToString());
if (cr.Errors.Count > 0)
{
foreach (CompilerError ce in cr.Errors)
{
#if DEBUG
Console.WriteLine(" {0}", ce.ToString());
Console.WriteLine();
#endif
ce.Line = ce.Line - 13;
compilationErrors.Add(ce);
if (!ce.IsWarning)
compilationSucceeded = false;
}
}
if (compilationSucceeded)
{
var ass = cr.CompiledAssembly;
var execInstance = ass.CreateInstance("ScriptEngine.Program");
var type = execInstance.GetType();
var methodInfo = type.GetMethod("Run");
// Execute the code.
// methodInfo.Invoke(execInstance, new object[] { context });
methodInfo.Invoke(execInstance, new object[] {});
}
return compilationSucceeded;
}
public CompilerErrorCollection RunSource( string source, ref ScriptContext context )
{
bool compilationSucceeded = true;
CompilerErrorCollection compilationErrors = new CompilerErrorCollection ( );
CSharpCodeProvider provider = new CSharpCodeProvider ( );
// Build the parameters for source compilation.
CompilerParameters cp = new CompilerParameters ( );
cp.TreatWarningsAsErrors = false;
// Add assembly references.
cp.ReferencedAssemblies.AddRange ( DEFAULT_ASSEMBLIES );
cp.ReferencedAssemblies.AddRange ( ReferencedAssemblies.ToArray ( ) );
cp.GenerateInMemory = true;
// Add using statements.
StringBuilder script = new StringBuilder ( );
foreach ( var usingNamespace in DEFAULT_NAMESPACES )
script.AppendFormat ( "using {0};\r\n", usingNamespace );
foreach ( var additionalUsingNamespace in UsingNamespaces )
script.AppendFormat ( "using {0};\r\n", additionalUsingNamespace );
// Create the script.
script.AppendLine ( );
script.AppendLine ( "namespace BlizzetaZero.Kernel.Scripts" );
script.AppendLine ( "{" );
script.AppendFormat ( "\t{0}", source );
script.AppendLine ( "}" );
Console.WriteLine ( script.ToString ( ) );
// Invoke compilation.
CompilerResults cr = provider.CompileAssemblyFromSource ( cp, script.ToString ( ) );
if ( cr.Errors.Count > 0 )
{
foreach ( CompilerError ce in cr.Errors )
{
#if DEBUG
Console.WriteLine ( "->\t{0}", ce.ToString ( ) );
Console.WriteLine ( );
#endif
ce.Line = ce.Line - 13;
compilationErrors.Add ( ce );
if ( !ce.IsWarning )
compilationSucceeded = false;
}
}
if ( compilationSucceeded )
{
var ass = cr.CompiledAssembly;
var execInstance = ass.CreateInstance ( "BlizzetaZero.Kernel.Scripts.Script" );
var type = execInstance.GetType ( );
var methodInfo = type.GetMethod ( "Load" );
// Execute the code.
methodInfo.Invoke ( execInstance, new object[] { context } );
}
return compilationErrors;
}