public override void Process(LOLMethod lm, CompilerErrorCollection errors, ILGenerator gen)
{
breakIdx = lm.breakables.Count - 1;
if (label == null)
{
while (breakIdx >= 0 && !lm.breakables[breakIdx].ContinueLabel.HasValue)
{
breakIdx--;
}
}
else
{
while (breakIdx >= 0 && (lm.breakables[breakIdx].Name != label || !lm.breakables[breakIdx].ContinueLabel.HasValue))
{
breakIdx--;
}
}
if (breakIdx < 0)
{
if (label == null)
{
errors.Add(new CompilerError(location.filename, location.startLine, location.startColumn, null, "MOAR encountered, but nothing to continue!"));
}
else
{
errors.Add(new CompilerError(location.filename, location.startLine, location.startColumn, null, string.Format("Named MOAR \"{0}\" encountered, but nothing by that name exists to continue!", label)));
}
}
}
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);
}
/// <summary>
/// Check to make sure that the blocks are in correct sequence i.e.
/// * no statements after the first classfeature block, and
/// * if the template contains a class block then it ends with a class block.
/// If not, log errors.
/// </summary>
private static void CheckBlockSequence(IList <Block> blocks, CompilerErrorCollection errors)
{
bool flag = false;
bool flag2 = false;
foreach (Block block2 in blocks)
{
if (!flag)
{
if (block2.Type == BlockType.ClassFeature)
{
flag = true;
}
}
else if (block2.Type == BlockType.Directive || block2.Type == BlockType.Statement)
{
CompilerError compilerError = new CompilerError(block2.FileName, block2.StartLineNumber, block2.StartColumnNumber, null, string.Format(CultureInfo.CurrentCulture, Resources.WrongBlockSequence, Enum.GetName(typeof(BlockType), block2.Type)));
compilerError.IsWarning = false;
errors.Add(compilerError);
flag2 = true;
}
}
if (flag && !flag2)
{
Block block = blocks[blocks.Count - 1];
if (block.Type != BlockType.ClassFeature && (block.Type != BlockType.BoilerPlate || !allNewlineRegex.Match(block.Text).Success))
{
CompilerError compilerError2 = new CompilerError(block.FileName, block.StartLineNumber, block.StartColumnNumber, null, Resources.WrongFinalBlockType);
compilerError2.IsWarning = false;
errors.Add(compilerError2);
}
}
}
public override void Process(LOLMethod lm, CompilerErrorCollection errors, ILGenerator gen)
{
m_breakLabel = gen.DefineLabel();
if (defaultCase != null)
{
defaultLabel = gen.DefineLabel();
}
Type t = null;
foreach (Case c in cases)
{
if (c.name.GetType() != t)
{
if (t != null)
{
errors.Add(new CompilerError(location.filename, location.startLine, location.startColumn, null, "A WTF statement cannot have OMGs with more than one type"));
break;
}
else
{
t = c.name.GetType();
}
}
}
if (t != typeof(int) && t != typeof(string))
{
errors.Add(new CompilerError(location.filename, location.startLine, location.startColumn, null, "OMG labels must be NUMBARs or YARNs"));
}
//Sort the cases
sortedCases = new Case[cases.Count];
cases.CopyTo(sortedCases);
Array.Sort <Case>(sortedCases);
//Check for duplicates
for (int i = 1; i < sortedCases.Length; i++)
{
if (sortedCases[i - 1].CompareTo(sortedCases[i]) == 0)
{
errors.Add(new CompilerError(location.filename, location.startLine, location.startColumn, null, string.Format("Duplicate OMG label: \"{0}\"", sortedCases[i].name)));
}
}
//Process child statements
lm.breakables.Add(this);
control.Process(lm, errors, gen);
foreach (Case c in cases)
{
c.statement.Process(lm, errors, gen);
}
defaultCase.Process(lm, errors, gen);
lm.breakables.RemoveAt(lm.breakables.Count - 1);
}
private bool BuildHashConfiguration(Block block)
{
_skip = false;
_applied = true;
if (!block.IsEmpty)
{
for (int i = 0; i < block.Statements.Count;)
{
var statement = block.Statements[i];
var expression = statement as ExpressionStatement;
if (expression == null)
{
_compileErrors.Add(CompilerErrorFactory.CustomError(
statement.LexicalInfo, "Unrecgonized configuration syntax"));
return(false);
}
_found = false;
Visit(expression.Expression);
if (_found == false)
{
_compileErrors.Add(CompilerErrorFactory.CustomError(
expression.LexicalInfo, "Unrecgonized configuration syntax"));
return(false);
}
if (_applied)
{
if (_skip == false)
{
block.Statements.RemoveAt(i);
}
else
{
++i;
}
}
else
{
return(false);
}
}
}
return(true);
}
private Assembly CompileAssembly(Node node, string url, CompilerErrorCollection errors)
{
CompilerContext result = Compile(url);
if (result.Errors.Count > 0)
{
errors.Add(new CompilerError(node.LexicalInfo, "Failed to add a file reference"));
foreach (CompilerError err in result.Errors)
{
errors.Add(err);
}
return(null);
}
return(result.GeneratedAssembly);
}
public CompilerErrorCollection TryCompileModule(dynamic moduleObject)
{
RequireSystemSigned();
CompilerErrorCollection compilerErrors = new CompilerErrorCollection();
Contract.Module module = ModuleManager.Session.Modules.Where(P => P.ID == moduleObject.ID).FirstOrDefault();
if (module != null && !module.Locked)
{
module = Contract.Module.FromString(module.ToString()); // Create a copy of the module
module.References = ((ThirdParty.JsonArray)moduleObject.References).Select(r => (string)r).ToList();
ModuleReversion moduleReversion = new ModuleReversion()
{
Version = module.LatestReversion.Version + 1, Updated = DateTime.UtcNow, Classes = new List <ModuleClass>()
};
moduleReversion.Classes = ((ThirdParty.JsonArray)moduleObject.LatestReversion.Classes).Select(p => new ModuleClass()
{
Name = ((dynamic)p).Name, Data = ((dynamic)p).Data
}).ToList();
module.LatestReversion = moduleReversion;
module.CompileClasses(out compilerErrors, false);
}
else
{
compilerErrors.Add(new CompilerError("", 0, 0, "", "Module is locked."));
}
return(compilerErrors);
}
public bool InitializeExtension(MethodInvocationExpression extension,
MacroStatement macro,
CompilerErrorCollection compileErrors)
{
_extension = extension;
_compileErrors = compileErrors;
if (macro.Body.IsEmpty)
{
if (macro.Arguments.Count != 1 ||
(ExtractMethod(macro.Arguments[0]) == false && _instanceAcessor == null))
{
_compileErrors.Add(CompilerErrorFactory.CustomError(macro.LexicalInfo,
"A createUsing statement must be in the form (@factory.<CreateMethod> | InstanceMethod)"));
return(false);
}
ConfigureFactoryAccessor();
}
else
{
ConfigureFactoryMethod(macro);
}
return(true);
}
private Expression CreateBuilderIfNeeded(MethodInvocationExpression child, string name)
{
int argsCount = child.Arguments.Count;
if (argsCount >= 1)
{
ReferenceExpression builder = child.Arguments[0] as ReferenceExpression;
if (builder != null)
{
Block block;
if (argsCount > 2 || (argsCount == 2 && !MacroHelper.IsNewBlock(child, out block)))
{
_compileErrors.Add(CompilerErrorFactory.CustomError(
child.Arguments[0].LexicalInfo,
"Builder syntax must be in the format builder, prop: value,..."));
return(null);
}
MethodInvocationExpression builderCtor = new MethodInvocationExpression(builder);
builderCtor.Arguments.Add(new StringLiteralExpression(name));
builderCtor.NamedArguments.Extend(child.NamedArguments);
return(builderCtor);
}
}
return(new StringLiteralExpression(name));
}
public CompilerError AddCompilerError()
{
var error = new CompilerError();
Errors.Add(error);
return(error);
}
private void LogError(bool isError, int line, int column, string token, string message)
{
var error = new CompilerError(m_filePath, line, column, token, message);
error.IsWarning = !isError;
m_errors.Add(error);
}
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 Process(LOLMethod lm, CompilerErrorCollection errors, ILGenerator gen)
{
if (arguments.Count != func.Arity && !func.IsVariadic)
{
errors.Add(new CompilerError(location.filename, location.startLine, location.startColumn, null, string.Format("Function \"{0}\" requires {1} arguments, passed {2}.", func.Name, func.Arity, arguments.Count)));
}
else if (arguments.Count < func.Arity && func.IsVariadic)
{
errors.Add(new CompilerError(location.filename, location.startLine, location.startColumn, null, string.Format("Function \"{0}\" requires at least {1} arguments, passed {2}.", func.Name, func.Arity, arguments.Count)));
}
foreach (Expression arg in arguments)
{
arg.Process(lm, errors, gen);
}
}
public bool InitializeExtension(MethodInvocationExpression extension,
MacroStatement macro,
CompilerErrorCollection compileErrors)
{
_extension = extension;
_compileErrors = compileErrors;
if (macro.Arguments.Count != 1 ||
(!ExtractMethod(macro.Arguments[0]) && _instanceAcessor == null))
{
_compileErrors.Add(CompilerErrorFactory.CustomError(macro.LexicalInfo,
"A createUsing statement must be in the form @factory.<CreateMethod>[()]"));
return(false);
}
if (_instanceAcessor == null)
{
_extension.Arguments.Add(Component);
_extension.Arguments.Add(Method);
}
else
{
_extension.Arguments.Add(_instanceAcessor);
}
return(true);
}
public CompilerErrorCollection UpdateModule(dynamic moduleObject)
{
RequireSystemSigned();
CompilerErrorCollection compilerErrors = new CompilerErrorCollection();
Contract.Module module = ModuleManager.Session.Modules.Where(P => P.ID == moduleObject.ID).FirstOrDefault();
if (module == null)
{
module = new Contract.Module()
{
ID = moduleObject.ID,
References = ((ThirdParty.JsonArray)moduleObject.References).Select(r => (string)r).ToList(),
};
ModuleReversion moduleReversion = new ModuleReversion()
{
Version = 1, Updated = DateTime.UtcNow, Classes = new List <ModuleClass>()
};
moduleReversion.Classes = ((ThirdParty.JsonArray)moduleObject.LatestReversion.Classes).Select(p => new ModuleClass()
{
Name = ((dynamic)p).Name, Data = ((dynamic)p).Data
}).ToList();
module.LatestReversion = moduleReversion;
ModuleManager.Session.AppendModuleReversion(module.ID, moduleReversion);
ModuleManager.Session.Modules.Add(module);
module.CompileClasses(out compilerErrors);
module.Save();
}
else if (!module.Locked)
{
module.References = ((ThirdParty.JsonArray)moduleObject.References).Select(r => (string)r).ToList();
ModuleReversion moduleReversion = new ModuleReversion()
{
Version = module.LatestReversion.Version + 1, Updated = DateTime.UtcNow, Classes = new List <ModuleClass>()
};
moduleReversion.Classes = ((ThirdParty.JsonArray)moduleObject.LatestReversion.Classes).Select(p => new ModuleClass()
{
Name = ((dynamic)p).Name, Data = ((dynamic)p).Data
}).ToList();
module.LatestReversion = moduleReversion;
ModuleManager.Session.AppendModuleReversion(module.ID, moduleReversion);
module.CompileClasses(out compilerErrors);
module.Save();
}
else
{
compilerErrors.Add(new CompilerError("", 0, 0, "", "Module is locked"));
}
return(compilerErrors);
}
CompilerError AddError(string message)
{
CompilerError err = new CompilerError();
err.Column = err.Line = -1;
err.ErrorText = message;
errors.Add(err);
return(err);
}
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);
}
}
/// <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 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);
}
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();
}
}
/// <summary>
/// Adds warnings to the error collection if unexpected unescaped start/end tags are found within the template
/// </summary>
private static void WarnAboutUnexpectedTags(IEnumerable <Block> blocks, CompilerErrorCollection errors)
{
foreach (Block block in blocks)
{
if (unescapedTagFindingRegex.Match(block.Text).Success)
{
CompilerError compilerError = new CompilerError(block.FileName, block.StartLineNumber, block.StartColumnNumber, null, Resources.UnexpectedTag);
compilerError.IsWarning = false;
errors.Add(compilerError);
}
}
}
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);
}
}
/// <summary>
/// Load a SFSchemaLanguage model
/// </summary>
/// <param name="store"></param>
/// <param name="inputFile"></param>
/// <returns></returns>
public static ISpySoft.SFSchemaLanguage.DomainModel.SchemaModel Load(CompilerErrorCollection errors, Store store, string inputFile)
{
if (errors == null)
{
throw new ArgumentNullException("errors");
}
if (store == null)
{
throw new ArgumentNullException("store");
}
if (inputFile == null)
{
throw new ArgumentNullException("inputFile");
}
using (System.IO.FileStream fileStream = File.OpenRead(inputFile))
{
// Get the set before we load the file
IList previousSet = store.ElementDirectory.GetElements(ISpySoft.SFSchemaLanguage.DomainModel.SchemaModel.MetaClassGuid);
try
{
using (Transaction t = store.TransactionManager.BeginTransaction("ProcessorLoad", true))
{
XmlSerialization.DeserializeStore(store, fileStream, 1, 1, SFSchemaLanguageFileLoader.UpgradeFileFormat, SFSchemaLanguageFileLoader.Deserialized);
t.Commit();
}
}
catch (Exception e)
{
errors.Add(new CompilerError(inputFile, -1, -1, "", e.ToString()));
}
IList candidates = store.ElementDirectory.GetElements(ISpySoft.SFSchemaLanguage.DomainModel.SchemaModel.MetaClassGuid);
// Remove the previous items from the new list, to leave just the newly added item
foreach (ISpySoft.SFSchemaLanguage.DomainModel.SchemaModel previous in previousSet)
{
if (previous != null)
{
candidates.Remove(previous);
}
}
foreach (ISpySoft.SFSchemaLanguage.DomainModel.SchemaModel candidate in candidates)
{
if (candidate != null)
{
return(candidate as ISpySoft.SFSchemaLanguage.DomainModel.SchemaModel);
}
}
}
return(null);
}
public bool GetNode(Expression expression, bool asAttribute,
CompilerErrorCollection compileErrors)
{
_isAttribute = asAttribute;
_compileErrors = compileErrors;
Visit(expression);
if (_node == null)
{
_compileErrors.Add(CompilerErrorFactory.CustomError(expression.LexicalInfo,
"Unrecgonized configuration node syntax"));
return(false);
}
return(true);
}
public static CompilerErrorCollection ParseOutput(string output)
{
using (var reader = new StringReader(output))
{
var errors = new CompilerErrorCollection();
string line;
while ((line = reader.ReadLine()) != null)
{
var err = ParseError(line);
if (err != null)
{
errors.Add(err);
}
}
return(errors);
}
}
public static CompilerErrorCollection Compile(string name, string outputPath, string[] references, string[] files, bool includePdb)
{
var pdbPath = Path.ChangeExtension(outputPath, "pdb");
var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithOptimizationLevel(OptimizationLevel.Debug) // currently no way to specify debug vs release. We still want pdb files with release mode for bug reports
.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
var parseOptions = new CSharpParseOptions(LanguageVersion.Latest);
var emitOptions = new EmitOptions();
if (Type.GetType("Mono.Runtime") != null)
{
emitOptions = emitOptions.WithDebugInformationFormat(DebugInformationFormat.PortablePdb);
}
var refs = references.Select(s => MetadataReference.CreateFromFile(s));
var src = files.Select(f => SyntaxFactory.ParseSyntaxTree(File.ReadAllText(f), parseOptions, f, Encoding.UTF8));
var comp = CSharpCompilation.Create(name, src, refs, options);
EmitResult results;
using (var peStream = File.OpenWrite(outputPath))
using (var pdbStream = includePdb ? File.OpenWrite(pdbPath) : null) {
results = comp.Emit(peStream, pdbStream, options: emitOptions);
}
var errors = new CompilerErrorCollection();
foreach (var d in results.Diagnostics.Where(d => d.Severity >= DiagnosticSeverity.Warning))
{
var loc = d.Location.GetLineSpan();
errors.Add(new CompilerError {
ErrorNumber = d.Id,
IsWarning = d.Severity == DiagnosticSeverity.Warning,
ErrorText = d.GetMessage(),
FileName = loc.Path ?? "",
Line = loc.StartLinePosition.Line,
Column = loc.StartLinePosition.Character
});
}
return(errors);
}
protected bool Compile(string outFile, string[] sourceFiles, params string[] references)
{
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.AddRange(references);
cp.GenerateExecutable = false;
cp.OutputAssembly = outFile;
cp.GenerateInMemory = false;
//生成调试文件
cp.IncludeDebugInformation = CompilerConfig.EnableDebug;
try
{
CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceFiles);
if (cr.Errors.Count > 0)
{
if (OnCompileFailed != null)
{
CompileException exp = new CompileException(sourceFiles, cr.PathToAssembly, cr.Errors);
OnCompileFailed(exp);
}
}
else
{
if (OnCompileSuccess != null)
{
OnCompileSuccess(sourceFiles, outFile);
}
}
return(cr.Errors.Count == 0);
}
catch (Exception e) {
if (OnCompileFailed != null)
{
CompilerErrorCollection t = new CompilerErrorCollection();
t.Add(new CompilerError()
{
ErrorText = e.Message
});
CompileException exp = new CompileException(sourceFiles, outFile, t);
OnCompileFailed(exp);
}
return(false);
}
}
public override void Process(LOLMethod lm, CompilerErrorCollection errors, ILGenerator gen)
{
if (operation != null)
{
FunctionRef fr = ((operation as AssignmentStatement).rval as FunctionExpression).func;
if (fr.Arity > 1 || (fr.IsVariadic && fr.Arity != 0))
{
errors.Add(new CompilerError(location.filename, location.startLine, location.startColumn, null, "Function used in loop must take 1 argument"));
}
}
m_breakLabel = gen.DefineLabel();
m_continueLabel = gen.DefineLabel();
lm.breakables.Add(this);
statements.Process(lm, errors, gen);
lm.breakables.RemoveAt(lm.breakables.Count - 1);
}
public void Constructor1_Deny_Unrestricted()
{
CompilerErrorCollection coll = new CompilerErrorCollection(array);
coll.CopyTo(array, 0);
Assert.AreEqual(1, coll.Add(ce), "Add");
Assert.AreSame(ce, coll[0], "this[int]");
coll[0] = ce;
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 = true;
Assert.IsFalse(coll.HasErrors, "HasErrors");
Assert.IsTrue(coll.HasWarnings, "HasWarnings");
}
private void LogError(string message, Location location, bool isWarning)
{
var err = new CompilerError();
err.ErrorText = message;
if (location.FileName != null)
{
err.Line = location.Line;
err.Column = location.Column;
err.FileName = location.FileName ?? string.Empty;
}
else
{
err.FileName = rootFileName ?? string.Empty;
}
err.IsWarning = isWarning;
errors.Add(err);
}