public static void LoadXml(string xml, Action <string, InvocationDelegate> callback)
{
LoadXmlNode(xml, new Action <string, XmlNode>((name, node) =>
{
XmlExpressionReader reader = new XmlExpressionReader();
XmlNode firstChild = null;
foreach (XmlNode child in node.ChildNodes)
{
if (child.NodeType == XmlNodeType.Element)
{
firstChild = child;
break;
}
}
//convert xml node to expression
Expression expr = reader.Read(firstChild);
CompileContext compile = new CompileContext();
//compile expression
var eval = compile.Compile(expr);
callback(name, eval);
}));
}
internal CompileContext CreateCompileContext(string pattern)
{
var context = new CompileContext(pattern)
{
Options = Options.ToPatternOptions(),
JitCompileOptions = Options.ToJitCompileOptions()
};
if (_newLine != null && _newLine != PcreNewLine.Default)
{
context.NewLine = (NewLine)_newLine;
}
if (_backslashR != null && _backslashR != PcreBackslashR.Default)
{
context.BackslashR = (BackslashR)_backslashR;
}
if (_parensLimit != null)
{
context.ParensNestLimit = _parensLimit.Value;
}
return(context);
}
public override void Run(CompileContext c)
{
CompileErrors = new List<Error>();
Process = new Process();
if (Metadata.ReadOutput)
{
Process.StartInfo = new ProcessStartInfo
{
RedirectStandardOutput = true,
RedirectStandardInput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true
};
}
var args = GameConfigurationManager.SubstituteValues(GetParameterString(), c.MapFile); ;
Process.StartInfo.FileName = GameConfigurationManager.SubstituteValues(Metadata.Path);
Process.StartInfo.Arguments = string.Join(" ", args);
Process.StartInfo.WorkingDirectory = runningDirectory;
Process.Start();
Process.PriorityClass = ProcessPriorityClass.BelowNormal;
if (Metadata.ReadOutput)
readOutput();
}
public CompileResult Compile(string source, CompileContext context)
{
var sourceFile = context.RootDirectory.GetFile(context.SourceFilePath);
lock (_lock)
{
rootDirectory = sourceFile.Directory;
Initialize();
StartRecordingOpenedFiles();
try
{
var compilerOptions = GetCompilerOptions(sourceFile);
var css = (string)sassCompiler.compile(source, compilerOptions);
return new CompileResult(css, importedFilePaths);
}
catch (Exception e)
{
// Provide more information for SassSyntaxErrors
if (e.Message == "Sass::SyntaxError")
{
throw CreateSassSyntaxError(sourceFile, e);
}
else
{
throw;
}
}
finally
{
StopRecordingOpenedFiles();
}
}
}
public override void GenTyped(CompileContext compileContext)
{
JSType TreeType = this.TreeType;
((ExpressionNode)base.Children[0]).GenTyped(compileContext, TreeType);
((ExpressionNode)base.Children[1]).GenTyped(compileContext, TreeType);
this.GenTypedOp(compileContext);
}
public TypeSymbol GetTypeSymbolWithoutRedirect(ITypeSymbol type)
{
TypeSymbol typeSymbol = CompileContext.GetTypeSymbol(type, this);
OnSymbolRetrieved(typeSymbol);
return(typeSymbol);
}
public override Intermediate.IRNode Emit(CompileContext context, Model.Scope scope, Target target)
{
var r = new TransientNode();
if (_struct.size == 0) throw new InternalError("Struct size not yet determined");
r.AddInstruction(Instructions.SET, target.GetOperand(TargetUsage.Push),
Constant((ushort)_struct.size));
return r;
}
/// <summary>
/// Compiles the specified JavaScript file via Babel
/// </summary>
/// <param name="source">The source.</param>
/// <param name="context">The context.</param>
/// <returns>JavaScript</returns>
public CompileResult Compile(string source, CompileContext context)
{
var output = _environment.Babel.Transform(
source,
Path.GetFileName(context.SourceFilePath)
);
return new CompileResult(output, Enumerable.Empty<string>());
}
public override void Compile(CompileContext context)
{
foreach (Expression exp in ChildNodes)
{
exp.Compile(context);
}
context.ILGenerator.Emit(OpCodes.Newobj, _constructor);
}
public Symbol GetSymbolNoRedirect(ISymbol sourceSymbol)
{
Symbol symbol = CompileContext.GetSymbol(sourceSymbol, this);
OnSymbolRetrieved(symbol);
return(symbol);
}
/// <summary>
/// Create a compilation context.
/// </summary>
/// <param name="name">Unique key of the template</param>
/// <param name="scope">The template data.</param>
/// <param name="environment"></param>
/// <returns></returns>
private static CompileContext GenerateContext(this IHostEnvironment environment, string name, IVariableScope scope)
{
var ctx = new CompileContext(environment);
ctx.Name = name;
ctx.Data = scope ?? ctx.CreateVariableScope();
return(ctx);
}
public object ReadExpr(FSMContext context, XmlNode exprNode, bool isBlock)
{
CompileContext ctx = new CompileContext(new FSMExpressionContextAdapter(context));
var expr = exprReader.Read(exprNode, isBlock, ctx);
return(expr);
}
public static Neo.ASML.Node.ASMProject Compile(Microsoft.CodeAnalysis.SyntaxNode node)
{
var proj = new Neo.ASML.Node.ASMProject();
CompileContext context = new CompileContext();
CompileNode(context, proj, node);
return(proj);
}
internal override void GenLazyEval(CompileContext compileContext, Label lblTrue, Label lblFalse)
{
Label lblPartTwo = compileContext.gen.DefineLabel();
((ExpressionNode)base.Children[0]).GenLazyEval(compileContext, lblPartTwo, lblFalse);
compileContext.gen.MarkLabel(lblPartTwo);
((ExpressionNode)base.Children[1]).GenLazyEval(compileContext, lblTrue, lblFalse);
}
public override void Run(CompileContext context)
{
CompilePalLogger.LogLine("\nCompilePal - Nav Generator");
mapname = System.IO.Path.GetFileName(context.BSPFile).Replace(".bsp", "");
mapnav = context.CopyLocation.Replace(".bsp", ".nav");
mapcfg = context.Configuration.GameFolder + "/cfg/" + mapname + ".cfg";
mapCFGBackup = context.Configuration.GameFolder + "/cfg/" + mapname + "_cpalbackup.cfg";
hidden = GetParameterString().Contains("-hidden");
string args = "-game \"" + context.Configuration.GameFolder + "\" -windowed -novid -nosound +sv_cheats 1 +map " + mapname;
if (hidden)
{
args += " -noborder -x 4000 -y 2000";
}
var startInfo = new ProcessStartInfo(context.Configuration.GameEXE, args);
startInfo.UseShellExecute = false;
startInfo.CreateNoWindow = false;
CompilePalLogger.LogLine("Generating...");
if (File.Exists(mapcfg))
{
if (File.Exists(mapCFGBackup))
{
System.IO.File.Delete(mapCFGBackup);
}
System.IO.File.Move(mapcfg, mapCFGBackup);
}
System.IO.File.Create(mapcfg).Dispose();
TextWriter tw = new StreamWriter(mapcfg);
tw.WriteLine("nav_generate");
tw.Close();
Process = new Process {
StartInfo = startInfo
};
Process.Start();
FileSystemWatcher fw = new FileSystemWatcher();
fw.Path = System.IO.Path.GetDirectoryName(mapnav);
fw.Filter = "*.nav";
fw.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
fw.Changed += new FileSystemEventHandler(fileSystemWatcher_NavCreated);
fw.Created += new FileSystemEventHandler(fileSystemWatcher_NavCreated);
fw.EnableRaisingEvents = true;
Process.WaitForExit();
fw.Dispose();
cleanUp();
CompilePalLogger.LogLine("nav file complete!");
}
public override void Compile(CompileContext context)
{
if (Expression is StringExpression stringExpression)
{
context.AddWarning(this, $"This string is unused, did you mean to call 'say \"{stringExpression}\"'");
}
Expression.Compile(context);
}
internal void GenCreate(CompileContext compileContext)
{
for (int i = 0; i < this.varNames.Length; i++)
{
compileContext.gen.Emit(OpCodes.Ldarg_0);
compileContext.gen.Emit(OpCodes.Ldstr, this.varNames[i]);
compileContext.gen.EmitCallV(CompileContext.mi_CreateMutableBinding);
}
}
public override void GenTyped(CompileContext compileContext)
{
((ExpressionNode)base.Children[0]).GenTyped(compileContext, JSType.Number);
compileContext.gen.EmitCallV(CompileContext.fnc_Utilities_JSToInt32);
((ExpressionNode)base.Children[1]).GenTyped(compileContext, JSType.Number);
compileContext.gen.EmitCallV(CompileContext.fnc_Utilities_JSToInt32);
compileContext.gen.Emit(this._op);
compileContext.gen.Emit(OpCodes.Conv_R8);
}
/// <summary>
/// Compiles the specified JavaScript file via Babel
/// </summary>
/// <param name="source">The source.</param>
/// <param name="context">The context.</param>
/// <returns>JavaScript</returns>
public CompileResult Compile(string source, CompileContext context)
{
var output = _environment.Babel.Transform(
source,
Path.GetFileName(context.SourceFilePath)
);
return(new CompileResult(output, Enumerable.Empty <string>()));
}
public TypeSymbol GetTypeSymbol(SpecialType type)
{
TypeSymbol typeSymbol = CompileContext.GetTypeSymbol(type, this);
typeSymbol = (TypeSymbol)RedirectTypeSymbol(typeSymbol);
OnSymbolRetrieved(typeSymbol);
return(typeSymbol);
}
void processImport(CompileContext ctx, Value s, Env env)
{
for (Value codeCons = s.Cdr; !codeCons.IsNil; codeCons = codeCons.Cdr)
{
var code = codeCons.Car;
var importSet = parseImportSet(code);
importSet.Module.ImportToEnv(env, importSet);
}
}
protected override void EmitClassDefinition(CodeWriter writer, CompileContext context)
{
string attribute = $"[FlatBufferStruct]";
writer.AppendSummaryComment(this.Documentation);
writer.AppendLine(attribute);
writer.AppendLine("[System.Runtime.CompilerServices.CompilerGenerated]");
writer.AppendLine($"public partial class {this.Name}");
}
//===================================================================
// define-library
//===================================================================
void processDefineLibrary(CompileContext ctx, Value s)
{
Value _, moduleNameList, rest;
Value.Bind2Rest(s, out _, out moduleNameList, out rest);
string moduleName = Module.GetModuleName(moduleNameList);
var module = new Module(moduleName);
var env = new Env(null);
for (Value codeCons = rest; !codeCons.IsNil; codeCons = codeCons.Cdr)
{
var code = codeCons.Car;
switch (code.Car.AsSymbol.ToString())
{
case "import":
{
processImport(ctx, code, env);
}
break;
case "export":
{
for (Value sym = code.Cdr; !sym.IsNil; sym = sym.Cdr)
{
module.Export(sym.Car.AsSymbol);
}
}
break;
case "include":
case "include-ci":
break;
case "begin":
{
var compiler = new Compiler(vm_, env);
for (Value c = code.Cdr; !c.IsNil; c = c.Cdr)
{
var lmd = compiler.Compile(c.Car);
var closure = new Closure(lmd, env);
var result = vm_.Eval.Run(closure);
}
}
break;
default:
throw new LispException($"Invalid define-library command {code}");
}
}
module.ExportFromEnv(env);
vm_.Modules[moduleName] = module;
}
internal override void GenStatementCode(CompileContext compileContext, bool bGenDebug)
{
Label lblTop = compileContext.gen.DefineLabel();
Label lblCond = base.continuedest = compileContext.gen.DefineLabel();
compileContext.gen.MarkLabel(lblTop);
((StatementNode)base.Children[0]).GenCode(compileContext);
compileContext.gen.MarkLabel(lblCond);
((ExpressionNode)base.Children[1]).GenLazyEval(compileContext, lblTop, base.breakdest);
}
private IEvaluator CreateEvaluator(Type type, MethodInfo execute, CompileContext compileContext)
{
var instance = CreateInstance(type, compileContext);
var ins = Expression.Parameter(typeof(object), "proxy");
var state = Expression.Parameter(typeof(object), "state");
var callExecute = Expression.Call(Expression.Convert(ins, type), execute, state);
var func = Expression.Lambda <Func <object, object, object> >(callExecute, "Evaluate", new[] { ins, state }).Compile();
return(compileContext.Cacheable ? (IEvaluator) new CachableEvaluator(instance, func) : new Evaluator(instance, func));
}
public override void GenTyped(CompileContext compileContext)
{
LocalBuilder l = compileContext.gen.DeclareLocal(typeof(string));
((ExpressionNode)base.Children[0]).GenTyped(compileContext, JSType.String);
compileContext.gen.Emit(OpCodes.Stloc, l.LocalIndex);
((ExpressionNode)base.Children[1]).GenCode(compileContext);
compileContext.gen.Emit(OpCodes.Ldloc, l.LocalIndex);
compileContext.gen.EmitCallV(CompileContext.mi_JSValue_HasProperty_in);
}
internal override void GenStatementCode(CompileContext compileContext, bool bGenDebug)
{
if (this.ChildCount != 0)
{
foreach (StatementNode n in base.Children)
{
n.GenCode(compileContext);
}
}
}
private static bool Compile <TModel>(CompileContext compileContext, string templatePath, Options options, Result result)
{
DateTime startTime = DateTime.Now;
if (options.DiagnosticLevel == DiagnosticLevel.Diagnostics)
{
foreach (var reference in compileContext.MetadataReferenceManager.References)
{
result.AddDiagnostic(new Diagnostic(DiagnosticSeverity.Info, Result.Sources.Compiler, "Diagnostic", $"Referencing assembly: {reference.Display}", -1, -1));
}
}
string templateName = MakeTemplateName(options, templatePath);
string assemblyPath = MakeAssemblyPath(options, templateName);
var referenceManager = compileContext.MetadataReferenceManager;
CSharpCompilationOptions compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
CSharpCompilation compilation = CSharpCompilation.Create(templateName)
.AddReferences(referenceManager.References)
.AddSyntaxTrees(compileContext.CompilationUnit.SyntaxTree)
.WithOptions(compilationOptions);
try
{
var emitResult = compilation.Emit(assemblyPath);
DateTime compileTime = DateTime.Now;
result.CompileTime = compileTime - startTime;
foreach (var diagnostic in emitResult.Diagnostics)
{
var location = diagnostic.Location.GetMappedLineSpan();
switch (diagnostic.Severity)
{
case Microsoft.CodeAnalysis.DiagnosticSeverity.Error:
result.AddDiagnostic(new Diagnostic(DiagnosticSeverity.Error, Result.Sources.Roslyn, "error", diagnostic.GetMessage(), location.StartLinePosition.Line + 1, -1));
break;
case Microsoft.CodeAnalysis.DiagnosticSeverity.Warning:
result.AddDiagnostic(new Diagnostic(DiagnosticSeverity.Warning, Result.Sources.Roslyn, "warning", diagnostic.GetMessage(), location.StartLinePosition.Line + 1, -1));
break;
case Microsoft.CodeAnalysis.DiagnosticSeverity.Info:
result.AddDiagnostic(new Diagnostic(DiagnosticSeverity.Info, Result.Sources.Roslyn, "info", diagnostic.GetMessage(), location.StartLinePosition.Line + 1, -1));
break;
}
}
return(emitResult.Success);
}
catch (Exception e)
{
result.AddDiagnostic(new Diagnostic(DiagnosticSeverity.Error, Result.Sources.Roslyn, "emit", e.Message));
return(false);
}
}
public override void Run(CompileContext context)
{
vbspInfo = context.Configuration.VBSPInfo;
bspFile = context.CopyLocation;
CompileErrors = new List <Error>();
try
{
CompilePalLogger.LogLine("\nCompilePalMulti - Cubemap Generator");
if (!File.Exists(context.CopyLocation))
{
throw new FileNotFoundException();
}
hidden = GetParameterString().Contains("-hidden");
FetchHDRLevels();
string mapname = System.IO.Path.GetFileName(context.CopyLocation).Replace(".bsp", "");
string args = "-steam -game \"" + context.Configuration.GameFolder + "\" -windowed -novid -nosound +mat_specular 0 %HDRevel% +map " + mapname + " -buildcubemaps";
if (hidden)
{
args += " -noborder -x 4000 -y 2000";
}
if (HDR && LDR)
{
CompilePalLogger.LogLine("Map requires two sets of cubemaps");
CompilePalLogger.LogLine("Compiling LDR cubemaps...");
RunCubemaps(context.Configuration.GameEXE, args.Replace("%HDRevel%", "+mat_hdr_level 0"));
CompilePalLogger.LogLine("Compiling HDR cubemaps...");
RunCubemaps(context.Configuration.GameEXE, args.Replace("%HDRevel%", "+mat_hdr_level 2"));
}
else
{
CompilePalLogger.LogLine("Map requires one set of cubemaps");
CompilePalLogger.LogLine("Compiling cubemaps...");
RunCubemaps(context.Configuration.GameEXE, args.Replace("%HDRevel%", ""));
}
CompilePalLogger.LogLine("Cubemaps compiled");
}
catch (FileNotFoundException)
{
CompilePalLogger.LogCompileError($"Could not find file: {context.CopyLocation}", new Error($"Could not find file: {context.CopyLocation}", ErrorSeverity.Error));
}
catch (Exception exception)
{
CompilePalLogger.LogLine("Something broke:");
CompilePalLogger.LogCompileError($"{exception}\n", new Error(exception.ToString(), "CompilePalMulti Internal Error", ErrorSeverity.FatalError));
}
}
public override void GatherSymbols(CompileContext context, Model.Scope enclosingScope)
{
base.GatherSymbols(context, enclosingScope);
staticLabel = Intermediate.Label.Make("_STRING");
var data = new List<Intermediate.Operand>();
data.Add(Constant((ushort)value.Length));
foreach (var c in value)
data.Add(Constant((ushort)c));
context.AddData(staticLabel, data);
}
public Symbol GetSymbol(ISymbol sourceSymbol)
{
Symbol symbol = CompileContext.GetSymbol(sourceSymbol, this);
symbol = RedirectTypeSymbol(symbol);
symbol = RedirectParameterSymbol(symbol);
symbol = RedirectMethodSymbol(symbol);
OnSymbolRetrieved(symbol);
return(symbol);
}
public void Run(CompileContext context)
{
var settings = new BinaryWriter.BinaryWriterSettings();
if (context.Options.CertificateThumbprint != null)
settings.Certificate = FindCertificate(context.Options.CertificateThumbprint);
var writer = new BinaryWriter(context.Output, settings);
writer.Descriptions.Add(context.Description);
writer.Write();
}
internal override int?OnDetermineDecimalPlaces(CompileContext context)
{
// Return at least the default number of decimal places.
int?suggested = base.OnDetermineDecimalPlaces(context);
int defaultDp = context.GetDecimalPlaces(ResultType);
int result = Math.Max(suggested ?? defaultDp, defaultDp);
return(result);
}
/// <summary>
/// Copies a range of elements from an <see cref="TemplateContext"/> starting at the first element and pastes them into another <see cref="CompileContext"/> starting at the first element.
/// </summary>
/// <param name="ctx1">The <see cref="TemplateContext"/> that contains the data to copy.</param>
/// <param name="ctx2">The <see cref="CompileContext"/> that receives the data.</param>
public static void CopyTo(this TemplateContext ctx1, CompileContext ctx2)
{
if (ctx1 != null && ctx2 != null)
{
ctx2.Data = ctx1.TempData;
ctx2.CurrentPath = ctx1.CurrentPath;
ctx2.Charset = ctx1.Charset;
ctx2.StripWhiteSpace = ctx1.StripWhiteSpace;
ctx2.ThrowExceptions = ctx1.ThrowExceptions;
}
}
public override Intermediate.IRNode Emit(CompileContext context, Model.Scope scope, Target target)
{
Model.Label destination = null;
foreach (var _label in scope.activeFunction.function.labels)
if (_label.declaredName == label) destination = _label;
if (destination == null) context.ReportError(this, "Unknown label - " + label);
var r = new StatementNode();
if (destination != null)
r.AddInstruction(Instructions.SET, Operand("PC"), Label(destination.realName));
return r;
}
internal override void GenStatementCode(CompileContext compileContext, bool bGenDebug)
{
if (bGenDebug)
{
base.GenDebugWrap(compileContext, new Action <CompileContext>(this.GenStatementCode));
}
else
{
this.GenStatementCode(compileContext);
}
}
internal void GenTyped(CompileContext compileContext, JSType aJType)
{
if (this.TreeType == aJType)
{
this.GenTyped(compileContext);
}
else
{
this.GenTypedBase(compileContext, aJType);
}
}
public SassCompiler_Tests()
{
directory = new Mock<IDirectory>();
file = new Mock<IFile>();
directory.Setup(d => d.GetFile(It.IsAny<string>())).Returns(new NonExistentFile("~"));
directory.Setup(d => d.GetFile("~/test.scss")).Returns(file.Object);
file.SetupGet(f => f.FullPath).Returns("~/test.scss");
file.SetupGet(f => f.Directory).Returns(directory.Object);
compileContext = new CompileContext { RootDirectory = directory.Object, SourceFilePath = "~/test.scss" };
compiler = new SassCompiler();
}
public override void Run(CompileContext context)
{
vbspInfo = context.Configuration.VBSPInfo;
bspFile = context.CopyLocation;
try
{
CompilePalLogger.LogLine("\nCompilePal - Cubemap Generator");
if (!File.Exists(context.CopyLocation))
{
throw new FileNotFoundException();
}
hidden = GetParameterString().Contains("-hidden");
FetchHDRLevels();
string mapname = System.IO.Path.GetFileName(context.CopyLocation).Replace(".bsp", "");
string args = "-game \"" + context.Configuration.GameFolder + "\" -windowed -novid -nosound +mat_specular 0 %HDRevel% +map " + mapname + " -buildcubemaps";
if (hidden)
args += " -noborder -x 4000 -y 2000";
if (HDR && LDR)
{
CompilePalLogger.LogLine("Map requires two sets of cubemaps");
CompilePalLogger.LogLine("Compiling LDR cubemaps...");
RunCubemaps(context.Configuration.GameEXE, args.Replace("%HDRevel%", "+mat_hdr_level 0"));
CompilePalLogger.LogLine("Compiling HDR cubemaps...");
RunCubemaps(context.Configuration.GameEXE, args.Replace("%HDRevel%", "+mat_hdr_level 2"));
}
else
{
CompilePalLogger.LogLine("Map requires one set of cubemaps");
CompilePalLogger.LogLine("Compiling cubemaps...");
RunCubemaps(context.Configuration.GameEXE, args.Replace("%HDRevel%", ""));
}
CompilePalLogger.LogLine("Cubemaps compiled");
}
catch (FileNotFoundException)
{
CompilePalLogger.LogLine("FAILED - Could not find " + context.CopyLocation);
}
catch (Exception exception)
{
CompilePalLogger.LogLine("Something broke:");
CompilePalLogger.LogLine(exception.ToString());
}
}
public override Intermediate.IRNode Emit(CompileContext context, Model.Scope scope, Target target)
{
var r = new StatementNode();
r.AddChild(new Annotation(context.GetSourceSpan(this.Span)));
if (ChildNodes.Count > 0)
{
r.AddChild(Child(0).Emit(context, scope, Target.Stack));
r.AddInstruction(Instructions.SET, Operand("A"), Operand("POP"));
}
r.AddChild(scope.activeFunction.CompileReturn(context, scope));
return r;
}
public override Intermediate.IRNode Emit(CompileContext context, Model.Scope scope, Target target)
{
var r = new StatementNode();
r.AddChild(new Annotation(context.GetSourceSpan(this.Span)));
var fetch_token = Child(1).GetFetchToken();
if (fetch_token == null)
{
var rTarget = Target.Register(context.AllocateRegister());
r.AddChild(Child(1).Emit(context, scope, rTarget));
fetch_token = rTarget.GetOperand(TargetUsage.Pop);
}
r.AddChild((Child(0) as AssignableNode).EmitAssignment(context, scope, fetch_token, opcodes[@operator]));
return r;
}
public CompileResult Compile(string source, CompileContext context)
{
Trace.Source.TraceInformation("Compiling {0}", context.SourceFilePath);
var workItem = compilationQueue.EnqueueCompilation(source);
try
{
var javascript = workItem.AwaitResult();
return new CompileResult(javascript, Enumerable.Empty<string>());
}
catch (Exception ex)
{
var message = ex.Message + " in " + context.SourceFilePath;
Trace.Source.TraceEvent(TraceEventType.Critical, 0, message);
throw new CoffeeScriptCompileException(message, context.SourceFilePath, ex);
}
}
public void Run(CompileContext context)
{
XmlLoader loader = new XmlLoader();
loader.Load(context.Input);
context.Errors.AddRange(loader.LoadErrors.Select(e => new CompileError(e)));
if (loader.LoadErrors.Count(e => e.Category == LoadErrorCategory.Error) > 0)
return;
var description = loader.GetDescriptions()[0];
// The component XML format doesn't provide an ID, so make one now
description.ID = "C0";
context.Description = description;
}
public CompileResult Compile(string source, CompileContext context)
{
var sourceFile = context.RootDirectory.GetFile(context.SourceFilePath);
importedFilePaths = new HashedSet<string>();
var parser = new Parser
{
Importer = new Importer(new CassetteLessFileReader(sourceFile.Directory, importedFilePaths))
};
var errorLogger = new ErrorLogger();
var engine = new LessEngine(
parser,
errorLogger,
configuration.MinifyOutput,
configuration.Debug,
configuration.DisableVariableRedefines,
configuration.DisableColorCompression,
configuration.KeepFirstSpecialComment,
configuration.Plugins);
string css;
try
{
css = engine.TransformToCss(source, sourceFile.FullPath);
}
catch (Exception ex)
{
throw new LessCompileException(
string.Format("Error compiling {0}{1}{2}", context.SourceFilePath, Environment.NewLine, ex.Message),
ex
);
}
if (errorLogger.HasErrors)
{
var exceptionMessage = string.Format(
"Error compiling {0}{1}{2}",
context.SourceFilePath,
Environment.NewLine,
errorLogger.ErrorMessage
);
throw new LessCompileException(exceptionMessage);
}
else
{
return new CompileResult(css, importedFilePaths);
}
}
Intermediate.IRNode AssignableNode.EmitAssignment(CompileContext context, Model.Scope scope, Intermediate.Operand from, Intermediate.Instructions opcode)
{
var r = new TransientNode();
if (member == null)
{
context.ReportError(this, "Member was not resolved");
return r;
}
var target = Target.Register(context.AllocateRegister());
r.AddChild(Child(0).Emit(context, scope, target));
r.AddInstruction(opcode, target.GetOperand(TargetUsage.Peek,
Intermediate.OperandSemantics.Dereference | Intermediate.OperandSemantics.Offset, (ushort)member.offset),
from);
return r;
}
public override void Run(CompileContext context)
{
// don't run unless it's the last map of the queue
if (CompilingManager.MapFiles.Last() == context.MapFile)
{
CompilePalLogger.LogLine("\nCompilePal - Shutdown");
CompilePalLogger.LogLine("The system will shutdown soon.");
CompilePalLogger.LogLine("You can cancel this shutdown by using the command \"shutdown -a\"");
var startInfo = new ProcessStartInfo("shutdown", GetParameterString());
startInfo.UseShellExecute = false;
startInfo.CreateNoWindow = true;
Process = new Process { StartInfo = startInfo };
Process.Start();
}
}
public override void ResolveTypes(CompileContext context, Model.Scope enclosingScope)
{
_struct = enclosingScope.FindType(typeName);
if (_struct == null)
{
CachedFetchToken = Constant(0);
context.ReportError(this, "Could not find type " + typeName);
}
else if (_struct.size == 0)
{
throw new InternalError("Struct size must be determined before types are resolved.");
}
else
CachedFetchToken = Constant((ushort)_struct.size);
ResultType = "word";
}
public CompileResult Compile(string coffeeScriptSource, CompileContext context)
{
Trace.Source.TraceInformation("Compiling {0}", context.SourceFilePath);
lock (ScriptEngine) // ScriptEngine is NOT thread-safe, so we MUST lock.
{
try
{
Trace.Source.TraceInformation("Compiled {0}", context.SourceFilePath);
var javascript = ScriptEngine.CallGlobalFunction<string>("compile", coffeeScriptSource);
return new CompileResult(javascript, Enumerable.Empty<string>());
}
catch (Exception ex)
{
var message = ex.Message + " in " + context.SourceFilePath;
Trace.Source.TraceEvent(TraceEventType.Critical, 0, message);
throw new CoffeeScriptCompileException(message, context.SourceFilePath, ex);
}
}
}
public override void ResolveTypes(CompileContext context, Model.Scope enclosingScope)
{
_struct = enclosingScope.FindType(typeName);
if (_struct == null)
{
context.ReportError(this, "Could not find type " + typeName);
CachedFetchToken = Constant(0);
}
else
{
var memberIndex = _struct.members.FindIndex(m => m.name == memberName);
if (memberIndex < 0)
{
context.ReportError(this, "Member not found : " + memberName);
CachedFetchToken = Constant(0);
}
else
CachedFetchToken = Constant((ushort)memberIndex);
}
ResultType = "word";
}
public override Intermediate.IRNode Emit(CompileContext context, Model.Scope scope, Target target)
{
var r = new TransientNode();
if (member == null)
{
context.ReportError(this, "Member was not resolved.");
return r;
}
Target objectTarget = target;
if (target.target == Targets.Stack)
objectTarget = Target.Register(context.AllocateRegister());
r.AddChild(Child(0).Emit(context, scope, objectTarget));
if (member.isArray)
{
if (target != objectTarget)
r.AddInstruction(Instructions.SET, target.GetOperand(TargetUsage.Push), objectTarget.GetOperand(TargetUsage.Pop));
r.AddInstruction(Instructions.ADD, target.GetOperand(TargetUsage.Peek), Constant((ushort)member.offset));
}
else
{
if (member.offset == 0)
r.AddInstruction(Instructions.SET,
target.GetOperand(TargetUsage.Push),
objectTarget.GetOperand(TargetUsage.Pop, Intermediate.OperandSemantics.Dereference));
else
r.AddInstruction(Instructions.SET,
target.GetOperand(TargetUsage.Push),
objectTarget.GetOperand(TargetUsage.Pop,
Intermediate.OperandSemantics.Dereference | Intermediate.OperandSemantics.Offset,
(ushort)member.offset));
}
return r;
}
public EvaluatePropertiesPhase(CompileContext compileContext, bool withDebug)
: this(compileContext)
{
_withDebug = withDebug;
}
public override Intermediate.IRNode Emit(CompileContext context, Model.Scope scope, Target target)
{
return new Intermediate.Annotation("Declaration of function " + function.name);
}
public EvaluatePropertiesPhase(CompileContext compileContext)
{
_compileContext = compileContext;
}
/// <summary>
/// Compiles the specified JSX file into JavaScript
/// </summary>
/// <param name="source">The source.</param>
/// <param name="context">The context.</param>
/// <returns>JavaScript</returns>
public CompileResult Compile(string source, CompileContext context)
{
var output = _environment.JsxTransformer.TransformJsx(source);
return new CompileResult(output, Enumerable.Empty<string>());
}
public override void GatherSymbols(CompileContext context, Model.Scope enclosingScope)
{
Child(0).GatherSymbols(context, enclosingScope);
Child(1).GatherSymbols(context, enclosingScope);
}
public override void Run(CompileContext context)
{
try
{
CompilePalLogger.LogLine("\nCompilePal - Nav Generator");
if (!File.Exists(context.CopyLocation))
{
throw new FileNotFoundException();
}
mapname = System.IO.Path.GetFileName(context.CopyLocation).Replace(".bsp", "");
mapnav = context.CopyLocation.Replace(".bsp", ".nav");
mapcfg = context.Configuration.GameFolder + "/cfg/" + mapname + ".cfg";
mapCFGBackup = context.Configuration.GameFolder + "/cfg/" + mapname + "_cpalbackup.cfg";
deleteNav(mapname, context.Configuration.GameFolder);
hidden = GetParameterString().Contains("-hidden");
string args = "-game \"" + context.Configuration.GameFolder + "\" -windowed -novid -nosound +sv_cheats 1 +map " + mapname;
if (hidden)
args += " -noborder -x 4000 -y 2000";
var startInfo = new ProcessStartInfo(context.Configuration.GameEXE, args);
startInfo.UseShellExecute = false;
startInfo.CreateNoWindow = false;
CompilePalLogger.LogLine("Generating...");
if (File.Exists(mapcfg))
{
if (File.Exists(mapCFGBackup))
System.IO.File.Delete(mapCFGBackup);
System.IO.File.Move(mapcfg, mapCFGBackup);
}
System.IO.File.Create(mapcfg).Dispose();
TextWriter tw = new StreamWriter(mapcfg);
tw.WriteLine("nav_generate");
tw.Close();
Process = new Process { StartInfo = startInfo };
Process.Start();
FileSystemWatcher fw = new FileSystemWatcher();
fw.Path = System.IO.Path.GetDirectoryName(mapnav);
fw.Filter = "*.nav";
fw.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
fw.Changed += new FileSystemEventHandler(fileSystemWatcher_NavCreated);
fw.Created += new FileSystemEventHandler(fileSystemWatcher_NavCreated);
fw.EnableRaisingEvents = true;
Process.WaitForExit();
fw.Dispose();
cleanUp();
CompilePalLogger.LogLine("nav file complete!");
}
catch (FileNotFoundException)
{
CompilePalLogger.LogLine("FAILED - Could not find " + context.CopyLocation);
}
catch (Exception exception)
{
CompilePalLogger.LogLine("Something broke:");
CompilePalLogger.LogLine(exception.ToString());
}
}
public virtual Intermediate.IRNode CompileFunction(CompileContext context)
{
if (context.options.strip && !function.reached)
return new Intermediate.Annotation("Function " + function.name + " stripped.");
context.nextVirtualRegister = 0;
var body = new Intermediate.IRNode();
foreach (var child in ChildNodes)
body.AddChild((child as CompilableNode).Emit(context, function.localScope, Target.Discard));
body.CollapseTransientNodes();
if (context.options.collapse_statements)
body.MergeConsecutiveStatements();
if (context.options.ssa)
body.ApplySSA();
body.PeepholeTree(context.peepholes);
var registers = new bool[] { true, false, false, false, false, false, false, true };
var used = 0;
// If we are emitting intermediate representation, we don't want to replace virtual registers.
if (!context.options.emit_ir)
{
body.AssignRegisters(null);
body.MarkUsedRealRegisters(registers);
used = registers.Count((rs) => rs == true) - 2; //Why -2? Don't preserve A or J.
body.CorrectVariableOffsets(-used);
}
var r = new Intermediate.Function
{
functionName = function.name,
entranceLabel = function.label,
parameterCount = function.parameterCount
};
r.AddChild(new Intermediate.Annotation(context.GetSourceSpan(this.headerSpan)));
r.AddLabel(function.label);
r.AddChild(new Intermediate.Annotation("Save frame pointer in J"));
r.AddInstruction(Intermediate.Instructions.SET, Operand("PUSH"), Operand("J"));
r.AddInstruction(Intermediate.Instructions.SET, Operand("J"), Operand("SP"));
//Save registers
for (int i = 1; i < 7; ++i)
if (registers[i])
r.AddInstruction(Intermediate.Instructions.SET, Operand("PUSH"), Operand((Model.Register)i));
r.AddChild(body);
r.AddLabel(footerLabel);
r.AddInstruction(Intermediate.Instructions.SET, Operand("SP"), Operand("J"));
if (used != 0)
r.AddInstruction(Intermediate.Instructions.SUB, Operand("SP"), Constant((ushort)used));
//Restore registers
for (int i = 6; i >= 1; --i)
if (registers[i])
r.AddInstruction(Intermediate.Instructions.SET, Operand((Model.Register)i), Operand("POP"));
r.AddInstruction(Intermediate.Instructions.SET, Operand("J"), Operand("POP"));
r.AddInstruction(Intermediate.Instructions.SET, Operand("PC"), Operand("POP"));
foreach (var nestedFunction in function.SubordinateFunctions)
r.AddChild(nestedFunction.Node.CompileFunction(context));
return r;
}
public override void ResolveTypes(CompileContext context, Model.Scope enclosingScope)
{
Child(0).ResolveTypes(context, enclosingScope);
Child(1).ResolveTypes(context, enclosingScope);
ResultType = Child(0).ResultType;
}
public CreateProducersPhase(CompileContext compileContext)
{
_compileContext = compileContext;
}
public CompileResult Compile(string source, CompileContext context)
{
var javascript = _scriptEngine.CallGlobalFunction<string>("handlebarsPrecompile", source);
return new CompileResult(javascript, Enumerable.Empty<string>());
}