public BlockBuilder(Block original) { Type = original.Type; Children = new List<SyntaxTreeNode>(original.Children); Name = original.Name; CodeGenerator = original.CodeGenerator; }
public GeneratorResults(Block document, IList<RazorError> parserErrors, CodeCompileUnit generatedCode, IDictionary<int, GeneratedCodeMapping> designTimeLineMappings) : this(parserErrors.Count == 0, document, parserErrors, generatedCode, designTimeLineMappings) { }
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context) { string endBlock = context.BuildCodeString(cw => { if (context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput) { if (!context.Host.DesignTimeMode) { cw.WriteEndMethodInvoke(); } cw.WriteEndStatement(); } else { cw.WriteLineContinuation(); } }); context.MarkEndOfGeneratedCode(); context.BufferStatementFragment(endBlock); context.FlushBufferedStatement(); if (context.Host.EnableInstrumentation && context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput) { Span contentSpan = target.Children .OfType<Span>() .Where(s => s.Kind == SpanKind.Code || s.Kind == SpanKind.Markup) .FirstOrDefault(); if (contentSpan != null) { context.AddContextCall(contentSpan, context.Host.GeneratedClassContext.EndContextMethodName, false); } } }
internal static void WriteDebugTree(string sourceFile, Block document, PartialParseResult result, TextChange change, RazorEditorParser parser, bool treeStructureChanged) { if (!OutputDebuggingEnabled) { return; } RunTask(() => { string outputFileName = Normalize(sourceFile) + "_tree"; string outputPath = Path.Combine(Path.GetDirectoryName(sourceFile), outputFileName); var treeBuilder = new StringBuilder(); WriteTree(document, treeBuilder); treeBuilder.AppendLine(); treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Last Change: {0}", change); treeBuilder.AppendLine(); treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Normalized To: {0}", change.Normalize()); treeBuilder.AppendLine(); treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Partial Parse Result: {0}", result); treeBuilder.AppendLine(); if (result.HasFlag(PartialParseResult.Rejected)) { treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Tree Structure Changed: {0}", treeStructureChanged); treeBuilder.AppendLine(); } if (result.HasFlag(PartialParseResult.AutoCompleteBlock)) { treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Auto Complete Insert String: \"{0}\"", parser.GetAutoCompleteString()); treeBuilder.AppendLine(); } File.WriteAllText(outputPath, treeBuilder.ToString()); }); }
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context) { if (context.Host.DesignTimeMode) { return; // Don't generate anything! } context.FlushBufferedStatement(); context.AddStatement(context.BuildCodeString(cw => { if (!String.IsNullOrEmpty(context.TargetWriterName)) { cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteAttributeToMethodName); cw.WriteSnippet(context.TargetWriterName); cw.WriteParameterSeparator(); } else { cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteAttributeMethodName); } cw.WriteStringLiteral(Name); cw.WriteParameterSeparator(); cw.WriteLocationTaggedString(Prefix); cw.WriteParameterSeparator(); cw.WriteLocationTaggedString(Suffix); // In VB, we need a line continuation cw.WriteLineContinuation(); })); }
public override void VisitBlock(Block block) { if (CanRewrite(block)) { SyntaxTreeNode newNode = RewriteBlock(_blocks.Peek(), block); if (newNode != null) { _blocks.Peek().Children.Add(newNode); } } else { // Not rewritable. BlockBuilder builder = new BlockBuilder(block); builder.Children.Clear(); _blocks.Push(builder); base.VisitBlock(block); Debug.Assert(ReferenceEquals(builder, _blocks.Peek())); if (_blocks.Count > 1) { _blocks.Pop(); _blocks.Peek().Children.Add(builder.Build()); } } }
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context) { _writer = context.CreateCodeWriter(); string prefix = context.BuildCodeString( cw => cw.WriteHelperHeaderPrefix(context.Host.GeneratedClassContext.TemplateTypeName, context.Host.StaticHelpers)); _writer.WriteLinePragma( context.GenerateLinePragma(Signature.Location, prefix.Length, Signature.Value.Length)); _writer.WriteSnippet(prefix); _writer.WriteSnippet(Signature); if (HeaderComplete) { _writer.WriteHelperHeaderSuffix(context.Host.GeneratedClassContext.TemplateTypeName); } _writer.WriteLinePragma(null); if (HeaderComplete) { _writer.WriteReturn(); _writer.WriteStartConstructor(context.Host.GeneratedClassContext.TemplateTypeName); _writer.WriteStartLambdaDelegate(HelperWriterName); } _statementCollectorToken = context.ChangeStatementCollector(AddStatementToHelper); _oldWriter = context.TargetWriterName; context.TargetWriterName = HelperWriterName; }
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context) { // Flush the buffered statement since we're interrupting it with a comment. if (!String.IsNullOrEmpty(context.CurrentBufferedStatement)) { context.MarkEndOfGeneratedCode(); context.BufferStatementFragment(context.BuildCodeString(cw => cw.WriteLineContinuation())); } context.FlushBufferedStatement(); }
protected GeneratorResults(bool success, Block document, IList<RazorError> parserErrors, CodeCompileUnit generatedCode, IDictionary<int, GeneratedCodeMapping> designTimeLineMappings) : base(success, document, parserErrors) { GeneratedCode = generatedCode; DesignTimeLineMappings = designTimeLineMappings; }
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context) { string startBlock = context.BuildCodeString(cw => { cw.WriteEndLambdaDelegate(); cw.WriteEndMethodInvoke(); cw.WriteEndStatement(); }); context.AddStatement(startBlock); }
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context) { string startBlock = context.BuildCodeString(cw => { cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.DefineSectionMethodName); cw.WriteStringLiteral(SectionName); cw.WriteParameterSeparator(); cw.WriteStartLambdaDelegate(); }); context.AddStatement(startBlock); }
protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block) { // Collect the content of this node string content = String.Concat(block.Children.Cast<Span>().Select(s => s.Content)); // Create a new span containing this content SpanBuilder span = new SpanBuilder(); span.EditHandler = new SpanEditHandler(HtmlTokenizer.Tokenize); FillSpan(span, block.Children.Cast<Span>().First().Start, content); return span.Build(); }
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context) { string generatedCode = context.BuildCodeString(cw => { cw.WriteEndLambdaDelegate(); cw.WriteEndConstructor(); cw.WriteEndLambdaExpression(); }); context.BufferStatementFragment(generatedCode); context.TargetWriterName = _oldTargetWriter; }
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context) { if (context.Host.DesignTimeMode) { return; // Don't generate anything! } context.FlushBufferedStatement(); context.AddStatement(context.BuildCodeString(cw => { cw.WriteEndMethodInvoke(); cw.WriteEndStatement(); })); }
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context) { string generatedCode = context.BuildCodeString(cw => { cw.WriteStartLambdaExpression(ItemParameterName); cw.WriteStartConstructor(context.Host.GeneratedClassContext.TemplateTypeName); cw.WriteStartLambdaDelegate(TemplateWriterName); }); context.MarkEndOfGeneratedCode(); context.BufferStatementFragment(generatedCode); context.FlushBufferedStatement(); _oldTargetWriter = context.TargetWriterName; context.TargetWriterName = TemplateWriterName; }
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context) { if (context.Host.DesignTimeMode) { return; // Don't generate anything! } // What kind of block is nested within string generatedCode; Block child = target.Children.Where(n => n.IsBlock).Cast<Block>().FirstOrDefault(); if (child != null && child.Type == BlockType.Expression) { _isExpression = true; generatedCode = context.BuildCodeString(cw => { cw.WriteParameterSeparator(); cw.WriteStartMethodInvoke("Tuple.Create"); cw.WriteLocationTaggedString(Prefix); cw.WriteParameterSeparator(); cw.WriteStartMethodInvoke("Tuple.Create", "System.Object", "System.Int32"); }); _oldRenderingMode = context.ExpressionRenderingMode; context.ExpressionRenderingMode = ExpressionRenderingMode.InjectCode; } else { generatedCode = context.BuildCodeString(cw => { cw.WriteParameterSeparator(); cw.WriteStartMethodInvoke("Tuple.Create"); cw.WriteLocationTaggedString(Prefix); cw.WriteParameterSeparator(); cw.WriteStartMethodInvoke("Tuple.Create", "System.Object", "System.Int32"); cw.WriteStartConstructor(context.Host.GeneratedClassContext.TemplateTypeName); cw.WriteStartLambdaDelegate(ValueWriterName); }); } context.MarkEndOfGeneratedCode(); context.BufferStatementFragment(generatedCode); _oldTargetWriter = context.TargetWriterName; context.TargetWriterName = ValueWriterName; }
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context) { if (context.Host.DesignTimeMode) { return; // Don't generate anything! } string generatedCode; if (_isExpression) { generatedCode = context.BuildCodeString(cw => { cw.WriteParameterSeparator(); cw.WriteSnippet(ValueStart.AbsoluteIndex.ToString(CultureInfo.CurrentCulture)); cw.WriteEndMethodInvoke(); cw.WriteParameterSeparator(); // literal: false - This attribute value is not a literal value, it is dynamically generated cw.WriteBooleanLiteral(false); cw.WriteEndMethodInvoke(); cw.WriteLineContinuation(); }); context.ExpressionRenderingMode = _oldRenderingMode; } else { generatedCode = context.BuildCodeString(cw => { cw.WriteEndLambdaDelegate(); cw.WriteEndConstructor(); cw.WriteParameterSeparator(); cw.WriteSnippet(ValueStart.AbsoluteIndex.ToString(CultureInfo.CurrentCulture)); cw.WriteEndMethodInvoke(); cw.WriteParameterSeparator(); // literal: false - This attribute value is not a literal value, it is dynamically generated cw.WriteBooleanLiteral(false); cw.WriteEndMethodInvoke(); cw.WriteLineContinuation(); }); } context.AddStatement(generatedCode); context.TargetWriterName = _oldTargetWriter; }
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context) { _statementCollectorToken.Dispose(); if (HeaderComplete) { _writer.WriteEndLambdaDelegate(); _writer.WriteEndConstructor(); _writer.WriteEndStatement(); } if (Footer != null && !String.IsNullOrEmpty(Footer.Value)) { _writer.WriteLinePragma( context.GenerateLinePragma(Footer.Location, 0, Footer.Value.Length)); _writer.WriteSnippet(Footer); _writer.WriteLinePragma(); } _writer.WriteHelperTrailer(); context.GeneratedClass.Members.Add(new CodeSnippetTypeMember(_writer.Content)); context.TargetWriterName = _oldWriter; }
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context) { if (context.Host.EnableInstrumentation && context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput) { Span contentSpan = target.Children .OfType<Span>() .Where(s => s.Kind == SpanKind.Code || s.Kind == SpanKind.Markup) .FirstOrDefault(); if (contentSpan != null) { context.AddContextCall(contentSpan, context.Host.GeneratedClassContext.BeginContextMethodName, false); } } string writeInvocation = context.BuildCodeString(cw => { if (context.Host.DesignTimeMode) { context.EnsureExpressionHelperVariable(); cw.WriteStartAssignment("__o"); } else if (context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput) { if (!String.IsNullOrEmpty(context.TargetWriterName)) { cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteToMethodName); cw.WriteSnippet(context.TargetWriterName); cw.WriteParameterSeparator(); } else { cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteMethodName); } } }); context.BufferStatementFragment(writeInvocation); context.MarkStartOfGeneratedCode(); }
internal static bool TreesAreDifferent(Block leftTree, Block rightTree, IEnumerable<TextChange> changes, CancellationToken cancelToken) { // Apply all the pending changes to the original tree // PERF: If this becomes a bottleneck, we can probably do it the other way around, // i.e. visit the tree and find applicable changes for each node. foreach (TextChange change in changes) { cancelToken.ThrowIfCancellationRequested(); Span changeOwner = leftTree.LocateOwner(change); // Apply the change to the tree if (changeOwner == null) { return true; } EditResult result = changeOwner.EditHandler.ApplyChange(changeOwner, change, force: true); changeOwner.ReplaceWith(result.EditedSpan); } // Now compare the trees bool treesDifferent = !leftTree.EquivalentTo(rightTree); return treesDifferent; }
//public override void VisitBlock(Block block) //{ // BlockBuilder parent = null; // if (_blocks.Count > 0) // { // parent = _blocks.Peek(); // } // BlockBuilder newBlock = new BlockBuilder(block); // newBlock.Children.Clear(); // _blocks.Push(newBlock); // if (block.Type == BlockType.Expression && parent != null) // { // VisitExpressionBlock(block, parent); // } // else // { // base.VisitBlock(block); // } // if (_blocks.Count > 1) // { // parent.Children.Add(_blocks.Pop().Build()); // } //} //public override void VisitSpan(Span span) //{ // Debug.Assert(_blocks.Count > 0); // _blocks.Peek().Children.Add(span); //} protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block) { BlockBuilder newBlock = new BlockBuilder(block); newBlock.Children.Clear(); Span ws = block.Children.FirstOrDefault() as Span; IEnumerable<SyntaxTreeNode> newNodes = block.Children; if (ws.Content.All(Char.IsWhiteSpace)) { // Add this node to the parent SpanBuilder builder = new SpanBuilder(ws); builder.ClearSymbols(); FillSpan(builder, ws.Start, ws.Content); parent.Children.Add(builder.Build()); // Remove the old whitespace node newNodes = block.Children.Skip(1); } foreach (SyntaxTreeNode node in newNodes) { newBlock.Children.Add(node); } return newBlock.Build(); }
public virtual void GenerateStartBlockCode(Block target, CodeGeneratorContext context) { }
protected ParserResults(bool success, Block document, IList<RazorError> errors) { Success = success; Document = document; ParserErrors = errors ?? new List<RazorError>(); }
public ParserResults(Block document, IList<RazorError> parserErrors) : this(parserErrors == null || parserErrors.Count == 0, document, parserErrors) { }
protected override bool CanRewrite(Block block) { return block.Type == BlockType.Expression && Parent != null; }
public override void VisitEndBlock(Block block) { block.CodeGenerator.GenerateEndBlockCode(block, Context); }
protected virtual SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block) { throw new NotImplementedException(); }
protected virtual bool CanRewrite(Block block) { return false; }
public void GenerateEndBlockCode(Block target, CodeGeneratorContext context) { }
public virtual Block Rewrite(Block input) { input.Accept(this); Debug.Assert(_blocks.Count == 1); return _blocks.Pop().Build(); }