public override void GenerateStartBlockCode (Block target, CodeGeneratorContext context) { if (context.Host.DesignTimeMode) return; context.FlushBufferedStatement(); var sb = new StringBuilder (); if (!string.IsNullOrEmpty (context.TargetWriterName)) { sb.AppendFormat ( "{0} ({1}, ", context.Host.GeneratedClassContext.WriteAttributeToMethodName, context.TargetWriterName ); } else { sb.AppendFormat ( "{0} (", context.Host.GeneratedClassContext.WriteAttributeMethodName ); } sb.WriteCStyleStringLiteral (Name); sb.Append (", "); sb.WriteCStyleStringLiteral (Prefix); sb.Append (", "); sb.WriteCStyleStringLiteral (Suffix); context.AddStatement (sb.ToString ()); }
public BlockBuilder(Block original) { Type = original.Type; Children = new List<SyntaxTreeNode>(original.Children); Name = original.Name; CodeGenerator = original.CodeGenerator; }
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 GeneratorResults(Block document, IList<RazorError> parserErrors, CodeCompileUnit generatedCode, IDictionary<int, GeneratedCodeMapping> designTimeLineMappings) : this(parserErrors.Count == 0, document, parserErrors, generatedCode, designTimeLineMappings) { }
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 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); } } }
public virtual void RenderClientTemplate(Block document, TextWriter output) { output.Write("function (Model) { "); output.Write("var _buf = []; "); ParseSyntaxTreeNode(document, output); output.Write(" return _buf.join(''); };"); }
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()); }); }
internal virtual void RunParseTest(string document, Func<ParserBase, Action> parserActionSelector, Block expectedRoot, IList<RazorError> expectedErrors, bool designTimeParser) { // Create the source using (StringTextBuffer reader = new StringTextBuffer(document)) { ParserResults results = null; try { ParserBase codeParser = CreateCodeParser(); MarkupParser markupParser = CreateMarkupParser(); SyntaxTreeBuilderVisitor listener = new SyntaxTreeBuilderVisitor(); ParserContext context = CreateParserRun(new TextBufferReader(reader), codeParser, markupParser, listener); context.DesignTimeMode = designTimeParser; codeParser.Context = context; markupParser.Context = context; // Run the parser parserActionSelector(context.ActiveParser)(); context.OnComplete(); // Collect the results results = listener.Results; EvaluateResults(TestContext, results, expectedRoot, expectedErrors); } finally { if (TestContext != null && results != null && results.Document != null) { TestContext.WriteLine(String.Empty); TestContext.WriteLine("Actual Parse Tree:"); WriteNode(0, TestContext, results.Document); } } } }
public override void GenerateStartBlockCode (Block target, CodeGeneratorContext context) { if (context.Host.DesignTimeMode) return; Block child = target.Children.Where (n => n.IsBlock).Cast<Block> ().FirstOrDefault (); isExpression = child != null && child.Type == BlockType.Expression; var sb = new StringBuilder (); sb.Append (", Tuple.Create<string,object,bool> ("); sb.WriteCStyleStringLiteral (Prefix.Value); sb.Append (", "); if (isExpression) { oldRenderingMode = context.GetExpressionRenderingMode (); context.SetExpressionRenderingMode (ExpressionRenderingMode.InjectCode); } else { sb.AppendFormat ( "new {0} ({1} => {{", context.Host.GeneratedClassContext.TemplateTypeName, ValueWriterName); } context.MarkEndOfGeneratedCode (); context.BufferStatementFragment (sb.ToString ()); oldTargetWriter = context.TargetWriterName; context.TargetWriterName = ValueWriterName; }
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 static string GetBlockName(Block block) { const string defaultName = "..."; switch (block.Type) { case BlockType.Statement: return "{...}"; case BlockType.Directive: break; case BlockType.Functions: return "@funtions"; case BlockType.Expression: break; case BlockType.Helper: return GetHelperBlockName(block); case BlockType.Markup: break; case BlockType.Section: return GetSectionBlockName(block); case BlockType.Template: break; case BlockType.Comment: return GetCommentBlockName(block); default: return defaultName; } return defaultName; }
public override void GenerateEndBlockCode (Block target, CodeGeneratorContext context) { if (context.Host.DesignTimeMode) return; context.FlushBufferedStatement (); context.AddStatement (");"); }
protected GeneratorResults(bool success, Block document, IList<RazorError> parserErrors, CodeCompileUnit generatedCode, IDictionary<int, GeneratedCodeMapping> designTimeLineMappings) : base(success, document, parserErrors) { GeneratedCode = generatedCode; DesignTimeLineMappings = designTimeLineMappings; }
public virtual void VisitBlock(Block block) { VisitStartBlock(block); foreach (SyntaxTreeNode node in block.Children) { node.Accept(this); } VisitEndBlock(block); }
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(); }
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context) { string startBlock = context.BuildCodeString(cw => { cw.WriteEndLambdaDelegate(); cw.WriteEndMethodInvoke(); cw.WriteEndStatement(); }); 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(); FillSpan(span, block.Children.Cast<Span>().First().Start, content); return span.Build(); }
internal void WriteTemplateFunction(Block document, TextWriter output) { output.WriteLine(@"function (Model) {"); output.WriteLine(" var buffer = [];"); ParseSyntaxTreeNode(document, output); output.WriteLine(" return buffer.join('');"); output.Write("}"); }
private static string GetSectionBlockName(Block block) { var sectionName = ""; if (block.Children != null) { var sectionHeader = block.Children.FirstOrDefault(c => c.GetType() == typeof (SectionHeaderSpan)) as SectionHeaderSpan; sectionName = sectionHeader != null ? sectionHeader.SectionName : ""; } return string.Format("section {0}", sectionName); }
protected virtual bool VisitBlock(Block block, TextWriter output) { if(block == null) return false; foreach (var child in block.Children) { ParseSyntaxTreeNode(child, output); } return true; }
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); }
private static string GetHelperBlockName(Block block) { var headerName = ""; var helperHeader = block.Children.FirstOrDefault(c => c.GetType() == typeof (HelperHeaderSpan)) as HelperHeaderSpan; if (helperHeader != null) { headerName = helperHeader.Content.Substring(0, helperHeader.Content.IndexOf("(", StringComparison.Ordinal)).Trim(); } return string.Format("helper {0}", headerName); }
public void ConstructorSetsPropertyValue() { // Arrange IEnumerable<SyntaxTreeNode> contents = new SyntaxTreeNode[0]; // Act Block block = new Block(BlockType.Expression, contents); // Assert Assert.AreEqual(BlockType.Expression, block.Type); Assert.AreSame(contents, block.Children); }
protected override SyntaxTreeNode RewriteBlock (BlockBuilder parent, Block block) { var b = new BlockBuilder (block); var abGen = block.CodeGenerator as AttributeBlockCodeGenerator; if (abGen != null) { b.CodeGenerator = new PreprocessedAttributeBlockCodeGenerator (abGen); } else { b.CodeGenerator = new PreprocessedDynamicAttributeBlockCodeGenerator ((DynamicAttributeBlockCodeGenerator)b.CodeGenerator); } return b.Build (); }
public override void VisitEndBlock(BlockType type) { base.VisitEndBlock(type); List<SyntaxTreeNode> elems = _blockStack.Pop(); Block block = new Block(type, elems); if (_blockStack.Count == 0) { _rootBlock = block; } else { CurrentBlock.Add(block); } }
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 IEnumerable<Node> Parse(Block block) { Node[] nodes = SyntaxTreeParser.Traverse(block).ToArray(); if (nodes.Length == 0) { return SyntaxTreeParser.EmptyNodeCollection; } return nodes.All(node => node.Type == NodeType.Markup || node.Type == NodeType.Expression) ? nodes : new[] { new BlockNode(nodes) }; }
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 void ConstructorSetsParentPointerOnChildren() { // Arrange SyntaxTreeNode[] contents = new SyntaxTreeNode[2] { new Block(BlockType.Comment, new SyntaxTreeNode[0]), new CodeSpan(String.Empty) }; // Act Block block = new Block(BlockType.Expression, contents); // Assert Assert.AreSame(block, contents[0].Parent); Assert.AreSame(block, contents[1].Parent); }