private void EmitNode(SyntaxTreeNode node)
{
var nodeType = node.GetType();
if (nodeType == typeof(WriteLiteralNode))
{
EmitWriteLiteral((WriteLiteralNode)node);
}
else if (nodeType == typeof(WriteExpressionNode))
{
EmitWriteExpression((WriteExpressionNode)node);
}
else if (nodeType == typeof(ConditionalNode))
{
EmitConditional((ConditionalNode)node);
}
else if (nodeType == typeof(IterateNode))
{
EmitIterate((IterateNode)node);
}
else if (nodeType == typeof(BlockNode))
{
EmitBlock((BlockNode)node);
}
else if (nodeType == typeof(IncludeTemplateNode))
{
EmitInclude((IncludeTemplateNode)node);
}
else if (nodeType == typeof(OverridePointNode))
{
EmitOverride((OverridePointNode)node);
}
else if (nodeType == typeof(FlushNode))
{
EmitFlush();
}
else if (nodeType == typeof(ScopedNode))
{
EmitScopedNode((ScopedNode)node);
}
else if (nodeType == typeof(ExtendTemplateNode))
{
throw new VeilCompilerException("Found an ExtendTemplate node inside a SyntaxTree. Extend nodes must be the root of a tree.");
}
else
{
throw new VeilCompilerException("Unknown SyntaxTreeNode {0}".FormatInvariant(nodeType.Name));
}
}
public TResult Visit(SyntaxTreeNode node)
{
if (node == null)
{
return(null);
}
var blockNode = node as BlockNode;
if (blockNode != null)
{
return(VisitBlockNode(blockNode));
}
var conditionalNode = node as ConditionalNode;
if (conditionalNode != null)
{
return(VisitConditionalNode(conditionalNode));
}
var iterateNode = node as IterateNode;
if (iterateNode != null)
{
return(VisitIterateNode(iterateNode));
}
var writeExpressionNode = node as WriteExpressionNode;
if (writeExpressionNode != null)
{
return(VisitWriteExpressionNode(writeExpressionNode));
}
var writeLiteralNode = node as WriteLiteralNode;
if (writeLiteralNode != null)
{
return(VisitWriteLiteralNode(writeLiteralNode));
}
var helperNode = node as HelperExpressionNode;
if (helperNode != null)
{
return(VisitHelperNode(helperNode));
}
var helperBlockNode = node as HelperBlockNode;
if (helperBlockNode != null)
{
return(VisitHelperBlockNode(helperBlockNode));
}
throw new NotSupportedException(string.Format("The given node type '{0}' isn't supported.", node.GetType()));
}
private Expression HandleNode(SyntaxTreeNode node)
{
if (node is BlockNode)
{
return(HandleBlock((BlockNode)node));
}
if (node is WriteLiteralNode)
{
return(HandleWriteLiteral((WriteLiteralNode)node));
}
if (node is WriteExpressionNode)
{
return(HandleWriteExpression((WriteExpressionNode)node));
}
if (node is IterateNode)
{
return(HandleIterate((IterateNode)node));
}
if (node is ConditionalNode)
{
return(HandleConditional((ConditionalNode)node));
}
if (node is ScopedNode)
{
return(HandleScopedNode((ScopedNode)node));
}
if (node is FlushNode)
{
return(HandleFlush());
}
//if (node is IncludeTemplateNode) return HandleInclude((IncludeTemplateNode)node);
if (node is OverridePointNode)
{
return(HandleOverride((OverridePointNode)node));
}
if (node is ExtendTemplateNode)
{
throw new VeilCompilerException("Found an ExtendTemplate node inside a SyntaxTree. Extend nodes must be the root of a tree.", node);
}
if (node is HelperExpressionNode)
{
return(HandleHelperExpression((HelperExpressionNode)node));
}
if (node is HelperBlockNode)
{
return(HandleHelperBlockNode((HelperBlockNode)node));
}
throw new VeilCompilerException("Unknown SyntaxTreeNode {0}".FormatInvariant(node.GetType().Name), node);
}
