/// <summary> /// Parser for EchoStatement /// </summary> /// <returns>Parsed EchoStatement</returns> public EchoStatement ParseEchoStatement() { //Skip echo NextToken("echo", "echo Expression/Embedding ;", "echo"); //Determine echo type if (TokenStream.HasNext() && TokenStream.Peek(1).GetType() == TokenType.EMBEDDING) { //EchoEmbeddingStatement EchoEmbeddingStatement echoEmbedding = new EchoEmbeddingStatement(); //Parse embedding echoEmbedding.SetEmbedding(embeddingParser.ParseEmbedding()); //Skip ; token NextToken(";", "echo Expression/Embedding ;", ';'); return(echoEmbedding); } else { //EchoExpressionStatement EchoExpressionStatement echoExpression = new EchoExpressionStatement(); //Parse expression echoExpression.SetExpression(expressionParser.ParseExpression()); //Skip ; token NextToken(";", "echo Expression/Embedding ;", ';'); return(echoExpression); } }
/// <summary> /// Parse an ListExpression /// </summary> /// <returns>Parsed List Expression</returns> public ListExpression ParseListExpression() { ListExpression listExpression = new ListExpression(); //Skip [ token NextToken("[", "[ expression, expression ]", '['); while (TokenStream.HasNext()) { //Scan for expressions if (TokenStream.Peek(1).GetValue().ToString() == "]") { break; //empty list found } listExpression.AddExpression(ParseExpression()); if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ",") { //separator NextToken(",", "[ expression, expression ]", ','); } } //Skip ] token NextToken("]", "[ expression, expression ]", ']'); return(listExpression); }
/// <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> /// Parse an RecordExpression /// </summary> /// <returns>Parsed Record Expression</returns> public RecordExpression ParseRecordExpression() { RecordExpression recordExpression = new RecordExpression(); //Skip { token NextToken("{", "{key:value, key:value}", '{'); while (TokenStream.HasNext()) { //Scan for key value pairs if (TokenStream.Peek(1).GetValue().ToString() == "}") { break; //} marks end of stream } recordExpression.AddKeyValuePair(ParseKeyValuePair()); if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ",") { //Skip , token NextToken(",", "{key:value, key:value}", ','); } } //Skip } token NextToken("}", "{key:value, key:value}", '}'); return(recordExpression); }
/// <summary> /// Parser for Formals /// </summary> /// <param name="functionDefinition">functionDefinition to add formals to</param> /// <returns>Parsed Formals</returns> public void ParseFormals(FunctionDefinition functionDefinition) { if (TokenStream.Peek(1).GetValue().ToString() != "(") { return; //No formals, so return empty formals } //Skip ( token NextToken("(", "(formal1, formal2)", '('); while (TokenStream.HasNext()) { //Parse formals if (TokenStream.Peek(1).GetValue().ToString() == ")") { break; //End of formals } else if (TokenStream.Peek(1).GetValue().ToString() == ",") { //Skip , token NextToken(",", "(formal1, formal2)", ','); } functionDefinition.AddFormal(ParseFormal()); } //Skip ) token NextToken(")", "(formal1, formal2)", ')'); }
private bool IsNextMarkupAttribute(int index) { if (TokenStream.Peek(index).GetType() != TokenType.SYMBOL) { return(false); } String tokenText = TokenStream.Peek(index).GetValue().ToString(); return(tokenText == "#" || tokenText == "." || tokenText == "$" || tokenText == ":" || tokenText == "@" || tokenText == "%"); }
private bool IsMarkupExpressionStatement() { if (TokenStream.Peek(1).GetType() == TokenType.SYMBOL) { //Expression characters are only [ and { return(TokenStream.Peek(1).GetValue().ToString() == "[" || TokenStream.Peek(1).GetValue().ToString() == "{"); } else { return(TokenStream.Peek(1).GetType() != TokenType.KEYWORD); } }
public virtual AType Parse(TokenStream tokens) { tokens.EnsureNotEof(); Token throwToken = tokens.Peek(); AType type = this.TryParse(tokens); if (type == null) { throw new ParserException(throwToken, "Type name expected"); } return(type); }
/// <summary> /// Detects if next tokens are markup (in a Markup+ form) /// </summary> /// <returns>True if markup otherwise false</returns> private bool DetectNextIsMarkup() { int j = 1; if (TokenStream.HasNext(1) && TokenStream.Peek(1).GetType() == TokenType.IDENTIFIER) { if (TokenStream.HasNext(j + 1) && TokenStream.Peek(j + 1).GetValue().ToString() == "+") { //CatExpression isn't markup return(false); } //Determine if arguments exists while (TokenStream.HasNext(j + 1)) { if (IsNextMarkupAttribute(j + 1)) { //Attribute is max 2 tokens wide if (TokenStream.HasNext(j + 2)) { j += 2; } else { //No markup; return(false); } } else { //End of attributes break; } } //Determine if it is a call if (TokenStream.HasNext(j + 1) && TokenStream.Peek(j + 1).GetType() == TokenType.SYMBOL && TokenStream.Peek(j + 1).GetValue().ToString() == "(") { //Call markup return(true); } else if (TokenStream.HasNext(j + 1) && TokenStream.Peek(j + 1).GetType() == TokenType.SYMBOL && TokenStream.Peek(j + 1).GetValue().ToString() == ";") { //No markup in a list return(false); } else { //Everything else is just markup return(true); } } else { //No identifier at start, so no markup return(false); } }
/// <summary> /// Parser for Statements /// </summary> /// <returns>Parsed Statements</returns> public Statement ParseStatement() { if (TokenStream.HasNext()) { //Determine type of statement if (TokenStream.Peek(1).GetValue().ToString() == "if") { //If (ThenElse) statement return(ParseIfStatement()); } else if (TokenStream.Peek(1).GetValue().ToString() == "each") { //Each statement return(ParseEachStatement()); } else if (TokenStream.Peek(1).GetValue().ToString() == "let") { //Let statement return(ParseLetStatement()); } else if (TokenStream.Peek(1).GetValue().ToString() == "{") { //Block statement return(ParseBlockStatement()); } else if (TokenStream.Peek(1).GetValue().ToString() == "comment") { //Comment statement return(ParseCommentStatement()); } else if (TokenStream.Peek(1).GetValue().ToString() == "echo") { //Echo statement return(ParseEchoStatement()); } else if (TokenStream.Peek(1).GetValue().ToString() == "cdata") { //Cdata statement return(ParseCdataStatement()); } else if (TokenStream.Peek(1).GetValue().ToString() == "yield") { //Yield statement return(ParseYieldStatement()); } else if (TokenStream.Peek(1).GetType() == TokenType.IDENTIFIER) { //Markup statements, starts always with an identifier return(ParseMarkupStatement()); } else { //Unexpected token, throw exception throw new UnexpectedToken("Statement expected, but found:", TokenStream.Peek(1).GetValue().ToString(), TokenStream.Peek(1).GetLine()); } } return(null); }
/// <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> /// 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 an argument /// </summary> /// <returns>Parsed Argument</returns> public Argument ParseArgument() { Argument argument = null; //Determine type of argument if (TokenStream.Peek(2).GetValue().ToString() == "=") { //IdCon = Expression argument = ParseAttrArgument(); } else { //Expression argument = ParseExpressionArgument(); } return(argument); }
/// <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 markup /// </summary> /// <returns>Parsed markup</returns> public Markup ParseMarkup() { //First parse mandatory designator Markup markup = new Markup(); markup.SetDesignator(ParseDesignator()); //Determine if arguments are after designator if (TokenStream.Peek(1).GetType() == TokenType.SYMBOL && TokenStream.Peek(1).GetValue().ToString() == "(") { //We are dealing with an MarkupCall, so set Markup as Call markup.SetCall(); ParseArguments(markup); } return(markup); }
/// <summary> /// Parse a path /// </summary> /// <returns>Parsed path</returns> public Path ParsePath() { Path path = new Path(); //Determine if we have directories in path or just a filename if (TokenStream.Peek(2).GetValue().ToString() == ".") { //Just a single filename to parse path.SetFilename(ParseFileName()); } else { //Directory and filename path.SetDirectoryName(ParseDirectoryName()); path.SetFilename(ParseFileName()); } return path; }
private bool IsMarkupStatStatement() { String value = TokenStream.Peek(1).GetValue().ToString(); bool lookahead = TokenStream.HasNext(3); if (lookahead) { String second = TokenStream.Peek(2).GetValue().ToString(); String look = TokenStream.Peek(3).GetValue().ToString(); return(value == "if" || value == "each" || value == "let" || (value == "{" && !(second == "}" && look == ";")) || value == "comment" || value == "echo" || value == "cdata" || value == "yield"); } else { return(value == "if" || value == "each" || value == "let" || value == "{" || value == "comment" || value == "echo" || value == "cdata" || value == "yield"); } }
/// <summary> /// Parser for If(Else)Statement /// </summary> /// <returns>Parsed If(Else)Statement</returns> public Statement ParseIfStatement() { Statement statement = null; //Skip if keyword NextToken("if", "if ( Predicate ) Statement else Statement", "if"); //Skip ( token NextToken("(", "if ( Predicate ) Statement else Statement", '('); //Parse predicate Predicate predicate = predicateParser.ParsePredicate(); //Skip ) token NextToken(")", "if ( Predicate ) Statement else Statement", ')'); //Parse if part of statement Statement ifStatementPart = ParseStatement(); if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "else") { //Else part detected //Skip else token NextToken("else", "if ( Predicate ) Statement else Statement", "else"); //Parse else statement part Statement elseStatementPart = ParseStatement(); IfElseStatement ifElseStatement = new IfElseStatement(); ifElseStatement.SetPredicate(predicate); ifElseStatement.SetTrueStatement(ifStatementPart); ifElseStatement.SetFalseStatement(elseStatementPart); statement = ifElseStatement; } else { //If statement IfStatement ifStatement = new IfStatement(); ifStatement.SetPredicate(predicate); ifStatement.SetTrueStatement(ifStatementPart); statement = ifStatement; } return(statement); }
/// <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> /// Parser for Predicate /// </summary> /// <returns>Parsed Predicate</returns> public Predicate ParsePredicate() { Predicate predicate = null; //Empty predicate if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "!") { //Not Predicate NotPredicate notPredicate = new NotPredicate(); //Skip ! token NextToken("!", "! predicate", '!'); //Parse predicate after ! notPredicate.SetPredicate(ParsePredicate()); predicate = notPredicate; } else { //Other predicates exists out of an expression Expression expression = expressionParser.ParseExpression(); if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ".") { //IsPredicate predicate = ParseIsPredicate(expression); } else { //ExpressionPredicate predicate = ParseExpressionPredicate(expression); } } //Check for && or || predicates if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "&" && TokenStream.Peek(2).GetValue().ToString() == "&") { //AndPredicate return(ParseAndPredicate(predicate)); } else if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "|" && TokenStream.Peek(2).GetValue().ToString() == "|") { //OrPredicate return(ParseOrPredicate(predicate)); } return(predicate); }
/// <summary> /// Parse Directory /// </summary> /// <returns>Parsed Directory</returns> public Directory ParseDirectory() { Directory directory = new Directory(); //Parse path elements while (TokenStream.HasNext()) { if(TokenStream.Peek(2).GetValue().ToString() == ".") { //End of directory, filename starts here break; } PathElement element = new PathElement(); NextToken("directory", "directory/filename.ext", TokenType.IDENTIFIER); element.SetPathElement(CurrentToken.GetValue().ToString()); directory.AddDirectoryElement(element); //Skip / or \ NextToken("/ or \\", "directory/FileName.ext", TokenType.SYMBOL); } return directory; }
/// <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); }
protected void ParseArgumentListDeclaration( TokenStream tokens, Node owner, IList <AType> argTypesOut, IList <Token> argNamesOut, IList <Expression> argDefaultValuesOut) { bool optionalArgFound = false; while (!tokens.PopIfPresent(")")) { if (argNamesOut.Count > 0) { tokens.PopExpected(","); } AType argType = this.HasTypes ? this.parser.TypeParser.Parse(tokens) : AType.Any(tokens.Peek()); Token argName = tokens.Pop(); this.parser.VerifyIdentifier(argName); Expression defaultValue = null; if (tokens.PopIfPresent("=")) { defaultValue = this.parser.ExpressionParser.Parse(tokens, owner); optionalArgFound = true; } else if (optionalArgFound) { throw this.parser.GenerateParseError( ErrorMessages.OPTIONAL_ARGUMENT_WAS_NOT_AT_END_OF_ARGUMENT_LIST, argName); } argTypesOut.Add(argType); argNamesOut.Add(argName); argDefaultValuesOut.Add(defaultValue); } }
/// <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> /// Parser for Designator /// </summary> /// <returns>Parsed Designator</returns> public Designator ParseDesignator() { Designator tag = new Designator(); //Parse identifier of tag NextToken("identifier", "identifier"); tag.SetIdentifier(CurrentToken.GetValue().ToString()); while (TokenStream.HasNext()) { //Parse attributes if (TokenStream.Peek(1).GetType() == TokenType.SYMBOL && IsAttribute(TokenStream.Peek(1).GetValue().ToString())) { tag.AddAttribute(ParseAttribute()); } else { break; //No attributes left, so break } } return(tag); }
/// <summary> /// Parser for FunctionDefinition /// </summary> /// <returns>Parsed FunctionDefinition</returns> public FunctionDefinition ParseFunctionDefinition() { FunctionDefinition functionDefinition = new FunctionDefinition(); //Parse FunctionId CurrentToken = TokenStream.NextToken(); functionDefinition.SetIdentifier(CurrentToken.GetValue().ToString()); //Parse Formals ParseFormals(functionDefinition); //Parse Statements while (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() != "end") { functionDefinition.AddStatement(statementParser.ParseStatement()); } //Skip end token NextToken("end", "def function() statements end", "end"); return(functionDefinition); }
/// <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 FuncBindAssignment /// </summary> /// <returns>Parsed FuncBindAssignment</returns> public FuncBindAssignment ParseFuncBindAssignment() { FuncBindAssignment funcBindAssignment = new FuncBindAssignment(); //Parse identifier CurrentToken = TokenStream.NextToken(); funcBindAssignment.SetIdentifier(CurrentToken.GetValue().ToString()); //Skip ( token NextToken("(", "identifier(identifier1, identifier2) = statement;", '('); //Parse identifiers while (TokenStream.HasNext()) { if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ")") { //No more identifiers break; } else if (TokenStream.Peek(1).GetValue().ToString() == ",") { //Skip , token NextToken(",", "(identifier1, identifier2)", ','); } CurrentToken = TokenStream.NextToken(); funcBindAssignment.AddIdentifier(CurrentToken.GetValue().ToString()); } //Skip ) token NextToken(")", "identifier(identifier1, identifier2) = statement;", ')'); //Skip = token NextToken("=", "identifier(identifier1, identifier2) = statement;", '='); //Parse statement funcBindAssignment.SetStatement(ParseStatement()); return(funcBindAssignment); }
/// <summary> /// Parser for BlockStatement /// </summary> /// <returns>Parsed BlockStatement</returns> public BlockStatement ParseBlockStatement() { BlockStatement blockStatement = new BlockStatement(); //Skip { token NextToken("{", "{ statements* }", '{'); //Parse statements while (TokenStream.HasNext()) { if (TokenStream.Peek(1).GetValue().ToString() == "}") { //End of blockstatement break; } blockStatement.AddStatement(ParseStatement()); } //Skip } token NextToken("}", "{ statements* }", '}'); return(blockStatement); }
/// <summary> /// Parse mappings /// </summary> /// <returns>A list of parsed mappings</returns> public NodeList ParseMappings() { NodeList MappingList = new NodeList(); while (TokenStream.HasNext()) //Parse mappings { MappingList.Add(ParseMapping()); if (TokenStream.HasNext()) //Check if another mapping comes { if (MatchValue(TokenStream.Peek(1).GetValue().ToString(), Waebric.WaebricKeyword.END.ToString())) { break; //END found so stop searching } else { NextToken(";", "Mapping ; Mapping", ';'); //Match separator } } } return MappingList; }