public CallCommand(Identifier identifier, ParameterSequence parameters, SourcePosition position)
: base(position)
{
Compiler.WriteDebuggingInfo($"Creating {this.GetType().Name}");
Identifier = identifier;
Parameters = parameters;
}
///////////////////////////////////////////////////////////////////////////////
//
// PARAMETERS
//
///////////////////////////////////////////////////////////////////////////////
ParameterSequence ParseParameters()
{
Compiler.WriteDebuggingInfo("Parsing Parameters");
Location startLocation = tokens.Current.Position.Start;
if (tokens.Current.Kind == TokenKind.RightBracket)
{
SourcePosition parameterPosition = new SourcePosition(startLocation, tokens.Current.Position.Finish);
return(new EmptyParameterSequence(parameterPosition));
}
Parameter parameter = ParseParameter();
if (tokens.Current.Kind == TokenKind.Comma)
{
AcceptIt();
ParameterSequence paramseq = ParseParameters();
//Parameter parameter2 = ParseParameters();
SourcePosition parameterPosition = new SourcePosition(startLocation, tokens.Current.Position.Finish);
return(new MultipleParameterSequence(parameter, paramseq, parameterPosition));
}
else
{
SourcePosition parameterPosition = new SourcePosition(startLocation, tokens.Current.Position.Finish);
return(new SingleParameterSequence(parameter, parameterPosition));
}
}
///////////////////////////////////////////////////////////////////////////////
// PARAMETERS
///////////////////////////////////////////////////////////////////////////////
private ParameterSequence ParseParameters()
{
Compiler.WriteDebuggingInfo("Parsing Parameters");
Location startLocation = tokens.Current.Start;
/*
* if(tokens.Current.Kind == TokenKind.RightBracket)
* return new EmptyParameterSequence(new SourcePosition(startLocation, tokens.Current.Finish));
* ParameterSequence ps = new SingleParameterSequence(ParseParameter(), new SourcePosition(startLocation, tokens.Current.Finish));
* while(tokens.Current.Kind == TokenKind.Comma) {
* AcceptIt();
* ps = new MultipleParameterSequence(ParseParameter(), ps, new SourcePosition(startLocation, tokens.Current.Finish));
* }
* return ps;
*/
Parameter p = ParseParameter();
if (tokens.Current.Kind == TokenKind.Comma)
{
AcceptIt();
ParameterSequence ps = ParseParameters();
SourcePosition parameterPosition = new SourcePosition(startLocation, tokens.Current.Position.Finish);
return(new MultipleParameterSequence(p, ps, parameterPosition));
}
else
{
SourcePosition parameterPosition = new SourcePosition(startLocation, tokens.Current.Position.Finish);
return(new SingleParameterSequence(p, parameterPosition));
}
}
public MultipleParameterSequence(Parameter parameter, ParameterSequence parameters,
SourcePosition position)
: base(position)
{
Compiler.WriteDebuggingInfo($"Creating {this.GetType().Name}");
Parameter = parameter;
Parameters = parameters;
}
///////////////////////////////////////////////////////////////////////////////
//
// PARAMETERS
//
///////////////////////////////////////////////////////////////////////////////
ParameterSequence ParseParameters()
{
Compiler.WriteDebuggingInfo("Parsing Parameters");
Location startLocation = tokens.Current.Position.Start;
Parameter p = ParseParameter();
if (tokens.Current.Kind == TokenKind.Comma)
{
AcceptIt();
ParameterSequence p2 = ParseParameters();
SourcePosition parameterPosition = new SourcePosition(startLocation, tokens.Current.Position.Finish);
return(new MultipleParameterSequence(p, p2, parameterPosition));
}
else
{
SourcePosition parameterPosition = new SourcePosition(startLocation, tokens.Current.Position.Finish);
return(new SingleParameterSequence(p, parameterPosition));
}
}
/// Parses the single command, and constructs an AST to represent its phrase structure.
/// @returns a {@link triangle.compiler.syntax.trees.commands.Command}
/// @throw syntaxError
private Command ParseSingleCommand()
{
Compiler.WriteDebuggingInfo("Parsing Single Command");
Location startLocation = tokens.Current.Start;
switch (tokens.Current.Kind)
{
case TokenKind.Identifier: {
Compiler.WriteDebuggingInfo("Parsing Assignment Command or Call Command");
Identifier identifier = ParseIdentifier();
if (tokens.Current.Kind == TokenKind.LeftBracket)
{
Compiler.WriteDebuggingInfo("Parsing Call Command");
AcceptIt();
ParameterSequence parameters = ParseParameters();
Accept(TokenKind.RightBracket);
return(new CallCommand(identifier, parameters, new SourcePosition(startLocation, tokens.Current.Finish)));
}
else if (tokens.Current.Kind == TokenKind.Becomes)
{
Compiler.WriteDebuggingInfo("Parsing Assignment Command");
Accept(TokenKind.Becomes);
Expression expression = ParseExpression();
return(new AssignCommand(identifier, expression, new SourcePosition(startLocation, tokens.Current.Finish)));
}
else
{
RaiseSyntacticError("Expected either an assignment or function call but found a \"%\"", tokens.Current);
return(null);
}
}
case TokenKind.Begin: {
Compiler.WriteDebuggingInfo("Parsing Begin Command");
AcceptIt();
Command command = ParseCommand();
Accept(TokenKind.End);
return(command);
}
case TokenKind.Let: {
Compiler.WriteDebuggingInfo("Parsing Let Command");
AcceptIt();
Declaration declaration = ParseDeclaration();
Accept(TokenKind.In);
Command c = ParseSingleCommand();
SourcePosition commandPosition = new SourcePosition(startLocation, tokens.Current.Finish);
return(new LetCommand(declaration, c, commandPosition));
}
case TokenKind.If: {
Compiler.WriteDebuggingInfo("Parsing If Command");
AcceptIt();
var e = ParseExpression();
Accept(TokenKind.Then);
var tc = ParseSingleCommand();
Accept(TokenKind.Else);
var fc = ParseSingleCommand();
SourcePosition commandPosition = new SourcePosition(startLocation, tokens.Current.Finish);
return(new IfCommand(e, tc, fc, commandPosition));
}
case TokenKind.While: {
Compiler.WriteDebuggingInfo("Parsing While Command");
AcceptIt();
var e = ParseExpression();
Accept(TokenKind.Do);
var c = ParseSingleCommand();
SourcePosition commandPosition = new SourcePosition(startLocation, tokens.Current.Finish);
return(new WhileCommand(e, c, commandPosition));
}
case TokenKind.Skip: {
Compiler.WriteDebuggingInfo("Parsing Skip Command");
AcceptIt();
SourcePosition commandPosition = new SourcePosition(startLocation, tokens.Current.Finish);
return(new SkipCommand(commandPosition));
}
default:
RaiseSyntacticError("\"%\" cannot start a command", tokens.Current);
return(null);
}
}
/// <summary>
/// Parses the primary expression, and constructs an AST to represent its
/// phrase structure.
/// </summary>
/// <returns>
/// an <link>Triangle.SyntaxTrees.Expressions.Expression</link>
/// </returns>
/// <throws type="SyntaxError">
/// a syntactic error
/// </throws>
Expression ParsePrimaryExpression()
{
Compiler.WriteDebuggingInfo("Parsing Primary Expression");
Location startLocation = tokens.Current.Start;
switch (tokens.Current.Kind)
{
case TokenKind.IntLiteral:
{
Compiler.WriteDebuggingInfo("Parsing Int Expression");
IntegerLiteral integer = ParseIntegerLiteral();
SourcePosition expressionPos = new SourcePosition(startLocation, tokens.Current.Finish);
return(new IntegerExpression(integer, expressionPos));
}
case TokenKind.CharLiteral:
{
Compiler.WriteDebuggingInfo("Parsing Char Expression");
CharacterLiteral charlit = ParseCharacterLiteral();
SourcePosition expressionPos = new SourcePosition(startLocation, tokens.Current.Finish);
return(new CharacterExpression(charlit, expressionPos));
}
case TokenKind.Identifier:
{
Compiler.WriteDebuggingInfo("Parsing Call Expression or Identifier Expression");
Identifier identifier = ParseIdentifier();
if (tokens.Current.Kind == TokenKind.LeftBracket)
{
Compiler.WriteDebuggingInfo("Parsing Call Expression");
AcceptIt();
ParameterSequence parameterSequence = ParseParameters();
Accept(TokenKind.RightBracket);
SourcePosition expressionPos = new SourcePosition(startLocation, tokens.Current.Finish);
return(new CallExpression(identifier, parameterSequence, expressionPos));
}
else
{
Compiler.WriteDebuggingInfo("Parsing Identifier Expression");
SourcePosition expressionPos = new SourcePosition(startLocation, tokens.Current.Finish);
return(new IdExpression(identifier, expressionPos));
}
}
case TokenKind.Operator:
{
Compiler.WriteDebuggingInfo("Parsing Unary Expression");
Operator operat = ParseOperator();
Expression expression = ParsePrimaryExpression();
SourcePosition expressionPos = new SourcePosition(startLocation, tokens.Current.Finish);
return(new UnaryExpression(operat, expression, expressionPos));
}
case TokenKind.LeftBracket:
{
Compiler.WriteDebuggingInfo("Parsing Bracket Expression");
AcceptIt();
Expression expression = ParseExpression();
Accept(TokenKind.RightBracket);
return(expression);
}
default:
{
RaiseSyntacticError("\"%\" cannot start an expression", tokens.Current);
return(null);
}
}
}
