/// <summary>
/// Write CData
/// </summary>
/// <param name="element">Element containing CData</param>
public void WriteCData(XHTMLElement element)
{
XhtmlWriter.BeginRender();
XhtmlWriter.Write("<![CDATA[" + element.GetContent() + "]]>");
XhtmlWriter.EndRender();
XhtmlWriter.Flush();
}
/// <summary>
/// Interpret LetStatement
/// </summary>
/// <param name="statement">LetStatement to interpret</param>
public override void Visit(LetStatement statement)
{
//Create SymbolTable's for each assignment to let referencing work properly
foreach (Assignment asgn in statement.GetAssignments())
{
SymbolTable = new SymbolTable(SymbolTable);
asgn.AcceptVisitor(this);
}
//If no root element, create one
if (statement.GetStatements().Count > 1 && Root == null)
{
XHTMLElement newRoot = new XHTMLElement("html", null, true);
Root = newRoot;
Current = Root;
}
//Interpret statements
int depth = this.Depth;
foreach (Statement stmt in statement.GetStatements())
{
stmt.AcceptVisitor(this);
BackToParentXHTMLElement(depth);
}
//Go back to scope outside let statement
foreach (Assignment asgn in statement.GetAssignments())
{
SymbolTable = SymbolTable.GetParentSymbolTable();
}
}
/// <summary>
/// Add an XHTMLElement to XHTMLTree
/// </summary>
/// <param name="element">Element to add</param>
private void AddElement(XHTMLElement element)
{
//If no root element, create new root
if (Root == null)
{
if (element.GetTagState())
{
Root = element;
}
else
{
XHTMLElement newRoot = new XHTMLElement("html", null, true);
Root = newRoot;
Current = Root;
newRoot.AddChild(element);
}
}
else
{
//Add element as child of current element
Current.AddChild(element);
}
if (element.GetTagState())
{
Current = element;
Depth++;
}
}
/// <summary>
/// Interpret PostTextTail
/// </summary>
/// <param name="textTail">PostTextTail to interpret</param>
public override void Visit(PostTextTail textTail)
{
XHTMLElement element = new XHTMLElement(textTail.GetPostText().GetText(), Current);
element.SetTagState(false);
AddElement(element);
}
/// <summary>
/// Method which determines if the tag needs alternative closing, like <img />, <br />, <hr />
/// </summary>
/// <param name="element">Element to check</param>
/// <returns>True if empty element, otherwise false</returns>
private bool IsEmptyElement(XHTMLElement element)
{
//Check if element has childs, if not it's empty
if (element.GetChildren().Count == 0 && !element.IsGenerated())
{
return(true);
}
//Generated elements like html in empty file should not be shortened in ending
if (element.IsGenerated())
{
return(false);
}
//Some elements are always empty
String[] xhtmlEmptyTags = Enum.GetNames(typeof(EmptyXHTMLElement));
String tag = element.GetTag();
foreach (String item in xhtmlEmptyTags)
{
if (item.Equals(tag.ToUpper()))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Interpret CommentStatement
/// </summary>
/// <param name="statement">CommentStatement to interpret</param>
public override void Visit(CommentStatement statement)
{
XHTMLElement comment = new XHTMLElement("comment", Current);
comment.SetTagState(false);
comment.AddContent(statement.GetCommentString());
AddElement(comment);
}
/// <summary>
/// Set Current to parent
/// </summary>
/// <param name="requestedDepth">Depth of parents</param>
private void BackToParentXHTMLElement(int requestedDepth)
{
for (int i = 0; Depth > requestedDepth; i++)
{
Current = Current.GetParent();
Depth--;
}
}
/// <summary>
/// Interpret CdataStatement
/// </summary>
/// <param name="statement">CdataStatement to interpret</param>
public override void Visit(CdataStatement statement)
{
statement.GetExpression().AcceptVisitor(this);
XHTMLElement cdata = new XHTMLElement("cdata", Current);
cdata.SetTagState(false);
cdata.AddContent(TextValue);
AddElement(cdata);
}
/// <summary>
/// Interpret EachStatement
/// </summary>
/// <param name="statement">EachStatement to interpret</param>
public override void Visit(EachStatement statement)
{
//If no root element, create one
if (Root == null)
{
XHTMLElement newRoot = new XHTMLElement("html", null, true);
Root = newRoot;
Current = Root;
}
Expression expr = statement.GetExpression();
//Different looping with different expression types
if (expr is ListExpression)
{ //Iterate through list
ListExpression listExpression = (ListExpression)expr;
//Iterate through list with expression
XHTMLElement temp = Current;
foreach (Expression currentExpr in listExpression.GetExpressions())
{
Current = temp;
//New scope
SymbolTable = new SymbolTable(SymbolTable);
//Define variable and interpret statement with this scope
SymbolTable.AddVariableDefinition(statement.GetIdentifier(), currentExpr);
statement.GetStatement().AcceptVisitor(this);
//Return to parent scope
SymbolTable = SymbolTable.GetParentSymbolTable();
}
}
else if (expr is FieldExpression)
{ //Get expression in referenced record
Expression expression = GetExpression((FieldExpression)expr);
//Visit each for expression
EachStatement eachStatement = new EachStatement();
eachStatement.SetExpression(expression);
eachStatement.SetStatement(statement.GetStatement());
eachStatement.SetIdentifier(statement.GetIdentifier());
Visit(eachStatement);
}
else if (expr is VarExpression)
{ //Get expression of variable
Expression expression = SymbolTable.GetVariableDefinition(((VarExpression)expr).GetVariableIdentifier());
//Visit each for expression
EachStatement eachStatement = new EachStatement();
eachStatement.SetExpression(expression);
eachStatement.SetStatement(statement.GetStatement());
eachStatement.SetIdentifier(statement.GetIdentifier());
Visit(eachStatement);
}
}
public XHTMLElement(String tag, XHTMLElement parent, bool generated)
{
Parent = parent;
Tag = tag;
AttributeMap = new Dictionary <String, String>();
Children = new List <XHTMLElement>();
Content = "";
IsTag = true;
Generated = generated;
}
/// <summary>
/// Get XHTML tree representation
/// </summary>
/// <returns>XHTMLElement which is root of the tree</returns>
public XHTMLElement GetTree()
{
//If tree is empty return only root html tag
if (Root == null)
{
Root = new XHTMLElement("html", null, true);
}
return(Root);
}
/// <summary>
/// Interpret MidTextTail
/// </summary>
/// <param name="textTail">MidTextTail to Interpret</param>
public override void Visit(MidTextTail textTail)
{
XHTMLElement element = new XHTMLElement(textTail.GetMidText().GetText(), Current);
element.SetTagState(false);
AddElement(element);
textTail.GetEmbed().AcceptVisitor(this);
textTail.GetTextTail().AcceptVisitor(this);
}
public XHTMLElement(String tag, XHTMLElement parent, bool generated)
{
Parent = parent;
Tag = tag;
AttributeMap = new Dictionary<String, String>();
Children = new List<XHTMLElement>();
Content = "";
IsTag = true;
Generated = generated;
}
/// <summary>
/// Interpret EchoExpressionStatement
/// </summary>
/// <param name="statement">EchoExpressionStatement to interpret</param>
public override void Visit(EchoExpressionStatement statement)
{
statement.GetExpression().AcceptVisitor(this);
//Add just an tag to current as parent
XHTMLElement echoElement = new XHTMLElement(TextValue, Current);
echoElement.SetTagState(false);
AddElement(echoElement);
}
/// <summary>
/// Interpret Embedding
/// </summary>
/// <param name="embedding">Embedding to interpret</param>
public override void Visit(Embedding embedding)
{
//Add content of pretext
XHTMLElement element = new XHTMLElement(embedding.GetPreText().GetText(), Current);
element.SetTagState(false);
AddElement(element);
//Interpret Embed and TextTail
embedding.GetEmbed().AcceptVisitor(this);
embedding.GetTextTail().AcceptVisitor(this);
}
/// <summary>
/// Write comment <!-- this is a comment -->
/// </summary>
/// <param name="element">Element containing element</param>
public void WriteComment(XHTMLElement element)
{
//Write comment open tag
XhtmlWriter.BeginRender();
XhtmlWriter.Write("<!--");
//Lets parse the text, because the XhtmlWriter handles layout chars incorrectly
CharIterator charIterator = new CharIterator();
String content = charIterator.ParseText(element.GetContent());
XhtmlWriter.Write(content);
//Close comment tag
XhtmlWriter.Write("-->");
XhtmlWriter.EndRender();
XhtmlWriter.Flush();
}
/// <summary>
/// Interpret BlockStatement
/// </summary>
/// <param name="statement">BlockStatement to interpret</param>
public override void Visit(BlockStatement statement)
{
//Create root XHTML element when multiple statements can be root and there's no root
if (statement.GetStatements().Count > 1 && Root == null)
{
XHTMLElement newRoot = new XHTMLElement("html", null, true);
Root = newRoot;
Current = Root;
}
int depth = this.Depth;
foreach (Statement currentStatement in statement.GetStatements())
{
currentStatement.AcceptVisitor(this);
BackToParentXHTMLElement(depth);
}
}
/// <summary>
/// Interpret an functionDefinition
/// </summary>
/// <param name="functionDefinition">FunctionDefinition to interpret</param>
public override void Visit(FunctionDefinition functionDefinition)
{
//Create root XHTML element when multiple statements can be root and there's no root
if (functionDefinition.GetStatements().Count > 1 && Root == null)
{
XHTMLElement newRoot = new XHTMLElement("html", null, true);
Root = newRoot;
Current = Root;
}
//Interpret statements
int depth = this.Depth;
foreach (Statement statement in functionDefinition.GetStatements())
{
statement.AcceptVisitor(this);
BackToParentXHTMLElement(depth);
}
}
/// <summary>
/// Interpret MarkupExpressionStatement
/// </summary>
/// <param name="statement">MarkupExpressionStatement to interpret</param>
public override void Visit(MarkupExpressionStatement statement)
{
//Iterate through Markup+
ISyntaxNode[] MarkupArray = statement.GetMarkups().ToArray();
for (int i = 0; i <= (MarkupArray.Length - 1); i++)
{
if (IsMarkupCall((Markup)MarkupArray[i]))
{
//Check if called function contains an yield, if so, add remaining markups/expression to yield stack
String functionIdentifier = ((Markup)MarkupArray[i]).GetDesignator().GetIdentifier();
if (NodeContainsYield(SymbolTable.GetFunctionDefinition(functionIdentifier)))
{
//Get remaining markups
NodeList nonInterpretedMarkups = new NodeList();
for (int j = i + 1; j <= (MarkupArray.Length - 1); j++)
{
nonInterpretedMarkups.Add(MarkupArray[j]);
}
//Create new MarkupExpressionStatement and push it to stack
MarkupExpressionStatement markupExpressionStatement = new MarkupExpressionStatement();
markupExpressionStatement.SetMarkups(nonInterpretedMarkups);
markupExpressionStatement.SetExpression(statement.GetExpression());
PushYieldNode(markupExpressionStatement);
}
//Interpret markup
((Markup)MarkupArray[i]).AcceptVisitor(this);
return;
}
else
{ //Interpret Tag
((Markup)MarkupArray[i]).AcceptVisitor(this);
}
}
//Interpret expression
statement.GetExpression().AcceptVisitor(this);
XHTMLElement element = new XHTMLElement(TextValue, Current);
element.SetTagState(false);
AddElement(element);
}
/// <summary>
/// Interpret YieldStatement
/// </summary>
/// <param name="statement">YieldStatement to interpret</param>
public override void Visit(YieldStatement statement)
{
if (YieldStack.Count == 0)
{
return;
}
//Pop from YieldStack and lets interpet it
YieldElement yieldElement = YieldStack.Pop();
if (yieldElement != null && yieldElement.GetRootElement() != null)
{
//Let's copy yieldstack, because there are possible yields in the yield.
Stack <YieldElement> tempYieldStack = new Stack <YieldElement>();
List <YieldElement> yieldList = YieldStack.ToList();
foreach (YieldElement yieldNode in yieldList)
{
tempYieldStack.Push(yieldNode);
}
//Lets interpret it with specific symboltable
SymbolTable temp = (SymbolTable)SymbolTable.Clone();
SymbolTable = yieldElement.GetSymbolTable();
yieldElement.GetRootElement().AcceptVisitor(this);
//Add some content when node is an expression or embedding
if (yieldElement.GetRootElement() is Expression || yieldElement.GetRootElement() is Embedding)
{
XHTMLElement element = new XHTMLElement(TextValue, Current);
element.SetTagState(false);
AddElement(element);
}
//Restore symboltable
SymbolTable = temp;
//Restore YieldStack in original shape before interpreting
YieldStack = tempYieldStack;
}
}
/// <summary>
/// Method which determines if the tag needs alternative closing, like <img />, <br />, <hr />
/// </summary>
/// <param name="element">Element to check</param>
/// <returns>True if empty element, otherwise false</returns>
private bool IsEmptyElement(XHTMLElement element)
{
//Check if element has childs, if not it's empty
if (element.GetChildren().Count == 0 && !element.IsGenerated())
{
return true;
}
//Generated elements like html in empty file should not be shortened in ending
if (element.IsGenerated())
{
return false;
}
//Some elements are always empty
String[] xhtmlEmptyTags = Enum.GetNames(typeof(EmptyXHTMLElement));
String tag = element.GetTag();
foreach (String item in xhtmlEmptyTags)
{
if (item.Equals(tag.ToUpper()))
{
return true;
}
}
return false;
}
/// <summary>
/// Write CData
/// </summary>
/// <param name="element">Element containing CData</param>
public void WriteCData(XHTMLElement element)
{
XhtmlWriter.BeginRender();
XhtmlWriter.Write("<![CDATA[" + element.GetContent() + "]]>");
XhtmlWriter.EndRender();
XhtmlWriter.Flush();
}
/// <summary>
/// Visit XHTMLElement and write it to stream
/// </summary>
/// <param name="element">Element to visit</param>
public void Visit(XHTMLElement element)
{
if (element.GetTag() == "cdata")
{ //CData need different handling
WriteCData(element);
}
else if (element.GetTag() == "comment")
{ //Write comment
WriteComment(element);
}
else
{ //Normal XHTML tag handling
XhtmlWriter.BeginRender();
//Check if element is tag, if not write tag, otherwise handle as XHTML tag
if (!element.GetTagState())
{
XhtmlWriter.BeginRender();
//Get escape chars out of this tag
CharIterator charIterator = new CharIterator();
String tag = charIterator.ParseText(element.GetTag());
XhtmlWriter.Write(tag);
XhtmlWriter.EndRender();
XhtmlWriter.Flush();
return;
}
XhtmlWriter.WriteBeginTag(element.GetTag());
foreach (KeyValuePair <String, String> pair in element.GetAttributes())
{
XhtmlWriter.WriteAttribute(pair.Key, pair.Value, false);
}
if (IsEmptyElement(element))
{ //Nothing inside element, so write tag end
XhtmlWriter.Write(XhtmlTextWriter.SelfClosingTagEnd);
}
else if (IsXHTMLTag(element.GetTag()))
{
//Write tag opening closing
XhtmlWriter.Write(XhtmlTextWriter.TagRightChar);
//Write content
XhtmlWriter.Write(element.GetContent());
//Visit children
foreach (XHTMLElement child in element.GetChildren())
{
Visit(child);
}
//Write closing tag
XhtmlWriter.WriteEndTag(element.GetTag());
XhtmlWriter.Flush();
}
else
{
//Just write it
XhtmlWriter.Write(element.GetTag());
XhtmlWriter.EndRender();
XhtmlWriter.Flush();
}
}
}
/// <summary>
/// Add child element to this element
/// </summary>
/// <param name="child">Child element</param>
public void AddChild(XHTMLElement child)
{
Children.Add(child);
}
/// <summary>
/// Write comment <!-- this is a comment -->
/// </summary>
/// <param name="element">Element containing element</param>
public void WriteComment(XHTMLElement element)
{
//Write comment open tag
XhtmlWriter.BeginRender();
XhtmlWriter.Write("<!--");
//Lets parse the text, because the XhtmlWriter handles layout chars incorrectly
CharIterator charIterator = new CharIterator();
String content = charIterator.ParseText(element.GetContent());
XhtmlWriter.Write(content);
//Close comment tag
XhtmlWriter.Write("-->");
XhtmlWriter.EndRender();
XhtmlWriter.Flush();
}
/// <summary>
/// Create an XHTMStreamWriter which writes to specified writer in specified XHTML DocType
/// </summary>
/// <param name="writer">Writer to write to</param>
/// <param name="docType">DocType of XHTML document</param>
public XHTMLStreamWriter(TextWriter writer, DocType docType, XHTMLElement tree)
{
DocTyping = docType;
XhtmlWriter = new XhtmlTextWriter(writer);
Root = tree;
}
/// <summary>
/// Create an XHTMStreamWriter which writes to specified writer in specified XHTML DocType
/// </summary>
/// <param name="writer">Writer to write to</param>
/// <param name="docType">DocType of XHTML document</param>
public XHTMLStreamWriter(TextWriter writer, DocType docType, XHTMLElement tree)
{
DocTyping = docType;
XhtmlWriter = new XhtmlTextWriter(writer);
Root = tree;
}
/// <summary>
/// Visit XHTMLElement and write it to stream
/// </summary>
/// <param name="element">Element to visit</param>
public void Visit(XHTMLElement element)
{
if (element.GetTag() == "cdata")
{ //CData need different handling
WriteCData(element);
}
else if (element.GetTag() == "comment")
{ //Write comment
WriteComment(element);
}
else
{ //Normal XHTML tag handling
XhtmlWriter.BeginRender();
//Check if element is tag, if not write tag, otherwise handle as XHTML tag
if (!element.GetTagState())
{
XhtmlWriter.BeginRender();
//Get escape chars out of this tag
CharIterator charIterator = new CharIterator();
String tag = charIterator.ParseText(element.GetTag());
XhtmlWriter.Write(tag);
XhtmlWriter.EndRender();
XhtmlWriter.Flush();
return;
}
XhtmlWriter.WriteBeginTag(element.GetTag());
foreach (KeyValuePair<String, String> pair in element.GetAttributes())
{
XhtmlWriter.WriteAttribute(pair.Key, pair.Value, false);
}
if (IsEmptyElement(element))
{ //Nothing inside element, so write tag end
XhtmlWriter.Write(XhtmlTextWriter.SelfClosingTagEnd);
}
else if (IsXHTMLTag(element.GetTag()))
{
//Write tag opening closing
XhtmlWriter.Write(XhtmlTextWriter.TagRightChar);
//Write content
XhtmlWriter.Write(element.GetContent());
//Visit children
foreach (XHTMLElement child in element.GetChildren())
{
Visit(child);
}
//Write closing tag
XhtmlWriter.WriteEndTag(element.GetTag());
XhtmlWriter.Flush();
}
else
{
//Just write it
XhtmlWriter.Write(element.GetTag());
XhtmlWriter.EndRender();
XhtmlWriter.Flush();
}
}
}
/// <summary>
/// Add child element to this element
/// </summary>
/// <param name="child">Child element</param>
public void AddChild(XHTMLElement child)
{
Children.Add(child);
}
