/// <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> /// 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> /// 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(); } } }