/// <summary>
/// This function is called on every recompilation to discard all previous results
/// </summary>
private void Reset()
{
_compilerErrorColl = null;
_outputSettings = null;
_qil = null;
_command = null;
}
public GenericConstructionChecker(TypeSystemServices tss, Node constructionNode, TypeReferenceCollection argumentNodes, CompilerErrorCollection errorCollection)
{
_tss = tss;
_constructionNode = constructionNode;
_argumentNodes = argumentNodes;
_errors = errorCollection;
}
public GenericConstructionChecker(TypeSystemServices tss, Node constructionNode, IType[] typeArguments, CompilerErrorCollection errorCollection)
{
_tss = tss;
_constructionNode = constructionNode;
_typeArguments = typeArguments;
_errors = errorCollection;
}
/// <summary>
/// Compiles a method body of C# script, wrapped in a basic void-returning method.
/// </summary>
/// <param name="methodText">The text of the script to place inside a method.</param>
/// <param name="errors">The compiler errors and warnings from compilation.</param>
/// <param name="methodIfSucceeded">The compiled method if compilation succeeded.</param>
/// <returns>True if compilation was a success, false otherwise.</returns>
public static bool CompileCSharpImmediateSnippet(string methodText, out CompilerErrorCollection errors, out MethodInfo methodIfSucceeded)
{
// wrapper text so we can compile a full type when given just the body of a method
string methodScriptWrapper = @"
using UnityEngine;
using UnityEditor;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Linq;
public static class CodeSnippetWrapper
{{
public static void PerformAction()
{{
{0};
}}
}}";
// default method to null
methodIfSucceeded = null;
// compile the full script
Assembly assembly;
if (CompileCSharpScript(string.Format(methodScriptWrapper, methodText), out errors, out assembly))
{
// if compilation succeeded, we can use reflection to get the method and pass that back to the user
methodIfSucceeded = assembly.GetType("CodeSnippetWrapper").GetMethod("PerformAction", BindingFlags.Static | BindingFlags.Public);
return true;
}
// compilation failed, caller has the errors, return false
return false;
}
private static void ThrowErrors(CompilerErrorCollection compilerErrorCollection)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError e in compilerErrorCollection)
{
sb.AppendLine(e.ErrorText);
}
throw new ProxyGenerationException("Compiler errors:\n" + sb.ToString());
}
/// <summary>
/// Compiles a C# script as if it were a file in your project.
/// </summary>
/// <param name="scriptText">The text of the script.</param>
/// <param name="errors">The compiler errors and warnings from compilation.</param>
/// <param name="assemblyIfSucceeded">The compiled assembly if compilation succeeded.</param>
/// <returns>True if compilation was a success, false otherwise.</returns>
public static bool CompileCSharpScript(string scriptText, out CompilerErrorCollection errors, out Assembly assemblyIfSucceeded)
{
var codeProvider = new CSharpCodeProvider();
var compilerOptions = new CompilerParameters();
// we want a DLL and we want it in memory
compilerOptions.GenerateExecutable = false;
compilerOptions.GenerateInMemory = true;
// add references to all currently loaded assemblies
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
compilerOptions.ReferencedAssemblies.Add(assembly.Location);
}
// default to null output parameters
errors = null;
assemblyIfSucceeded = null;
// compile the assembly from the source script text
CompilerResults result = codeProvider.CompileAssemblyFromSource(compilerOptions, scriptText);
// store the errors for the caller. even on successful compilation, we may have warnings.
errors = result.Errors;
// see if any errors are actually errors. if so return false
foreach (CompilerError e in errors)
{
if (!e.IsWarning)
{
return false;
}
}
// otherwise we pass back the compiled assembly and return true
assemblyIfSucceeded = result.CompiledAssembly;
return true;
}
public string[] GetCompileErrors()
{
CompilerErrorCollection errors = this.results.Errors;
int num = 0;
int num2 = 0;
foreach (CompilerError error in errors)
{
if (error.IsWarning)
{
num2++;
}
else
{
num++;
}
}
string[] strArray = new string[1 + (2 * num)];
strArray[0] = "COMPILE";
int num3 = 1;
foreach (CompilerError error2 in errors)
{
if (!error2.IsWarning)
{
strArray[num3++] = error2.ErrorText;
strArray[num3++] = error2.Line.ToString();
Console.WriteLine("Line {0}: {1}", strArray[num3 - 1], strArray[num3 - 2]);
}
else
{
Console.WriteLine("Warning: Line {0}: {1}", error2.Line.ToString(), error2.ErrorText);
}
}
return(strArray);
}
internal static void LogCompileErrors(CompilerErrorCollection errors)
{
Directory.CreateDirectory(LogPath);
string file = LogPath + Path.DirectorySeparatorChar + "Compile Errors.txt";
CompilerError displayError = null;
using (StreamWriter writer = File.CreateText(file))
{
foreach (CompilerError error in errors)
{
writer.WriteLine(error.ToString());
writer.WriteLine();
if (!error.IsWarning && displayError == null)
{
displayError = error;
}
}
}
string errorHeader = "An error ocurred while compiling a mod." + Environment.NewLine + Environment.NewLine;
Interface.errorMessage.SetMessage(errorHeader + displayError);
Interface.errorMessage.SetGotoMenu(Interface.modSourcesID);
Interface.errorMessage.SetFile(file);
}
/// <summary>
/// Creates the CompilerException instance from the specified compiler errors errors.
/// </summary>
/// <param name="Errors">The compiler errors.</param>
/// <param name="hideCompilerWarnings">if set to <c>true</c> hide compiler warnings.</param>
/// <returns></returns>
public static CompilerException Create(CompilerErrorCollection Errors, bool hideCompilerWarnings)
{
StringBuilder compileErr = new StringBuilder();
foreach (CompilerError err in Errors)
{
if (err.IsWarning && hideCompilerWarnings)
{
continue;
}
//compileErr.Append(err.ToString());
compileErr.Append(err.FileName);
compileErr.Append("(");
compileErr.Append(err.Line);
compileErr.Append(",");
compileErr.Append(err.Column);
compileErr.Append("): ");
if (err.IsWarning)
{
compileErr.Append("warning ");
}
else
{
compileErr.Append("error ");
}
compileErr.Append(err.ErrorNumber);
compileErr.Append(": ");
compileErr.Append(err.ErrorText);
compileErr.Append(Environment.NewLine);
}
CompilerException retval = new CompilerException(compileErr.ToString());
retval.Data.Add("Errors", Errors);
return(retval);
}
private void btnGenerateViews_Click(object sender, RoutedEventArgs e)
{
if (dataGridTables.SelectedItems.Count > 0)
{
CompilerErrorCollection errors = null;
foreach (DataRowView selectedItem in dataGridTables.SelectedItems)
{
errors = ProcessTemplate(@"C:\practice\T4TemplateDemo\T4TemplateDemo\SQLViews.tt", selectedItem.Row[1].ToString(), selectedItem.Row[2].ToString());
if (errors.HasErrors)
{
MessageBox.Show("Error occured while processing template", "Code Generator", MessageBoxButton.OK);
break;
}
}
if (errors != null && !errors.HasErrors)
{
MessageBox.Show("SQL Views Created!", "Code Generator", MessageBoxButton.OK);
}
}
else
{
MessageBox.Show("Please select atleast one table.", "Select table(s).", MessageBoxButton.OK);
}
}
/// <summary>
/// Compiles a C# script as if it were a file in your project.
/// </summary>
/// <param name="scriptText">The text of the script.</param>
/// <param name="errors">The compiler errors and warnings from compilation.</param>
/// <param name="assemblyIfSucceeded">The compiled assembly if compilation succeeded.</param>
/// <returns>True if compilation was a success, false otherwise.</returns>
public static bool CompileCSharpScript(string scriptText, out CompilerErrorCollection errors, out Assembly assemblyIfSucceeded)
{
var codeProvider = new CSharpCodeProvider();
var compilerOptions = new CompilerParameters();
// We want a DLL and we want it in memory
compilerOptions.GenerateExecutable = false;
compilerOptions.GenerateInMemory = true;
// Add references for UnityEngine and UnityEditor DLLs
compilerOptions.ReferencedAssemblies.Add(typeof(Vector2).Assembly.Location);
compilerOptions.ReferencedAssemblies.Add(typeof(EditorApplication).Assembly.Location);
// Default to null output parameters
errors = null;
assemblyIfSucceeded = null;
// Compile the assembly from the source script text
CompilerResults result = codeProvider.CompileAssemblyFromSource(compilerOptions, scriptText);
// Store the errors for the caller. even on successful compilation, we may have warnings.
errors = result.Errors;
// See if any errors are actually errors. if so return false
foreach (CompilerError e in errors)
{
if (!e.IsWarning)
{
return(false);
}
}
// Otherwise we pass back the compiled assembly and return true
assemblyIfSucceeded = result.CompiledAssembly;
return(true);
}
private ObservableCollection <Problem> method_18(CompilerErrorCollection compilerErrorCollection_0, int int_14)
{
ObservableCollection <Problem> observableCollection = new ObservableCollection <Problem>();
ObservableCollection <Problem> result;
foreach (CompilerError compilerError in compilerErrorCollection_0)
{
Problem problem = new Problem();
if (compilerError.ErrorText == "The name 'results' does not exist in the current context")
{
problem.Description = "All queries must be assigned to a variable named \"results\"";
problem.ProblemType = RuleStatus.CompileError;
observableCollection.Add(problem);
result = observableCollection;
return(result);
}
problem.Description = compilerError.ErrorText;
problem.LineNumber = new int?(compilerError.Line - int_14);
problem.ProblemType = RuleStatus.CompileError;
observableCollection.Add(problem);
}
result = observableCollection;
return(result);
}
internal static void LogCompileErrors(CompilerErrorCollection errors)
{
string errorHeader = "An error ocurred while compiling a mod." + Environment.NewLine + Environment.NewLine;
Console.WriteLine(errorHeader);
Directory.CreateDirectory(LogPath);
CompilerError displayError = null;
using (var writer = File.CreateText(CompileErrorPath))
{
foreach (CompilerError error in errors)
{
writer.WriteLine(error + Environment.NewLine);
Console.WriteLine(error);
if (!error.IsWarning && displayError == null)
{
displayError = error;
}
}
}
Interface.errorMessage.SetMessage(errorHeader + displayError);
Interface.errorMessage.SetGotoMenu(Interface.modSourcesID);
Interface.errorMessage.SetFile(CompileErrorPath);
}
/* convert shader-errors that come in the format of:
* c:\self.demos\tooll2\n\a(58,12): error X3004: undeclared identifier 'col2'
* c:\self.demos\tooll2\n\a(58,5): error X3080: 'PS': function must return a value
**/
protected CompilerErrorCollection ErrorsFromString(string errorString)
{
var errors = new CompilerErrorCollection();
var errorLinePattern = new Regex(@"\((\d+),(\d+)\): error\s*(\w+):\s*(.*?)\s*$");
foreach (var line in errorString.Split('\n'))
{
var matches = errorLinePattern.Matches(line);
if (matches.Count == 1)
{
var lineNumber = int.Parse(matches[0].Groups[1].Value);
var column = int.Parse(matches[0].Groups[2].Value);
string errorCode = matches[0].Groups[3].Value;
string errorMessage = matches[0].Groups[4].Value;
errors.Add(new CompilerError()
{
Column = column, ErrorNumber = errorCode, Line = lineNumber, ErrorText = errorMessage
});
}
}
return(errors);
}
private void SetUnitPriceExpression(string expression)
{
GridViewDataColumn unitPriceColumn = this.gridView.Columns["UnitPrice"];
UnitPriceConverter unitPriceConverter = unitPriceColumn.DataTypeConverter as UnitPriceConverter;
CompilerErrorCollection compilerErrors = unitPriceConverter.SetExpression(expression);
if (!compilerErrors.HasErrors)
{
changedColumn = unitPriceColumn;
return;
}
StringBuilder errorMessage = new StringBuilder();
foreach (CompilerError error in compilerErrors)
{
errorMessage.AppendLine(error.ErrorText);
}
if (errorMessage.Length > 0)
{
RadMessageBox.Show(errorMessage.ToString(), "Expression Syntax Error", MessageBoxButtons.OK, RadMessageIcon.Error);
}
}
private CompilerErrorCollection Errors(ICompilable item, bool sourceHeader)
{
CompilerErrorCollection err = new CompilerErrorCollection();
foreach (CompilerError e in item.CompilerResults.Errors) // deep copy error collection
{
err.Add(new CompilerError(e.FileName, e.Line, e.Column, e.ErrorNumber, e.ErrorText));
}
for (int i = 0; i < err.Count; i++) // adapt errors according to sourceHeader
{
if (err[i].Line < 0)
{
if (sourceHeader)
{
err[i].Line = ErrorLine(item, sourceHeader, err[i].Line);
}
}
else if (sourceHeader)
{
err.RemoveAt(i--); // don't mark ordinary errors in SourceHeader.
}
}
return(err);
}
/// <summary>
/// Starts processing run.
/// </summary>
/// <param name="languageProvider">Target language provider.</param>
/// <param name="templateContents">The contents of the template being processed</param>
/// <param name="errors">colelction to report processing errors in</param>
public override void StartProcessingRun(CodeDomProvider languageProvider, string templateContents, CompilerErrorCollection errors)
{
if (languageProvider == null)
{
throw new ArgumentNullException("languageProvider");
}
base.StartProcessingRun(languageProvider, templateContents, errors);
if (state != 0)
{
throw new InvalidOperationException(Resources.StartProcessingCallError);
}
state = ProcessorState.Started;
languageCodeDomProvider = languageProvider;
codeBuffer = new StringBuilder();
preInitializationBuffer = new StringBuilder();
postInitializationBuffer = new StringBuilder();
}
/// <summary>
/// Parse a template file into blocks. Each block is of type boilerplate, directive,
/// statement, classfeature or expression. Also puts position information (line/column
/// number) for the block into each block.
/// </summary>
/// <param name="content">Template content.</param>
/// <param name="fileName"></param>
/// <param name="errors">Error collection to report errors to.</param>
/// <returns>Name of template file.</returns>
public static List <Block> ParseTemplateIntoBlocks(string content, string fileName, CompilerErrorCollection errors)
{
if (content == null)
{
throw new ArgumentNullException("content");
}
if (fileName == null)
{
throw new ArgumentNullException("fileName");
}
if (errors == null)
{
throw new ArgumentNullException("errors");
}
List <Block> list = new List <Block>();
MatchCollection matchCollection = templateParsingRegex.Matches(content);
foreach (Match item in matchCollection)
{
Block block = new Block();
Group group;
if ((group = item.Groups["boilerplate"]).Success)
{
block.Type = BlockType.BoilerPlate;
}
else if ((group = item.Groups["directive"]).Success)
{
block.Type = BlockType.Directive;
}
else if ((group = item.Groups["classfeature"]).Success)
{
block.Type = BlockType.ClassFeature;
}
else if ((group = item.Groups["expression"]).Success)
{
block.Type = BlockType.Expression;
}
else if ((group = item.Groups["statement"]).Success)
{
block.Type = BlockType.Statement;
}
if (group != null && group.Success)
{
block.Text = group.Value;
block.FileName = fileName;
list.Add(block);
}
}
InsertPositionInformation(list);
WarnAboutUnexpectedTags(list, errors);
StripEscapeCharacters(list);
CheckBlockSequence(list, errors);
return(list);
}
/// <summary>
/// Parse a directive block for the directive name and param-value pairs
/// </summary>
/// <param name="block"></param>
/// <param name="errors"></param>
/// <returns></returns>
public static Directive ParseDirectiveBlock(Block block, CompilerErrorCollection errors)
{
if (block == null)
{
throw new ArgumentNullException("block");
}
if (errors == null)
{
throw new ArgumentNullException("errors");
}
if (!ValidateDirectiveString(block))
{
CompilerError compilerError = new CompilerError(block.FileName, block.StartLineNumber, block.StartColumnNumber, null, Resources.WrongDirectiveFormat);
compilerError.IsWarning = false;
errors.Add(compilerError);
return(null);
}
MatchCollection matchCollection = directiveParsingRegex.Matches(block.Text);
string text = null;
Dictionary <string, string> dictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (Match item in matchCollection)
{
Group group;
if ((group = item.Groups["name"]).Success)
{
text = group.Value;
}
else
{
string text2 = null;
string text3 = null;
if ((group = item.Groups["pname"]).Success)
{
text2 = group.Value;
}
if ((group = item.Groups["pvalue"]).Success)
{
text3 = group.Value;
}
if (text2 != null && text3 != null)
{
if (dictionary.ContainsKey(text2))
{
CompilerError compilerError2 = new CompilerError(block.FileName, block.StartLineNumber, block.StartColumnNumber, null, string.Format(CultureInfo.CurrentCulture, Resources.DuplicateDirectiveParameter, text2));
compilerError2.IsWarning = true;
errors.Add(compilerError2);
}
else
{
text3 = StripDirectiveEscapeCharacters(text3);
dictionary.Add(text2, text3);
}
}
}
}
if (text != null)
{
return(new Directive(text, dictionary, block));
}
return(null);
}
/// <summary>
/// Log the compilation errors.
/// </summary>
/// <param name="errors">The errors.</param>
public void LogErrors(CompilerErrorCollection errors)
{
_compilationErrors = errors;
}
protected virtual List <ValidationError> GetValidationErrorsFromCompilerErrors(CompilerErrorCollection compilerErrors)
{
var validationErrors = new List <ValidationError>();
if (compilerErrors == null)
{
return(validationErrors);
}
for (int i = 0; i < compilerErrors.Count; i++)
{
CompilerError compilerError = compilerErrors[i];
var error = ValidationError.CreateFromCompileError(compilerError);
validationErrors.Add(error);
}
return(validationErrors);
}
/// <summary>
/// 记录错误信息
/// The engine calls this method when it is done processing a text template to pass any errors that occurred to the host. The host can decide how to display them.
/// 该引擎调用完成时，处理文本模板通过任何错误发生的主机此方法。主机可以决定如何显示它们。
/// </summary>
/// <param name="errors"></param>
public void LogErrors(System.CodeDom.Compiler.CompilerErrorCollection errors)
{
_ErrorCollection = errors;
}
public Assembly CreateAssembly(IList filenames, IList references)
{
string fileType = null;
foreach (string filename in filenames)
{
string extension = Path.GetExtension(filename);
if (fileType == null)
{
fileType = extension;
}
else if (fileType != extension)
{
throw new ArgumentException("All files in the file list must be of the same type.");
}
}
compilerErrors = null;
CodeDomProvider codeProvider = null;
switch (fileType)
{
case ".cs":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case ".vb":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
default:
throw new InvalidOperationException("Script files must have a .cs, .vb, or .js extension, for C#, Visual Basic.NET, or JScript respectively.");
}
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.CompilerOptions = "/target:library /optimize";
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
compilerParams.IncludeDebugInformation = false;
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
foreach (string reference in references)
{
if (!compilerParams.ReferencedAssemblies.Contains(reference))
{
compilerParams.ReferencedAssemblies.Add(reference);
}
}
CompilerResults results = codeProvider.CompileAssemblyFromFile(
compilerParams, (string[])ArrayList.Adapter(filenames).ToArray(typeof(string)));
if (results.Errors.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError item in results.Errors)
{
sb.AppendFormat("{0} line:{1} {2}\r\n", item.FileName, item.Line, item.ErrorText);
}
compilerErrors = results.Errors;
throw new Exception(
"Compiler error(s)\r\n" + sb.ToString());
}
Assembly createdAssembly = results.CompiledAssembly;
return(createdAssembly);
}
/// <summary>
/// Checks whether a given set of arguments can be used to construct a generic type or method from a specified definition.
/// </summary>
public bool CheckGenericConstruction(Node node, IEntity definition, IType[] argumentTypes, CompilerErrorCollection errors)
{
GenericConstructionChecker checker = new GenericConstructionChecker(
TypeSystemServices, node, argumentTypes, Errors);
return !(
checker.NotGenericDefinition(definition) ||
checker.IncorrectGenerity(definition) ||
checker.ViolatesParameterConstraints(definition));
}
public void ReportErrors(CompilerErrorCollection targetErrorCollection)
{
targetErrorCollection.Extend(Errors);
}
public CompilationErrorsException(CompilerErrorCollection errors)
: base(errors.ToString())
{
_errors = errors;
}
/// <summary>
/// Checks whether a given set of arguments can be used to construct a generic type or method from a specified definition.
/// </summary>
public bool CheckGenericConstruction(IEntity definition, Node node, TypeReferenceCollection arguments, CompilerErrorCollection errors)
{
// Ensure definition is a valid entity
if (definition == null || TypeSystemServices.IsError(definition))
{
return false;
}
// Ensure definition really is a generic definition
GenericConstructionChecker checker = new GenericConstructionChecker(
TypeSystemServices, node, arguments, Errors);
return !(
checker.NotGenericDefinition(definition) ||
checker.IncorrectGenerity(definition) ||
checker.ViolatesParameterConstraints(definition));
}
public static void ConvertCodeSourceStreamToAssemblyFile(ArrayList outCodeStreamList, string assemblyPath, string strongNameFilename)
{
CompilerResults results = null;
string path = "__Sn.cs";
try
{
if (strongNameFilename != null)
{
if (assemblyPath != null)
{
int num = assemblyPath.LastIndexOf(@"\");
if (num > 0)
{
path = assemblyPath.Substring(0, num + 1) + path;
}
}
FileStream stream = new FileStream(path, FileMode.Create, FileAccess.ReadWrite);
StreamWriter writer = new StreamWriter(stream, new UTF8Encoding(false, true));
writer.WriteLine("// CLR Remoting Autogenerated Key file (to create a key file use: sn -k tmp.key)");
writer.WriteLine("using System;");
writer.WriteLine("using System.Reflection;");
writer.WriteLine("[assembly: AssemblyKeyFile(@\"" + strongNameFilename + "\")]");
writer.WriteLine("[assembly: AssemblyVersion(@\"1.0.0.1\")]");
writer.Flush();
writer.Close();
stream.Close();
outCodeStreamList.Add(path);
}
string[] sources = new string[outCodeStreamList.Count];
string[] strArray2 = new string[outCodeStreamList.Count];
int num2 = 0;
for (int i = 0; i < outCodeStreamList.Count; i++)
{
Stream stream2;
bool flag = false;
if (outCodeStreamList[i] is string)
{
string str2 = (string)outCodeStreamList[i];
strArray2[i] = str2;
stream2 = System.IO.File.OpenRead(str2);
flag = true;
}
else
{
if (!(outCodeStreamList[i] is Stream))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_UnknownObjectInCodeStreamList"));
}
stream2 = (Stream)outCodeStreamList[i];
strArray2[i] = "Stream" + num2++;
}
sources[i] = new StreamReader(stream2).ReadToEnd();
if (flag)
{
stream2.Close();
}
}
string outputName = assemblyPath;
string[] assemblyNames = new string[] { "System.dll", "System.Runtime.Remoting.dll", "System.Data.dll", "System.Xml.dll", "System.Web.Services.dll" };
if (sources.Length > 0)
{
CodeDomProvider provider = new CSharpCodeProvider();
CompilerParameters options = new CompilerParameters(assemblyNames, outputName, true)
{
GenerateExecutable = false
};
results = provider.CompileAssemblyFromSource(options, sources);
}
}
catch (Exception exception)
{
Console.WriteLine(exception.ToString());
}
finally
{
System.IO.File.Delete(path);
}
if (results.Errors.HasErrors)
{
CompilerErrorCollection errors = results.Errors;
if (errors.Count > 0)
{
foreach (CompilerError error in errors)
{
Console.WriteLine(error.ToString());
}
}
}
}
public CompilerErrorCollection(CompilerErrorCollection value) {}
/// <summary>
/// Preprocesses the input from <paramref name="input"/> and writes the output to <paramref name="output"/>
/// </summary>
/// <param name="input">The input source to preprocess</param>
/// <param name="output">The output target for the post-processed <paramref name="input"/></param>
/// <param name="args">The arguments to pass to the T4 code. Accessed through "Arguments" in the code. If null, an empty dictionary will be created</param>
/// <param name="lang">The language to use for the T4 code - defaults to C#</param>
public static void Preprocess(TextReader input, TextWriter output, IDictionary <string, object> args = null, string lang = "cs")
{
CompilerErrorCollection errors = null;
// TODO: Add error handling, even though output codegen errors shouldn't occur with this
var method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Static;
method.Name = "Preprocess";
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(TextWriter), "Response"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IDictionary <string, object>), "Arguments"));
int cur;
var more = true;
while (more)
{
var text = _ReadUntilStartContext(input);
if (0 < text.Length)
{
method.Statements.Add(new CodeMethodInvokeExpression(
new CodeArgumentReferenceExpression("Response"),
"Write",
new CodePrimitiveExpression(text)));
}
cur = input.Read();
if (-1 == cur)
{
more = false;
}
else if ('=' == cur)
{
method.Statements.Add(new CodeMethodInvokeExpression(
new CodeArgumentReferenceExpression("Response"),
"Write",
new CodeSnippetExpression(_ReadUntilEndContext(-1, input))));
}
else
{
method.Statements.Add(new CodeSnippetStatement(_ReadUntilEndContext(cur, input)));
}
}
method.Statements.Add(new CodeMethodInvokeExpression(new CodeArgumentReferenceExpression("Response"), "Flush"));
var cls = new CodeTypeDeclaration("Preprocessor");
cls.TypeAttributes = TypeAttributes.Public;
cls.IsClass = true;
cls.Members.Add(method);
var ns = new CodeNamespace();
ns.Types.Add(cls);
var cu = new CodeCompileUnit();
cu.Namespaces.Add(ns);
var prov = CodeDomProvider.CreateProvider(lang);
var opts = new CompilerParameters();
var outp = prov.CompileAssemblyFromDom(opts, cu);
if (outp.Errors.HasErrors)
{
var sb = new StringBuilder();
foreach (CompilerError err in outp.Errors)
{
if (!err.IsWarning)
{
sb.AppendLine(err.ErrorText);
}
}
throw new InvalidOperationException(sb.ToString());
}
var asm = outp.CompiledAssembly;
if (null == args)
{
args = new Dictionary <string, object>();
}
var ran = false;
if (null != asm)
{
var t = asm.GetType("Preprocessor");
var m = t.GetMethod("Preprocess");
if (null != m)
{
try
{
m.Invoke(null, new object[] { output, args });
ran = true;
}
catch (TargetInvocationException tex)
{
throw tex.InnerException;
}
}
}
if (!ran)
{
errors = outp.Errors;
if (0 < errors.Count)
{
CompilerError err = errors[0];
throw new InvalidOperationException(err.ErrorText);
}
}
}
public void AddRange(CompilerErrorCollection value) {}
public static void ConvertCodeSourceStreamToAssemblyFile(ArrayList outCodeStreamList, String assemblyPath, String strongNameFilename)
{
#if FEATURE_PAL
throw new NotImplementedException("Not Implemented in Rotor");
#else
Util.Log("MetaData.ConvertCodeSourceStreamToAssemblyFile " + assemblyPath);
CompilerResults results = null;
String stfilename = "__Sn.cs";
try
{
if (strongNameFilename != null)
{
// Create strong name file with assembly attribute
if (assemblyPath != null)
{
int index = assemblyPath.LastIndexOf("\\");
if (index > 0)
{
stfilename = assemblyPath.Substring(0, index + 1) + stfilename;
}
}
FileStream fs = new FileStream(stfilename, FileMode.Create, FileAccess.ReadWrite);
StreamWriter fsWriter = new StreamWriter(fs, new UTF8Encoding(false, true));
fsWriter.WriteLine("// CLR Remoting Autogenerated Key file (to create a key file use: sn -k tmp.key)");
fsWriter.WriteLine("using System;");
fsWriter.WriteLine("using System.Reflection;");
fsWriter.WriteLine("[assembly: AssemblyKeyFile(@\"" + strongNameFilename + "\")]");
fsWriter.WriteLine("[assembly: AssemblyVersion(@\"1.0.0.1\")]");
fsWriter.Flush();
fsWriter.Close();
fs.Close();
outCodeStreamList.Add(stfilename);
Util.Log("MetaData.ConvertCodeSourceStreamToAssemblyFile key file " + stfilename);
}
String[] sourceTexts = new String[outCodeStreamList.Count];
String[] sourceTextNames = new String[outCodeStreamList.Count];
int streamCount = 0; // used for naming sourceTexts streams
for (int item = 0; item < outCodeStreamList.Count; item++)
{
Stream inputStream;
bool close = false;
if (outCodeStreamList[item] is String)
{
// it's a file
String filename = (String)outCodeStreamList[item];
sourceTextNames[item] = (String)filename;
Util.Log("MetaData.ConvertCodeSourceStreamToAssemblyFile filename " + filename);
inputStream = File.OpenRead(filename);
close = true;
}
else if (outCodeStreamList[item] is Stream)
{
// it's a stream
inputStream = (Stream)outCodeStreamList[item];
sourceTextNames[item] = "Stream" + (streamCount++);
}
else
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_UnknownObjectInCodeStreamList"));
}
StreamReader streamReader = new StreamReader(inputStream);
sourceTexts[item] = streamReader.ReadToEnd();
if (true == close)
{
inputStream.Close();
}
}
String target = assemblyPath;
String[] imports = new String[5];
imports[0] = "System.dll";
imports[1] = "System.Runtime.Remoting.dll";
imports[2] = "System.Data.dll";
imports[3] = "System.Xml.dll";
imports[4] = "System.Web.Services.dll";
if (sourceTexts.Length > 0)
{
CodeDomProvider csharpCompiler = new CSharpCodeProvider();
CompilerParameters compileParams = new CompilerParameters(imports, target, true);
compileParams.GenerateExecutable = false; // target:library
results = csharpCompiler.CompileAssemblyFromSource(compileParams, sourceTexts);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
finally {
File.Delete(stfilename);
}
if (results.Errors.HasErrors)
{
CompilerErrorCollection errors = results.Errors;
if (errors.Count > 0)
{
foreach (CompilerError error in errors)
{
Console.WriteLine(error.ToString());
}
}
}
#endif //!FEATURE_PAL
}
public virtual void StartProcessingRun(CodeDomProvider languageProvider, string templateContents, CompilerErrorCollection errors)
{
if (languageProvider == null)
{
throw new ArgumentNullException("languageProvider");
}
}
public void LogErrors(CompilerErrorCollection errors)
{
this.errorCollection = errors;
}
/// <summary>
/// Begin a round of directive processing
/// </summary>
/// <param name="languageProvider"></param>
/// <param name="templateContents">the contents of the template being processed</param>\
/// <param name="errors">collection to report processing errors in</param>
public virtual void StartProcessingRun(CodeDomProvider languageProvider, string templateContents, CompilerErrorCollection errors)
{
Errors = errors;
}
public static RunResults CompilationFailed(CompilFailure reason, CompilerErrorCollection errors)
{
return(new RunResults(false, false, reason, errors));
}
internal ErrorTrap(ConverterSettings settings)
{
this.errors = settings.Errors;
this.fileName = settings.FileName;
}
public static List <Block> ParseTemplateIntoBlocks(string content, CompilerErrorCollection errors)
{
return(ParseTemplateIntoBlocks(content, "", errors));
}
//---------------------------------------------------------------
#endregion
//---------------------------------------------------------------
//---------------------------------------------------------------
#region Initialisation
//---------------------------------------------------------------
/// <summary>
/// scripting exception taking className and collection of CompilerErrors as parameters
/// </summary>
/// <param name="className">name of compiled class</param>
/// <param name="errors">collection of CompilerErrors</param>
public CompilerErrorException(string className, CompilerErrorCollection errors)
{
this.className = className;
this.errors = errors;
}
//The engine calls this method when it is done processing a text
//template to pass any errors that occurred to the host.
//The host can decide how to display them.
//---------------------------------------------------------------------
public void LogErrors(CompilerErrorCollection errors)
{
errorsValue = errors;
}
public override void StartProcessingRun(CodeDomProvider languageProvider, string templateContents, CompilerErrorCollection errors)
{
base.StartProcessingRun(languageProvider, templateContents, errors);
this.provider = languageProvider;
//HACK: Mono as of 2.10.2 doesn't implement GenerateCodeFromMember
if (Type.GetType("Mono.Runtime") != null)
{
useMonoHack = true;
}
if (languageProvider is Microsoft.CSharp.CSharpCodeProvider)
{
isCSharp = true;
}
postStatements.Clear();
members.Clear();
}
void ITextTemplatingEngineHost.LogErrors(CompilerErrorCollection errors)
{
this.errors.AddRange(errors);
}
private void CompileXsltToQil(object stylesheet, XsltSettings settings, XmlResolver stylesheetResolver)
{
_compilerErrorColl = new Compiler(settings, _enableDebug, null).Compile(stylesheet, stylesheetResolver, out _qil);
}
