private IEnumerable <StatementList> Parse(Stream stream) { while (stream.Peek() != null) { var token = stream.Peek(); switch (token.Type) { case TokenType.StringLiteral: case TokenType.StringLiteralPipe: case TokenType.QuotedStringLiteral: case TokenType.Identifier: case TokenType.OpenBracket: case TokenType.OpenParenthesis: case TokenType.Equal: case TokenType.At: var statement = ParseStatement(stream); yield return(statement); break; default: Errors.Add(new UnexpectedToken(token)); stream.Next(); break; //throw new ParserException(token); } } }
private StatementList ParseChild(Stream stream) { var child = new StatementList(_host); var open = stream.Next(); while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { default: var statements = ParseStatement(stream); foreach (var statement in statements) { child.Add(statement); } goto doneWithChildren; } } doneWithChildren: return(child); }
private Attribute ParseAttribute(Stream stream) { var identifier = stream.Next(); var equalsToken = stream.Peek() as EqualToken; if (equalsToken != null) { stream.NextNoReturn(); var valueToken = stream.Peek(); if (valueToken == null) { //TODO: Errors.Add(stream.Next()); Errors.Add(new UnexpectedToken(identifier)); return(new Attribute(identifier.Content, null)); //throw new ParserException(string.Format("Unexpected end of stream")); } if (valueToken.Type == TokenType.CloseBracket) { //then it's an invalid declaration Errors.Add(new AttributeValueMissing { Index = valueToken.Index }); } Statement value = ParseStatement(stream).SingleOrDefault(); //force this as an attribute type if (value == null) { } else { switch (value.Name) { case "true": case "false": case "null": value = new StringLiteral("\"" + value.Name + "\""); break; } } //reduction return(new Attribute(identifier.Content, value)); } //single attribute only return(new Attribute(identifier.Content, null)); }
private AttributeList ParseAttributes(Stream stream) { var attributes = new AttributeList(); var open = stream.Next(); Token token = null; //expecting identifier while (stream.Peek() != null) { token = stream.Peek(); switch (token.Type) { case TokenType.Identifier: attributes.Add(ParseAttribute(stream)); break; case TokenType.CloseBracket: //consume close bracket stream.NextNoReturn(); goto doneWithAttribute; default: //invalid token Errors.Add(new AttributeIdentifierMissing { Index = token.Index }); //throw new ParserException(token); return(attributes); } } doneWithAttribute: if (attributes.Count == 0) { //must be empty attribute list Errors.Add(new AttributeListEmpty { Index = token.Index }); return(attributes); //throw new ParserException(token); } //do reduction here return(attributes); }
private ParameterList ParseParameters(Stream stream) { var parameterList = new ParameterList(); //( parameterlist ) var open = stream.Next(); while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.Identifier: case TokenType.QuotedStringLiteral: case TokenType.StringLiteralPipe: parameterList.Add(ParseParameter(stream)); break; case TokenType.Comma: //another parameter - consume this stream.NextNoReturn(); break; case TokenType.CloseParenthesis: //consume close parenthesis stream.NextNoReturn(); goto doneWithParameter; default: //read until ) Errors.Add(new UnexpectedToken(token)); return(parameterList); //throw new ParserException(token); } } doneWithParameter: return(parameterList); }
private StatementList ParseChild(Stream stream) { var child = new StatementList(); stream.Next(); var token = stream.Peek(); if (token != null) { var statements = ParseStatement(stream); foreach (var statement in statements) { child.Add(statement); } } return(child); }
private Parameter ParseParameter(Stream stream) { var identifier = stream.Next(); switch (identifier.Type) { case TokenType.StringLiteralPipe: case TokenType.MultiLineStringLiteral: case TokenType.QuotedStringLiteral: case TokenType.StringLiteral: case TokenType.Identifier: break; default: //invalid token throw new ParserException(identifier); } //reduction return(new Parameter(_host, identifier.Content)); }
private StatementList ParseChildren(Stream stream) { StatementList statement = new StatementList(_host); var open = stream.Next(); CloseBracesToken close = null; while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.Plus: //ignore these? break; case TokenType.CloseBrace: //consume closing brace stream.NextNoReturn(); goto doneWithChildren; default: var statements = ParseStatement(stream); int length = statements.Count; for (int i = 0; i < length; i++) { statement.Add(statements[i]); } break; } } doneWithChildren: return(statement); }
private Parameter ParseParameter(Stream stream) { var identifier = stream.Next(); switch (identifier.Type) { case TokenType.StringLiteralPipe: case TokenType.QuotedStringLiteral: case TokenType.StringLiteral: case TokenType.Identifier: break; default: //invalid token Errors.Add(new UnexpectedToken(identifier)); //throw new ParserException(identifier); return(null); } //reduction return(new Parameter(identifier.Content)); }
private Attribute ParseAttribute(Stream stream) { var identifier = stream.Next(); var equalsToken = stream.Peek() as EqualToken; if (equalsToken != null) { stream.NextNoReturn(); var valueToken = stream.Peek(); if (valueToken == null) { throw new ParserException(string.Format("Unexpected end of stream")); } stream.NextNoReturn(); switch (valueToken.Type) { case TokenType.StringLiteralPipe: case TokenType.MultiLineStringLiteral: case TokenType.QuotedStringLiteral: case TokenType.StringLiteral: case TokenType.Identifier: //only accept tokens that are valid for attribute values break; default: //invalid token throw new ParserException(valueToken); } //reduction return(new Attribute(_host, identifier.Content, valueToken.Content)); } //single attribute only return(new Attribute(_host, identifier.Content, null)); }
private ParameterList ParseParameters(Stream stream) { var parameterList = new ParameterList(_host); //( parameterlist ) var open = stream.Next(); while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.Identifier: case TokenType.QuotedStringLiteral: case TokenType.StringLiteralPipe: case TokenType.MultiLineStringLiteral: parameterList.Add(ParseParameter(stream)); break; case TokenType.CloseParenthesis: //consume close parenthesis stream.NextNoReturn(); goto doneWithParameter; default: throw new ParserException(token); } } doneWithParameter: return(parameterList); }
/// <summary> /// Parses a token stream creating the largest statement possible /// </summary> /// <param name="stream">Stream of tokens to parse</param> /// <returns>Statement</returns> private StatementList ParseStatement(Stream stream) { var previousToken = stream.Peek(); if (previousToken == null) { Errors.Add(new EndOfStreamException()); return(new StatementList()); } var tokenType = previousToken.Type; Token identifier = null; switch (tokenType) { case TokenType.Identifier: //standard identifier identifier = stream.Next(); break; case TokenType.OpenBracket: case TokenType.OpenParenthesis: //ignore these break; case TokenType.StringLiteral: case TokenType.StringLiteralPipe: case TokenType.QuotedStringLiteral: //string statement identifier = stream.Next(); break; case TokenType.At: stream.GetNextNoReturn(); identifier = stream.Next(); break; case TokenType.Equal: stream.GetNextNoReturn(); identifier = stream.Next(); break; default: Errors.Add(new UnexpectedToken(previousToken)); return(new StatementList()); //throw new ParserException(stream.Peek()); } Statement statement; StatementTail tail = null; while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.OpenParenthesis: case TokenType.OpenBracket: case TokenType.OpenBrace: tail = ParseStatementTail(stream); break; case TokenType.GreaterThan: //consume greater than stream.NextNoReturn(); //might be a single child or a statement list of siblings tail = ParseSingleStatementTail(stream, tail); break; case TokenType.StringLiteralPipe: if (previousToken is StringLiteralPipeToken) { //if the previous token was a string literal pipe then we don't continue processing goto default; } //this overrides all previous tail elements tail = ParseSingleStatementTail(stream, tail); break; default: GetStatementFromToken(identifier, tail); goto checkForSiblings; } } checkForSiblings: statement = GetStatementFromToken(identifier, tail, previousToken); var list = new StatementList(); list.Add(statement); while (stream.Peek() != null) { //Parrot.Debugger.Debug.WriteLine("Looking for siblings"); if (stream.Peek().Type == TokenType.Plus) { //it's now a statementlist not a statement stream.NextNoReturn(); var siblings = ParseStatement(stream); foreach (var sibling in siblings) { list.Add(sibling); } } else { break; } } return(list); }
/// <summary> /// Parses a token stream creating the largest statement possible /// </summary> /// <param name="stream">Stream of tokens to parse</param> /// <returns>Statement</returns> private StatementList ParseStatement(Stream stream) { var tokenType = stream.Peek().Type; Token identifier = null; switch (tokenType) { case TokenType.Identifier: //standard identifier identifier = stream.Next(); break; case TokenType.OpenBracket: case TokenType.OpenParenthesis: //ignore these break; case TokenType.StringLiteral: case TokenType.MultiLineStringLiteral: case TokenType.StringLiteralPipe: case TokenType.QuotedStringLiteral: //string statement identifier = stream.Next(); break; } Statement statement = null; StatementTail tail = null; while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.OpenParenthesis: case TokenType.OpenBrace: case TokenType.OpenBracket: tail = ParseStatementTail(stream); break; case TokenType.GreaterThan: //consume greater than stream.NextNoReturn(); //might be a single child or a statement list of siblings tail = ParseSingleStatementTail(stream); break; case TokenType.Colon: //next thing must be an identifier var colon = stream.Next(); identifier = stream.Next(); statement = new EncodedOutput(_host, identifier.Content); goto checkForSiblings; case TokenType.Equal: //next thing must be an identifier var equal = stream.Next(); identifier = stream.Next(); statement = new RawOutput(_host, identifier.Content); goto checkForSiblings; default: statement = GetStatementFromToken(identifier, tail); goto checkForSiblings; } } statement = GetStatementFromToken(identifier, tail); checkForSiblings: var list = new StatementList(_host); list.Add(statement); while (stream.Peek() != null) { //Parrot.Debugger.Debug.WriteLine("Looking for siblings"); if (stream.Peek().Type == TokenType.Plus) { //it's now a statementlist not a statement stream.NextNoReturn(); var siblings = ParseStatement(stream); foreach (var sibling in siblings) { list.Add(sibling); } } else { break; } } return(list); }
private ParameterList ParseParameters(Stream stream) { var parameterList = new ParameterList(_host); //( parameterlist ) var open = stream.Next(); while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.Identifier: case TokenType.QuotedStringLiteral: case TokenType.StringLiteralPipe: case TokenType.MultiLineStringLiteral: parameterList.Add(ParseParameter(stream)); break; case TokenType.CloseParenthesis: //consume close parenthesis stream.NextNoReturn(); goto doneWithParameter; default: throw new ParserException(token); } } doneWithParameter: return parameterList; }
/// <summary> /// Parses a token stream creating the largest statement possible /// </summary> /// <param name="stream">Stream of tokens to parse</param> /// <returns>Statement</returns> private StatementList ParseStatement(Stream stream) { var tokenType = stream.Peek().Type; Token identifier = null; switch (tokenType) { case TokenType.Identifier: //standard identifier identifier = stream.Next(); break; case TokenType.OpenBracket: case TokenType.OpenParenthesis: //ignore these break; case TokenType.StringLiteral: case TokenType.MultiLineStringLiteral: case TokenType.StringLiteralPipe: case TokenType.QuotedStringLiteral: //string statement identifier = stream.Next(); break; } Statement statement = null; StatementTail tail = null; while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.OpenParenthesis: case TokenType.OpenBrace: case TokenType.OpenBracket: tail = ParseStatementTail(stream); break; case TokenType.GreaterThan: //consume greater than stream.NextNoReturn(); //might be a single child or a statement list of siblings tail = ParseSingleStatementTail(stream); break; case TokenType.Colon: //next thing must be an identifier var colon = stream.Next(); identifier = stream.Next(); statement = new EncodedOutput(_host, identifier.Content); goto checkForSiblings; case TokenType.Equal: //next thing must be an identifier var equal = stream.Next(); identifier = stream.Next(); statement = new RawOutput(_host, identifier.Content); goto checkForSiblings; default: statement = GetStatementFromToken(identifier, tail); goto checkForSiblings; } } statement = GetStatementFromToken(identifier, tail); checkForSiblings: var list = new StatementList(_host); list.Add(statement); while (stream.Peek() != null) { //Parrot.Debugger.Debug.WriteLine("Looking for siblings"); if (stream.Peek().Type == TokenType.Plus) { //it's now a statementlist not a statement stream.NextNoReturn(); var siblings = ParseStatement(stream); foreach (var sibling in siblings) { list.Add(sibling); } } else { break; } } return list; }
private StatementList ParseChildren(Stream stream) { StatementList statement = new StatementList(_host); var open = stream.Next(); CloseBracesToken close = null; while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.Plus: //ignore these? break; case TokenType.CloseBrace: //consume closing brace stream.NextNoReturn(); goto doneWithChildren; default: var statements = ParseStatement(stream); int length = statements.Count; for (int i = 0; i < length; i++) { statement.Add(statements[i]); } break; } } doneWithChildren: return statement; }
private Parameter ParseParameter(Stream stream) { var identifier = stream.Next(); switch (identifier.Type) { case TokenType.StringLiteralPipe: case TokenType.MultiLineStringLiteral: case TokenType.QuotedStringLiteral: case TokenType.StringLiteral: case TokenType.Identifier: break; default: //invalid token throw new ParserException(identifier); } //reduction return new Parameter(_host, identifier.Content); }
private Attribute ParseAttribute(Stream stream) { var identifier = stream.Next(); var equalsToken = stream.Peek() as EqualToken; if (equalsToken != null) { stream.NextNoReturn(); var valueToken = stream.Peek(); if (valueToken == null) { //TODO: Errors.Add(stream.Next()); Errors.Add(new UnexpectedToken(identifier)); return new Attribute(identifier.Content, null); //throw new ParserException(string.Format("Unexpected end of stream")); } if (valueToken.Type == TokenType.CloseBracket) { //then it's an invalid declaration Errors.Add(new AttributeValueMissing { Index = valueToken.Index }); } Statement value = ParseStatement(stream).SingleOrDefault(); //force this as an attribute type if (value == null) { } else { switch (value.Name) { case "true": case "false": case "null": value = new StringLiteral("\"" + value.Name + "\""); break; } } //reduction return new Attribute(identifier.Content, value); } //single attribute only return new Attribute(identifier.Content, null); }
private IEnumerable<StatementList> Parse(Stream stream) { while (stream.Peek() != null) { var token = stream.Peek(); switch (token.Type) { case TokenType.StringLiteral: case TokenType.StringLiteralPipe: case TokenType.QuotedStringLiteral: case TokenType.Identifier: case TokenType.OpenBracket: case TokenType.OpenParenthesis: case TokenType.Equal: case TokenType.At: var statement = ParseStatement(stream); yield return statement; break; default: Errors.Add(new UnexpectedToken(token)); stream.Next(); break; //throw new ParserException(token); } } }
private Attribute ParseAttribute(Stream stream) { var identifier = stream.Next(); var equalsToken = stream.Peek() as EqualToken; if (equalsToken != null) { stream.NextNoReturn(); var valueToken = stream.Peek(); if (valueToken == null) { throw new ParserException(string.Format("Unexpected end of stream")); } stream.NextNoReturn(); switch (valueToken.Type) { case TokenType.StringLiteralPipe: case TokenType.MultiLineStringLiteral: case TokenType.QuotedStringLiteral: case TokenType.StringLiteral: case TokenType.Identifier: //only accept tokens that are valid for attribute values break; default: //invalid token throw new ParserException(valueToken); } //reduction return new Attribute(_host, identifier.Content, valueToken.Content); } //single attribute only return new Attribute(_host, identifier.Content, null); }
/// <summary> /// Parses a token stream creating the largest statement possible /// </summary> /// <param name="stream">Stream of tokens to parse</param> /// <returns>Statement</returns> private StatementList ParseStatement(Stream stream) { var previousToken = stream.Peek(); if (previousToken == null) { Errors.Add(new EndOfStreamException()); return new StatementList(); } var tokenType = previousToken.Type; Token identifier = null; switch (tokenType) { case TokenType.Identifier: //standard identifier identifier = stream.Next(); break; case TokenType.OpenBracket: case TokenType.OpenParenthesis: //ignore these break; case TokenType.StringLiteral: case TokenType.StringLiteralPipe: case TokenType.QuotedStringLiteral: //string statement identifier = stream.Next(); break; case TokenType.At: stream.GetNextNoReturn(); identifier = stream.Next(); break; case TokenType.Equal: stream.GetNextNoReturn(); identifier = stream.Next(); break; default: Errors.Add(new UnexpectedToken(previousToken)); return new StatementList(); //throw new ParserException(stream.Peek()); } Statement statement; StatementTail tail = null; while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.OpenParenthesis: case TokenType.OpenBracket: case TokenType.OpenBrace: tail = ParseStatementTail(stream); break; case TokenType.GreaterThan: //consume greater than stream.NextNoReturn(); //might be a single child or a statement list of siblings tail = ParseSingleStatementTail(stream, tail); break; case TokenType.StringLiteralPipe: if (previousToken is StringLiteralPipeToken) { //if the previous token was a string literal pipe then we don't continue processing goto default; } //this overrides all previous tail elements tail = ParseSingleStatementTail(stream, tail); break; default: GetStatementFromToken(identifier, tail); goto checkForSiblings; } } checkForSiblings: statement = GetStatementFromToken(identifier, tail, previousToken); var list = new StatementList(); list.Add(statement); while (stream.Peek() != null) { //Parrot.Debugger.Debug.WriteLine("Looking for siblings"); if (stream.Peek().Type == TokenType.Plus) { //it's now a statementlist not a statement stream.NextNoReturn(); var siblings = ParseStatement(stream); foreach (var sibling in siblings) { list.Add(sibling); } } else { break; } } return list; }
private ParameterList ParseParameters(Stream stream) { var parameterList = new ParameterList(); //( parameterlist ) var open = stream.Next(); while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.Identifier: case TokenType.QuotedStringLiteral: case TokenType.StringLiteralPipe: parameterList.Add(ParseParameter(stream)); break; case TokenType.Comma: //another parameter - consume this stream.NextNoReturn(); break; case TokenType.CloseParenthesis: //consume close parenthesis stream.NextNoReturn(); goto doneWithParameter; default: //read until ) Errors.Add(new UnexpectedToken(token)); return parameterList; //throw new ParserException(token); } } doneWithParameter: return parameterList; }
private Parameter ParseParameter(Stream stream) { var identifier = stream.Next(); switch (identifier.Type) { case TokenType.StringLiteralPipe: case TokenType.QuotedStringLiteral: case TokenType.StringLiteral: case TokenType.Identifier: break; default: //invalid token Errors.Add(new UnexpectedToken(identifier)); //throw new ParserException(identifier); return null; } //reduction return new Parameter(identifier.Content); }
private StatementList ParseChild(Stream stream) { var child = new StatementList(); stream.Next(); var token = stream.Peek(); if (token != null) { var statements = ParseStatement(stream); foreach (var statement in statements) { child.Add(statement); } } return child; }
private AttributeList ParseAttributes(Stream stream) { var attributes = new AttributeList(_host); var open = stream.Next(); Token token = null; //expecting identifier while (stream.Peek() != null) { token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.Identifier: attributes.Add(ParseAttribute(stream)); break; case TokenType.CloseBracket: //consume close bracket stream.NextNoReturn(); goto doneWithAttribute; default: //invalid token throw new ParserException(token); } } doneWithAttribute: if (attributes.Count == 0) { //must be empty attribute list throw new ParserException(token); } //do reduction here return attributes; }
private StatementList ParseChild(Stream stream) { var child = new StatementList(_host); var open = stream.Next(); while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { default: var statements = ParseStatement(stream); foreach (var statement in statements) { child.Add(statement); } goto doneWithChildren; } } doneWithChildren: return child; }