/// <summary> /// Get NextToken and verify it maches matchObject (EmbeddedTokenStream) /// </summary> /// <param name="name">Name of expected token</param> /// <param name="syntax">Type of expected token</param> /// <param name="matchObject">Type of expected token</param> /// <returns>True if token matches, otherwise false</returns> private new bool NextToken(String name, String syntax, Object matchObject) { if (NextToken(name, syntax)) { if (CurrentToken.GetValue().Equals(matchObject)) { return(true); } else { throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } } return(false); }
/// <summary> /// Get NextToken and verify type of token (EmbeddedTokenStream) /// </summary> /// <param name="name">Name of expected token</param> /// <param name="syntax">Syntax of expected token</param> /// <param name="type">Type of expected token</param> /// <returns>True if token found and type matches, otherwise false</returns> private new bool NextToken(String name, String syntax, TokenType type) { if (NextToken(name, syntax)) { if (type.Equals(CurrentToken.GetType())) { return(true); } else { throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } } return(false); }
/// <summary> /// Parser for Embedding /// </summary> /// <returns>Parsed Embedding</returns> public Embedding ParseEmbedding() { //Get iterator for specific embedding if (TokenStream.Peek(1).GetType() == TokenType.EMBEDDING) { //Store embedding in internal tokeniterator to parse internally CurrentToken = TokenStream.NextToken(); EmbeddingTokenStream = ((EmbeddingToken)CurrentToken).GetTokenIterator(); } else { //Raise exception throw new UnexpectedToken("Embedding expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } //Let's parse embedding Embedding embedding = new Embedding(); embedding.SetPreText(ParsePreText()); embedding.SetEmbed(ParseEmbed()); embedding.SetTextTail(ParseTextTail()); return(embedding); }
/// <summary> /// Parser for Embed /// </summary> /// <returns>Parsed Embed</returns> public Embed ParseEmbed() { Embed embed = null; NodeList markupList = new NodeList(); //Set up MarkupParser markupParser = new MarkupParser(EmbeddingTokenStream); //Parse Markup* //EmbeddingTokenStream.HasNext(2) && !(EmbeddingTokenStream.Peek(2).GetValue().ToString() == ">" while (NextTokenIsMarkup()) { markupList.Add(markupParser.ParseMarkup()); } //Check if an expression is remaining, otherwise embed is MarkupEmbedding if (IsExpressionRemaining()) { //ExpressionEmbedding ExpressionEmbed expressionEmbed = new ExpressionEmbed(); //Add already parsed markups to expressionEmbed expressionEmbed.SetMarkups(markupList); //Set up expressionparser expressionParser = new ExpressionParser(EmbeddingTokenStream); //Parse expression expressionEmbed.SetExpression(expressionParser.ParseExpression()); embed = expressionEmbed; } else { //MarkupEmbedding //Get last item from markupList and add it as Markup if (markupList.Count != 0) { Markup markup = (Markup)markupList.Get(markupList.Count - 1); markupList.Remove(markupList.Count - 1); MarkupEmbed markupEmbed = new MarkupEmbed(); markupEmbed.SetMarkups(markupList); markupEmbed.SetMarkup(markup); embed = markupEmbed; } else { //Markup* Markup must contain at least one markup element throw new UnexpectedToken("Markup expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } } /*//Determine if remaining embed is Markup or Expression * if (NextTokenIsMarkup()) * { //MarkupEmbedding * MarkupEmbed markupEmbed = new MarkupEmbed(); * * //Add already parsed markups to markupEmbed * markupEmbed.SetMarkups(markupList); * * //Parse latest markup * markupEmbed.SetMarkup(markupParser.ParseMarkup()); * * embed = markupEmbed; * } * else * { //ExpressionEmbedding * ExpressionEmbed expressionEmbed = new ExpressionEmbed(); * * //Add already parsed markups to expressionEmbed * expressionEmbed.SetMarkups(markupList); * * //Set up expressionparser * expressionParser = new ExpressionParser(EmbeddingTokenStream); * * //Parse expression * expressionEmbed.SetExpression(expressionParser.ParseExpression()); * * embed = expressionEmbed; * } */ return(embed); }
/// <summary> /// Get NextToken and verify if it exists (EmbeddedTokenStream) /// </summary> /// <param name="name">Name of expected token</param> /// <param name="syntax">Syntax of expected token</param> /// <returns>True if new token found, otherwise false</returns> private new bool NextToken(String name, String syntax) { if (EmbeddingTokenStream.HasNext()) { CurrentToken = EmbeddingTokenStream.NextToken(); return(true); } else { throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } }
/// <summary> /// Parse one module /// </summary> /// <param name="module">Module to parse</param> public Module ParseModule() { Module module = new Module(); //Skip module token NextToken("module", "module identifier", "module"); //Parse first the identifier of the module and set it ModuleId moduleIdentifier = ParseModuleId(); module.SetModuleId(moduleIdentifier); //Look for elements like SITE, DEF, etc while (TokenStream.HasNext()) { if (MatchValue(TokenStream.Peek(1).GetValue().ToString(), Waebric.WaebricKeyword.MODULE.ToString())) { //New module found, raise exception, only one module per file allowed throw new UnexpectedToken("Unexpected token, found second module definition:", "module", TokenStream.Peek(1).GetLine()); } CurrentToken = TokenStream.NextToken(); //Check for different elements which may appear in a module if (MatchValue(CurrentToken.GetValue().ToString(), Waebric.WaebricKeyword.DEF.ToString())) { //Function definition found module.AddFunctionDefinition(functionParser.ParseFunctionDefinition()); } else if (MatchValue(CurrentToken.GetValue().ToString(), Waebric.WaebricKeyword.SITE.ToString())) { //Site definition found, call siteparser module.AddSite(siteParser.ParseSite()); } else if (MatchValue(CurrentToken.GetValue().ToString(), Waebric.WaebricKeyword.IMPORT.ToString())) { //Imports found module.AddImport(ParseImport()); } else { //Exception throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } } return(module); }
/// <summary> /// Parse a module identifier /// </summary> /// <param name="identifier">Identifier to parse</param> public ModuleId ParseModuleId() { ModuleId moduleId = new ModuleId(); //parse module identifier while (TokenStream.HasNext()) { if (NextToken("identifier", "module identifier.identifier", TokenType.IDENTIFIER)) { moduleId.AddIdentifier(CurrentToken.GetValue().ToString()); } else { //Raise exception throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ".") { //Period, so another identifier will appear after this one NextToken(".", "module identifier.identifier", '.'); } else { break; //No more module identifier stuff will appear } } return(moduleId); }
/// <summary> /// Parser for MarkupStatement types /// </summary> /// <returns>Parsed Statement</returns> public Statement ParseMarkupStatement() { //Start parsing first markup part Markup firstMarkup = markupParser.ParseMarkup(); if (TokenStream.HasNext() && TokenStream.Peek(1).GetType() == TokenType.SYMBOL && TokenStream.Peek(1).GetValue().ToString() == ";") { //Just a single markup statement MarkupStatement markupStatement = new MarkupStatement(); markupStatement.SetMarkup(firstMarkup); //Skip ; token NextToken(";", "markup;", ';'); return(markupStatement); } else { //Get other markups NodeList markups = new NodeList(); markups.Add(firstMarkup); while (DetectNextIsMarkup()) { markups.Add(markupParser.ParseMarkup()); } //Determine statement type if (TokenStream.HasNext()) { if (TokenStream.Peek(1).GetType() == TokenType.EMBEDDING) { //Markup Embedding Statement MarkupEmbeddingStatement markupEmbedding = new MarkupEmbeddingStatement(); markupEmbedding.SetMarkups(markups); markupEmbedding.SetEmbedding(embeddingParser.ParseEmbedding()); //Skip ; token NextToken(";", "Markup+ Embedding;", ';'); return(markupEmbedding); } else if (TokenStream.Peek(1).GetValue().ToString() == ";") { //MarkupStatement MarkupMarkupStatement markupStatement = new MarkupMarkupStatement(); //Get last parsed markup from list and remove it from list Markup last = (Markup)markups.Get(markups.Count - 1); markups.Remove(markups.Count - 1); markupStatement.SetMarkup(last); markupStatement.SetMarkups(markups); //Skip ; token NextToken(";", "Markup+ Markup;", ';'); return(markupStatement); } else if (IsMarkupStatStatement()) { //MarkupStatStatement MarkupStatStatement markupStatStatement = new MarkupStatStatement(); markupStatStatement.SetMarkups(markups); markupStatStatement.SetStatement(ParseStatement()); return(markupStatStatement); } else if (IsMarkupExpressionStatement()) { //MarkupExpressionStatement MarkupExpressionStatement markupExpressionStatement = new MarkupExpressionStatement(); //Parse MarkupExpressionStatement markupExpressionStatement.SetMarkups(markups); markupExpressionStatement.SetExpression(expressionParser.ParseExpression()); //Skip ; token NextToken(";", "Markup+ Expression;", ';'); return(markupExpressionStatement); } else { //Unexpected token throw new UnexpectedToken("Markup Statement expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } } else { throw new UnexpectedToken("Expected MarkupStatement type, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } } }
/// <summary> /// Parse import /// </summary> /// <returns></returns> public Import ParseImport() { Import import = new Import(); if (TokenStream.HasNext() && TokenStream.Peek(1).GetType() == TokenType.IDENTIFIER) { import.SetModuleId(ParseModuleId()); } else { //Raise exception throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } return(import); }
/// <summary> /// Parser for Assignment /// </summary> /// <returns>Parsed Assignment</returns> public Assignment ParseAssignment() { //Determine type if (TokenStream.HasNext(2) && TokenStream.Peek(2).GetValue().ToString() == "(") { //FuncBindAssignment return(ParseFuncBindAssignment()); } else if (TokenStream.HasNext(2) && TokenStream.Peek(2).GetValue().ToString() == "=") { //VarBindAssignment return(ParseVarBindAssignment()); } else { throw new UnexpectedToken("Assignment expected, found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } }
/// <summary> /// Parser for LetStatement /// </summary> /// <returns>Parsed LetStatement</returns> public LetStatement ParseLetStatement() { LetStatement letStatement = new LetStatement(); //Skip let token NextToken("let", "let assignment+ in statement* end", "let"); //Parse arguments while (TokenStream.HasNext()) { if (TokenStream.Peek(1).GetValue().ToString() == "in") { break; //no more assignments left } letStatement.AddAssignment(ParseAssignment()); } if (letStatement.GetAssignments().Count == 0) { //No assignments is not allowed throw new UnexpectedToken("LetStatement doesn't contain assignments.", "Expected at least one assignment ", CurrentToken.GetLine()); //throw new UnexpectedToken(); } //Skip in token NextToken("in", "let assignment+ in statement* end", "in"); //Parse statements while (TokenStream.HasNext()) { if (TokenStream.Peek(1).GetValue().ToString() == "end") { //No more statements left break; } letStatement.AddStatement(ParseStatement()); } //Skip end token NextToken("end", "let assignment+ in statement* end", "end"); return(letStatement); }
/// <summary> /// Parse an expression /// </summary> /// <returns>Parsed Expression</returns> public Expression ParseExpression() { Expression expression = null; //Determine subtype and then parse that type if (TokenStream.Peek(1).GetType() == TokenType.TEXT) { //Text expression expression = ParseTextExpression(); } else if (TokenStream.Peek(1).GetType() == TokenType.WAEBRICSYMBOL) { //Symbol expression expression = ParseSymExpression(); } else if (TokenStream.Peek(1).GetType() == TokenType.NUMBER) { //Numeric expression expression = ParseNumExpression(); } else if (TokenStream.Peek(1).GetType() == TokenType.IDENTIFIER) { //Variable expression expression = ParseVarExpression(); } else if (TokenStream.Peek(1).GetValue().ToString() == "[") { //List expression expression = ParseListExpression(); } else if (TokenStream.Peek(1).GetValue().ToString() == "{") { //Record expression expression = ParseRecordExpression(); } //Check if it is maybe an catenation or field if (TokenStream.HasNext(2) && TokenStream.Peek(1).GetValue().ToString() == "." && TokenStream.Peek(2).GetType() == TokenType.IDENTIFIER && TokenStream.Peek(3).GetValue().ToString() != "?") { //Field return(ParseFieldExpression(expression)); } else if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "+") { //Catenation return(ParseCatExpression(expression)); } if (expression == null) { //No expression found, raise exception throw new UnexpectedToken("Expression expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } return(expression); }
/// <summary> /// Parser for Attribute /// </summary> /// <returns>Parsed Attribute</returns> public Attribute ParseAttribute() { CurrentToken = TokenStream.NextToken(); Attribute attribute = null; switch (CurrentToken.GetValue().ToString()) { //Determine different types of attributes case "#": //Id attribute attribute = ParseIdAttribute(); break; case ".": //Class attribute attribute = ParseClassAttribute(); break; case "$": //Name attribute attribute = ParseNameAttribute(); break; case ":": //Type attribute attribute = ParseTypeAttribute(); break; case "@": //Width_(Height) attribute if (TokenStream.Peek(2).GetValue().ToString() == "%") { //Width-Height attribute attribute = ParseWidth_HeightAttribute(); } else { //Only width attribute attribute = ParseWidthAttribute(); } break; default: throw new UnexpectedToken("Expected attribute, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } return(attribute); }
/// <summary> /// Parser for Type /// </summary> /// <returns>Parsed Type</returns> public Type ParseType() { //return specific type CurrentToken = TokenStream.NextToken(); if (CurrentToken.GetValue().ToString() == "list") { //ListType return(new ListType()); } else if (CurrentToken.GetValue().ToString() == "record") { //RecordType return(new RecordType()); } else if (CurrentToken.GetValue().ToString() == "string") { //StringType return(new StringType()); } else { //Unexpected type, throw exception throw new UnexpectedToken("Type expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine()); } }