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;
}
