public void Compile(CompilationContext context) { targetObject.Compile(context); value.Compile(context); CompilationHelper.PrepareValueOnStack(context, fieldInfo.FieldType, value.itemType); context.Emit(OpCodes.Stfld, fieldInfo); }
internal override IEnumerable<AssociativeNode> BuildAst(List<AssociativeNode> inputAstNodes, CompilationContext context) { var rhs = AstFactory.BuildStringNode(Value); var assignment = AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), rhs); return new[] { assignment }; }
static int Main(string[] args) { if (args != null && args.Length == 1) { if (args[0].Equals("-w", StringComparison.InvariantCultureIgnoreCase) || args[0].Equals("-wait", StringComparison.InvariantCultureIgnoreCase)) Console.ReadLine(); else siteRoot = args[0]; } if (siteRoot == null) { string baseDirectory = AppDomain.CurrentDomain.BaseDirectory; siteRoot = baseDirectory.Substring(0, baseDirectory.LastIndexOf("\\bin", StringComparison.InvariantCultureIgnoreCase)); } Console.WriteLine("Compiling [" + siteRoot + "] ..."); InitializeConfig(); if (!Directory.Exists(siteRoot)) { PrintHelpMessage(string.Format("The path '{0}' does not exist", siteRoot)); Console.ReadLine(); return -1; } OfflineCompiler compiler; try { ICompilationContext compilationContext = new CompilationContext( new DirectoryInfo(Path.Combine(siteRoot, "bin")), new DirectoryInfo(siteRoot), new DirectoryInfo(Path.Combine(siteRoot, "views")), new DirectoryInfo(options.CompilerOptions.TemporarySourceFilesDirectory)); compiler = new OfflineCompiler( new CSharpCodeProviderAdapterFactory(), new PreProcessor(), compilationContext, options.CompilerOptions, new DefaultFileSystemAdapter()); } catch { PrintHelpMessage("Could not start the compiler."); return -2; } try { string path = compiler.Execute(); Console.WriteLine("[{0}] compiled into [{1}].", siteRoot, path); return 0; } catch (Exception ex) { PrintHelpMessage("Could not compile." + Environment.NewLine + ex); return -3; } }
public static void EmitCall( CompilationContext context, IAstRefOrAddr invocationObject, MethodInfo methodInfo, List<IAstStackItem> arguments) { if (arguments == null) { arguments = new List<IAstStackItem>(); } if (invocationObject != null) { invocationObject.Compile(context); } ParameterInfo[] args = methodInfo.GetParameters(); if (args.Length != arguments.Count) { throw new Exception("Invalid method parameters count"); } for (int i = 0; i < args.Length; ++i) { arguments[i].Compile(context); PrepareValueOnStack(context, args[i].ParameterType, arguments[i].itemType); } if (methodInfo.IsVirtual) { context.EmitCall(OpCodes.Callvirt, methodInfo); } else { context.EmitCall(OpCodes.Call, methodInfo); } }
private void CompileDirectory(CompilationContext context, string viewDirectory) { // Prevent processing of the same directories multiple times (sligh performance optimization, // as the build manager second call to compile a view is essentially a "no-op". if (context.ProcessedDirectories.Contains(viewDirectory)) return; context.ProcessedDirectories.Add(viewDirectory); var stopwatch = new Stopwatch(); stopwatch.Start(); try { var firstFile = _virtualPathProvider .ListFiles(viewDirectory) .Where(f => context.FileExtensionsToCompile.Any(e => f.EndsWith(e, StringComparison.OrdinalIgnoreCase))) .FirstOrDefault(); if (firstFile != null) BuildManager.GetCompiledAssembly(firstFile); } catch(Exception e) { // Some views might not compile, this is ok and harmless in this // context of pre-compiling views. Logger.Information(e, "Compilation of directory '{0}' skipped", viewDirectory); } stopwatch.Stop(); Logger.Information("Directory '{0}' compiled in {1} msec", viewDirectory, stopwatch.ElapsedMilliseconds); }
public override void Compile(CompilationContext context) { CompilationHelper.CheckIsValue(itemType); array.Compile(context); context.Emit(OpCodes.Ldc_I4, index); context.Emit(OpCodes.Ldelema, itemType); }
/// <summary> /// Executes the translation process. /// </summary> /// <param name="context">The compilation context.</param> public void Execute(CompilationContext context) { if (context == null || context.Model == null) return; if (context.OutputStream == null || !context.OutputStream.CanWrite) throw new CompilationException("The translation output stream is null or not writable."); var translationCtx = new TranslationContext(); translationCtx.OutputStream = context.OutputStream; // write enum declarations var enumTranslator = new EnumTranslator(); foreach (var item in context.Model.Enums) enumTranslator.Translate(item, translationCtx); // write class declarations var classTranslator = new ClassTranslator(); foreach (var item in ClassSorter.Sort(context.Model.Classes)) classTranslator.Translate(item, translationCtx); // write global statements if (context.Model.GlobalStatements.Any()) { translationCtx.WriteLine(); foreach (var item in context.Model.GlobalStatements) translationCtx.WriteModel(item); } }
public void Compile(CompilationContext context) { AstBuildHelper.CallMethod( _setMethod, _targetObject, new List<IAstStackItem>() { _value } ).Compile(context); }
public void Compile(CompilationContext context) { if(localType.IsValueType) { context.Emit(OpCodes.Ldloca, localIndex); context.Emit(OpCodes.Initobj, localType); } }
/// <summary> /// Executes the model validation process. /// </summary> /// <param name="context">The compilation context.</param> public void Execute(CompilationContext context) { var provider = new ImportProvider<IModelValidator>(); foreach (var validator in provider.GetImports()) { validator.Validate(context.Model, context.Result); } }
public void Compile(CompilationContext context) { new AstCallMethod(methodInfo, invocationObject, arguments).Compile(context); if (methodInfo.ReturnType != typeof(void)) { context.Emit(OpCodes.Pop); } }
public void Compile(CompilationContext context) { var endBlock = context.ilGenerator.BeginExceptionBlock(); protectedBlock.Compile(context); context.ilGenerator.BeginCatchBlock(exceptionType); context.ilGenerator.Emit(OpCodes.Stloc, eceptionVariable); handlerBlock.Compile(context); context.ilGenerator.EndExceptionBlock(); }
public virtual void Compile(CompilationContext context) { AstReadArgument arg = new AstReadArgument() { argumentIndex = 0, argumentType = thisType }; arg.Compile(context); }
public void Compile(CompilationContext context) { value.Compile(context); if (value.itemType.IsValueType) { context.Emit(OpCodes.Box, itemType); } }
public IncrementalHighlighter(Highlighter highlighter) { highlightingParser = new HighlightingParser(highlighter); var context = new CompilationContext(); tokenizer = context.CreateTokenizer( token => highlightingParser.OnToken(token), () => highlightingParser.OnDone(), () => {} ); }
public Delegate Compile () { #if TARGET_JVM || MONOTOUCH return new System.Linq.jvm.Runner (this).CreateDelegate (); #else var context = new CompilationContext (); context.AddCompilationUnit (this); return context.CreateDelegate (); #endif }
public void Compile(CompilationContext context) { Label ifNotNullLabel = context.ilGenerator.DefineLabel(); _value.Compile(context); context.Emit(OpCodes.Dup); context.Emit(OpCodes.Brtrue_S, ifNotNullLabel); context.Emit(OpCodes.Pop); _ifNullValue.Compile(context); context.ilGenerator.MarkLabel(ifNotNullLabel); }
public void Compile(CompilationContext context) { foreach (IAstNode node in nodes) { if (node != null) { node.Compile(context); } } }
/// <summary> /// Executes the syntax validation process. /// </summary> /// <param name="context">The compilation context.</param> public void Execute(CompilationContext context) { var visitor = new SyntaxValidationVisitor( new SyntaxValidatorProvider(), context.Result); foreach (var tree in context.Compilation.SyntaxTrees) { visitor.CurrentTree = tree; visitor.Visit(tree.GetRoot()); } }
public virtual void Compile(CompilationContext context) { MethodInfo mi = propertyInfo.GetGetMethod(); if (mi == null) { throw new Exception("Property " + propertyInfo.Name + " doesn't have get accessor"); } AstBuildHelper.CallMethod(mi, sourceObject, null).Compile(context); }
override public void Compile(CompilationContext context) { CompilationHelper.CheckIsValue(itemType); if (itemType == typeof(Int32)) { context.Emit(OpCodes.Ldind_I4); } else { throw new Exception("Unsupported type"); } }
public void Compile(CompilationContext context) { LocalBuilder loc = context.ilGenerator.DeclareLocal(itemType); new AstInitializeLocalVariable(loc).Compile(context); new AstWriteLocal() { localIndex = loc.LocalIndex, localType = loc.LocalType, value = value }.Compile(context); new AstReadLocalAddr(loc).Compile(context); }
/// <summary> /// Executes the preprocessing process. /// </summary> /// <param name="context">The compilation context.</param> public void Execute(CompilationContext context) { if (context == null || context.Compilation == null) return; // get local imports var provider = new ImportProvider<IPreprocessor>(null); var sorter = new PreprocessorSorter(); foreach (var preprocessor in sorter.Sort(provider.GetImports())) { context.Compilation = preprocessor.ProcessCompilation(context.Compilation); } }
public static void PrepareValueOnStack(CompilationContext context, Type desiredType, Type typeOnStack) { if (typeOnStack.IsValueType && !desiredType.IsValueType) { context.Emit(OpCodes.Box, typeOnStack); } else if (!typeOnStack.IsValueType && desiredType.IsValueType) { context.Emit(OpCodes.Unbox_Any, desiredType); } else if (desiredType != typeOnStack) { context.Emit(OpCodes.Castclass, desiredType); } }
/// <summary> /// Executes the module builder process /// </summary> /// <param name="context">The compilation context.</param> public void Execute(CompilationContext context) { if (context.Input == null) throw new CompilationException("The compilation input cannot be null."); // ensure the output directory is available if (!Directory.Exists(context.Input.TargetDirectory)) Directory.CreateDirectory(context.Input.TargetDirectory); CompilerResults compileResult = null; using (var codeProvider = new CSharpCodeProvider()) { // create compiler and options var options = new CompilerParameters { GenerateExecutable = false, GenerateInMemory = true, IncludeDebugInformation = false, CompilerOptions = "/t:library /noconfig /nostdlib" }; // add referenced assemblies options.ReferencedAssemblies.AddRange( context.Input.ReferencePaths.ToArray()); // compile to module compileResult = codeProvider.CompileAssemblyFromFile(options, context.Input.SourceFilePaths.ToArray()); } // check for errors or warnings foreach (var item in compileResult.Errors.OfType<CompilerError>()) { var msg = new CompilationMessage { FilePath = item.FileName, Message = item.ErrorText }; if (item.IsWarning) context.Result.AddWarning(msg); else context.Result.AddError(msg); } }
public RootTokenizer(Action<Token> tokenConsumer, Action tokenReady, Action lineReady, CompilationContext compilationContext) { if(tokenConsumer == null) { throw new ArgumentNullException("tokenConsumer"); } else if(tokenReady == null) { throw new ArgumentNullException("tokenReady"); } else if(lineReady == null) { throw new ArgumentNullException("lineReady"); } else if(compilationContext == null) { throw new ArgumentNullException("compilationContext"); } this.tokenConsumer = tokenConsumer; this.tokenReady = tokenReady; this.lineReady = lineReady; this.compilationContext = compilationContext; }
/// <summary> /// Executes the transformation process. /// </summary> /// <param name="context">The compilation context.</param> public void Execute(CompilationContext context) { if (context == null || context.Compilation == null) return; if (context.Model == null) context.Model = new CompilationModel(); if (context.Compilation is Roslyn.Compilers.CSharp.Compilation) TransformCSharp(context); else if (context.Compilation is Roslyn.Compilers.VisualBasic.Compilation) TransformVisualBasic(context); else throw new NotImplementedException("Transformation not implemented for compilation of type: " + context.Compilation.GetType().FullName); if (!context.Result.HasErrors) { ModelRegistry.Current.ExtendCompilation(context.Model, context.Compilation.Assembly); } }
public void DefaultConstructorInitializeCorrectly() { var compilation = CSharpCompilation.Create("fakecompilation"); var fakeProject = new MockCompilationProject(); var fakeFramework = new FrameworkName(".NET Framework, Version=8.0"); var fakeConfiguration = "fakeConfiguration"; var resourceResolverInvoked = false; var context = new CompilationContext( compilation, fakeProject, fakeFramework, fakeConfiguration, new List<IMetadataReference>(), () => { resourceResolverInvoked = true; return new List<CodeAnalysis.ResourceDescription>(); }); Assert.NotNull(context.Modules); Assert.Equal(0, context.Modules.Count); Assert.Equal(compilation, context.Compilation); Assert.Equal(compilation, context.BeforeCompileContext.Compilation); Assert.Equal(fakeProject, context.Project); Assert.Equal(fakeFramework, context.ProjectContext.TargetFramework); Assert.Equal(fakeConfiguration, context.ProjectContext.Configuration); Assert.False(resourceResolverInvoked, "Resource resolver should not be invoked"); Assert.Equal(0, context.Resources.Count); Assert.True(resourceResolverInvoked); var newCompilation = compilation.Clone(); context.Compilation = newCompilation; Assert.NotEqual(compilation, context.Compilation); Assert.NotEqual(compilation, context.BeforeCompileContext.Compilation); Assert.Equal(newCompilation, context.Compilation); Assert.Equal(newCompilation, context.BeforeCompileContext.Compilation); }
public virtual void Compile(CompilationContext context) { switch (argumentIndex) { case 0: context.Emit(OpCodes.Ldarg_0); break; case 1: context.Emit(OpCodes.Ldarg_1); break; case 2: context.Emit(OpCodes.Ldarg_2); break; case 3: context.Emit(OpCodes.Ldarg_3); break; default: context.Emit(OpCodes.Ldarg, argumentIndex); break; } }
/// <summary> /// Executes the diagnostic process. /// </summary> /// <param name="context">The compilation context.</param> public void Execute(CompilationContext context) { if (context == null || context.Compilation == null) return; if (context.Result == null) context.Result = new CompilationResult(); foreach (var item in context.Compilation.GetDiagnostics()) { switch (item.Info.Severity) { case DiagnosticSeverity.Error: context.Result.AddError(CreateMessage(item)); break; case DiagnosticSeverity.Warning: context.Result.AddWarning(CreateMessage(item)); break; } } }
private IEnumerable <SymbolInformationOrDocumentSymbol> GetSymbols(CompilationContext context) { return(context.Compilation.GetEntrypointSemanticModel().Root.AllDeclarations .OrderBy(symbol => symbol.DeclaringSyntax.Span.Position) .Select(symbol => new SymbolInformationOrDocumentSymbol(CreateDocumentSymbol(symbol, context.LineStarts)))); }
private DeferredSectionVisitor(CompilationContext context) : base(context) { }
public void Emit(CompilationContext context) { //TODO: need to change emitted value if it's cast? ((ICodeEmitter)Tokens.Last()).Emit(context); }
/// <summary> /// Initializes a new instance of the <see cref="StaticAnalysisProcess"/> class. /// </summary> private StaticAnalysisProcess(CompilationContext context) { this.CompilationContext = context; }
public System.Linq.Expressions.Expression FromOutput(IFunction output, Type outputType, CompileFunction compile, CompilationContext context) { throw new NotImplementedException("Outputting an array is not supported yet"); }
IFunction IFunction.CallInternal(IFunction[] arguments, string output, CompilationContext context) => this;
internal override IEnumerable <AssociativeNode> BuildAst(List <AssociativeNode> inputAstNodes, CompilationContext context) { AssociativeNode assignment; if (null == inputAstNodes || inputAstNodes.Count == 0) { assignment = AstFactory.BuildAssignment(AstIdentifierForPreview, AstFactory.BuildNullNode()); } else { assignment = AstFactory.BuildAssignment(AstIdentifierForPreview, inputAstNodes[0]); } return(new[] { assignment }); }
protected abstract void EmitSource(CompilationContext context);
internal override IEnumerable <AssociativeNode> BuildAst(List <AssociativeNode> inputAstNodes, CompilationContext context) { //Do not build if the node is in error. if (State == ElementState.Error) { return(Enumerable.Empty <AssociativeNode>()); } var resultNodes = new List <AssociativeNode>(); // Define unbound variables if necessary if (inputIdentifiers != null && inputAstNodes != null && inputIdentifiers.Count == inputAstNodes.Count) { var initStatments = inputIdentifiers.Zip(inputAstNodes, (ident, rhs) => { var identNode = AstFactory.BuildIdentifier(ident); if (context != CompilationContext.NodeToCode) { MapIdentifiers(identNode); } return(AstFactory.BuildAssignment(identNode, rhs)); }); resultNodes.AddRange(initStatments); } foreach (var astNode in codeStatements.Select(stmnt => NodeUtils.Clone(stmnt.AstNode))) { if (context != CompilationContext.NodeToCode) { MapIdentifiers(astNode); } resultNodes.Add(astNode as AssociativeNode); } return(resultNodes); }
public CompilationContext Update(IReadOnlyWorkspace workspace, CompilationContext current, ImmutableDictionary <ISourceFile, ISemanticModel> modelLookup, RootConfiguration configuration, LinterAnalyzer linterAnalyzer) { var syntaxTreeGrouping = SourceFileGroupingBuilder.Rebuild(moduleDispatcher, workspace, current.Compilation.SourceFileGrouping, configuration); return(this.CreateContext(syntaxTreeGrouping, modelLookup, configuration, linterAnalyzer)); }
private void EmitSetTarget(CompilationContext context) { ((IMemberBuilder)TargetMember).EmitSetter(context); }
internal sealed override void Compile(CompilationContext context) { context.Stack.Push(context.Locals[this.Index]); var localIndex = this.Index - context.Signature.ParameterTypes.Length; if (localIndex < 0) { //Referring to a parameter. switch (this.Index) { default: if (this.Index <= byte.MaxValue) { context.Emit(OpCodes.Ldarg_S, checked ((byte)this.Index)); } else { context.Emit(OpCodes.Ldarg, checked ((ushort)this.Index)); } break; case 0: context.Emit(OpCodes.Ldarg_0); break; case 1: context.Emit(OpCodes.Ldarg_1); break; case 2: context.Emit(OpCodes.Ldarg_2); break; case 3: context.Emit(OpCodes.Ldarg_3); break; } } else { //Referring to a local. switch (localIndex) { default: if (localIndex > 65534) // https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldloc { throw new CompilerException($"Implementation limit exceeded: maximum accessible local index is 65534, tried to access {localIndex}."); } if (localIndex <= byte.MaxValue) { context.Emit(OpCodes.Ldloc_S, (byte)localIndex); } else { context.Emit(OpCodes.Ldloc, checked ((ushort)localIndex)); } break; case 0: context.Emit(OpCodes.Ldloc_0); break; case 1: context.Emit(OpCodes.Ldloc_1); break; case 2: context.Emit(OpCodes.Ldloc_2); break; case 3: context.Emit(OpCodes.Ldloc_3); break; } } }
public void Emit(CompilationContext context) { context.EmitInstruction(new IRSysEx()); }
public static System.Linq.Expressions.Expression Bind(System.Linq.Expressions.Expression expr, CompilationContext context) { return(new DeferredSectionVisitor(context).Visit(expr)); }
static MethodBuilder CreateSelectHelper(HelperMethod helper, CompilationContext context) { Assert(context != null); MethodBuilder builder; switch (helper) { default: Fail("Attempted to obtain an unknown helper method."); return(null); case HelperMethod.SelectInt32: builder = context.ExportsBuilder.DefineMethod( "☣ Select Int32", CompilationContext.HelperMethodAttributes, typeof(int), new[] { typeof(int), typeof(int), typeof(int), } ); break; case HelperMethod.SelectInt64: builder = context.ExportsBuilder.DefineMethod( "☣ Select Int64", CompilationContext.HelperMethodAttributes, typeof(long), new[] { typeof(long), typeof(long), typeof(int), } ); break; case HelperMethod.SelectFloat32: builder = context.ExportsBuilder.DefineMethod( "☣ Select Float32", CompilationContext.HelperMethodAttributes, typeof(float), new[] { typeof(float), typeof(float), typeof(int), } ); break; case HelperMethod.SelectFloat64: builder = context.ExportsBuilder.DefineMethod( "☣ Select Float64", CompilationContext.HelperMethodAttributes, typeof(double), new[] { typeof(double), typeof(double), typeof(int), } ); break; } var il = builder.GetILGenerator(); il.Emit(OpCodes.Ldarg_2); var @true = il.DefineLabel(); il.Emit(OpCodes.Brtrue_S, @true); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Ret); il.MarkLabel(@true); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ret); return(builder); }
public XmlWriteValueMethodCompiler(CompilationContext context) : base(context) { }
bool?IType.SatisfiedBy(IFunction value, CompilationContext info) => value is Error ? (bool?)null : value.GetSize(info).HasValue;
public IValue ResolveSubExpression(IValue previous, IScope resolutionScope, CompilationContext compilationContext) => previous switch {
internal override IEnumerable <AssociativeNode> BuildAst(List <AssociativeNode> inputAstNodes, CompilationContext context) { if (context == CompilationContext.NodeToCode) { var rhs = AstFactory.BuildStringNode(Value.Replace(@"\", @"\\")); var assignment = AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), rhs); return(new[] { assignment }); } else { return(base.BuildAst(inputAstNodes, context)); } }
/// <summary> /// Creates a P# static analysis process. /// </summary> public static StaticAnalysisProcess Create(CompilationContext context) { return(new StaticAnalysisProcess(context)); }
internal override IEnumerable <AssociativeNode> BuildAst(List <AssociativeNode> inputAstNodes, CompilationContext context) { return(Controller.BuildAst(this, inputAstNodes)); }
private const byte Else = 1; // End of the 'then' block and beginning of 'else' block. public static void Emit(byte[] instruction, CompilationContext context) { Emit(instruction, context, null); }
public int GetSizeOfAllLocalVariables(CompilationContext context) { return 0; }
public abstract void Emit(Type sourceType, Type targetType, CompilationContext context);
private static void Emit(byte[] instruction, CompilationContext context, IEnumerable <IOperation> operationsElse) { // 2X000000 // X: End type (0 = End, 1 = Else). byte terminationType = instruction[TerminationTypeIndex]; switch (terminationType) { case End: break; case Else: // Start a new operation block with the 'else' instruction to signal that there is the 'then' block just above it. context.BlockStack.Push(new OperationBlock(instruction)); return; default: throw new TamperCompilationException($"Unknown conditional termination type {terminationType}"); } // Use the conditional begin instruction stored in the stack. var upperInstruction = context.CurrentBlock.BaseInstruction; CodeType codeType = InstructionHelper.GetCodeType(upperInstruction); // Pop the current block of operations from the stack so control instructions // for the conditional can be emitted in the upper block. IEnumerable <IOperation> operations = context.CurrentOperations; context.BlockStack.Pop(); // If the else operations are already set, then the upper block must not be another end. if (operationsElse != null && codeType == CodeType.EndConditionalBlock) { throw new TamperCompilationException($"Expected an upper 'if' conditional instead of 'end conditional'"); } ICondition condition; switch (codeType) { case CodeType.BeginMemoryConditionalBlock: condition = MemoryConditional.Emit(upperInstruction, context); break; case CodeType.BeginKeypressConditionalBlock: condition = KeyPressConditional.Emit(upperInstruction, context); break; case CodeType.BeginRegisterConditionalBlock: condition = RegisterConditional.Emit(upperInstruction, context); break; case CodeType.EndConditionalBlock: terminationType = upperInstruction[TerminationTypeIndex]; // If there is an end instruction above then it must be an else. if (terminationType != Else) { throw new TamperCompilationException($"Expected an upper 'else' conditional instead of {terminationType}"); } // Re-run the Emit with the else operations set. Emit(instruction, context, operations); return; default: throw new TamperCompilationException($"Conditional end does not match code type {codeType} in Atmosphere cheat"); } // Create a conditional block with the current operations and nest it in the upper // block of the stack. IfBlock block = new IfBlock(condition, operations, operationsElse); context.CurrentOperations.Add(block); }
public void PushAddress(CompilationContext context) { ((IHasAddress)Tokens.Last()).PushAddress(context); }
public ExpressionType GetExpressionType(CompilationContext context) { return ((IHasType)Tokens[0]).GetExpressionType(context); }
/// <summary> /// Compiles the transient unit. 'PreCompile' should be called first! /// </summary> internal bool Compile(CompilationContext /*!*/ context, EvalKinds kind) { Analyzer analyzer = null; try { analyzer = new Analyzer(context); // perform pre-analysis on types and functions: if (types != null) { analyzer.PreAnalyze(types.Values); } if (functions != null) { analyzer.PreAnalyze(functions.Values); } // perform member analysis on types and functions: if (types != null) { analyzer.AnalyzeMembers(types.Values); } if (functions != null) { analyzer.AnalyzeMembers(functions.Values); } if (context.Errors.AnyFatalError) { return(false); } // perform full analysis: analyzer.Analyze(sourceUnit); if (context.Errors.AnyFatalError) { return(false); } // perform post analysis: analyzer.PostAnalyze(); } catch (CompilerException) { return(false); } finally { resolvingScriptContext = null; referringType = null; } // do not emit anything if there was parse/analysis error: if (context.Errors.AnyError) { return(false); } DefineBuilders(); // define constructed types: analyzer.DefineConstructedTypeBuilders(); CodeGenerator cg = new CodeGenerator(context); sourceUnit.Emit(cg); return(true); }
public IFunction ToInput(System.Linq.Expressions.Expression parameter, ICLRBoundaryMap rootTypeMap, CompilationContext info) => new Array1DFunc(parameter);
internal static TemplateDelegate CompileView(ViewReaderFactory readerFactoryFactory, string templatePath, CompilationContext compilationContext) { var configuration = compilationContext.Configuration; IEnumerable <object> tokens; using (var sr = readerFactoryFactory(configuration, templatePath)) { using (var reader = new ExtendedStringReader(sr)) { tokens = Tokenizer.Tokenize(reader).ToArray(); } } var layoutToken = tokens.OfType <LayoutToken>().SingleOrDefault(); var expressions = ExpressionBuilder.ConvertTokensToExpressions(tokens, configuration); var compiledView = FunctionBuilder.Compile(expressions, compilationContext); if (layoutToken == null) { return(compiledView); } var fs = configuration.FileSystem; var layoutPath = fs.Closest(templatePath, layoutToken.Value + ".hbs"); if (layoutPath == null) { throw new InvalidOperationException($"Cannot find layout '{layoutToken.Value}' for template '{templatePath}'"); } var compiledLayout = CompileView(readerFactoryFactory, layoutPath, new CompilationContext(compilationContext)); return((in EncodedTextWriter writer, BindingContext context) => { var config = context.Configuration; using var bindingContext = BindingContext.Create(config, null); foreach (var pair in context.ContextDataObject) { switch (pair.Key.WellKnownVariable) { case WellKnownVariable.Parent: case WellKnownVariable.Root: continue; } bindingContext.ContextDataObject[pair.Key] = pair.Value; } using var innerWriter = ReusableStringWriter.Get(config.FormatProvider); using var textWriter = new EncodedTextWriter(innerWriter, config.TextEncoder, FormatterProvider.Current, true); compiledView(textWriter, context); var inner = innerWriter.ToString(); var viewModel = new LayoutViewModel(inner, context.Value); bindingContext.Value = viewModel; compiledLayout(writer, bindingContext); });