public void Parser_CanParseFunctionLiteral()
{
string input = @"
fn(x, y) { x + y; }
";
AST result = this.subject.ParseProgram(input);
Assert.Empty(result.Errors);
Assert.Equal(1, result.Program.Statements.Count);
ExpressionStatement actual = this.AssertAndCast <ExpressionStatement>(result.Program.Statements[0]);
FunctionLiteral fnExpression = this.AssertAndCast <FunctionLiteral>(actual.Expression);
Assert.Equal(2, fnExpression.Parameters.Count);
Identifier paramExpr = this.AssertAndCast <Identifier>(fnExpression.Parameters[0]);
Assert.Equal("x", paramExpr.Value);
paramExpr = this.AssertAndCast <Identifier>(fnExpression.Parameters[1]);
Assert.Equal("y", paramExpr.Value);
Assert.Equal(1, fnExpression.Body.Statements.Count);
ExpressionStatement body = this.AssertAndCast <ExpressionStatement>(fnExpression.Body.Statements[0]);
InfixExpression bodyExpr = this.AssertAndCast <InfixExpression>(body.Expression);
Assert.Equal("x", bodyExpr.Left.TokenLiteral);
Assert.Equal(TokenType.Plus, bodyExpr.Operator);
Assert.Equal("y", bodyExpr.Right.TokenLiteral);
}
private Object evalInfixExpression(InfixExpression infixExpression)
{
var context = ExecutionContext.Peek();
var left = Eval(context, infixExpression.Left);
var right = Eval(context, infixExpression.Right);
Object result = null;
switch (infixExpression.Operator.Type)
{
case Token.TokenType.Equal:
result = new Bool(left.Same(right));
break;
case Token.TokenType.NotEqual:
result = new Bool(!left.Same(right));
break;
case Token.TokenType.Plus:
result = left.Add(right);
break;
default: break;
}
return(result);
}
private string buildInfixExpression(InfixExpression infixExpression)
{
var result = "";
result += Build(infixExpression.Left) + " ";
result += infixExpression.Operator.Literal + " ";
result += Build(infixExpression.Right);
return(result);
}
private IExpression parseInfixExpression(IExpression left)
{
var expression = new InfixExpression(currentToken, currentToken.Literal, left);
var precedence = CurrentPrecedence();
NextToken();
expression.Right = ParseExpression(precedence);
return(expression);
}
private IExpression ParseInfixExpression(IExpression left)
{
var exp = new InfixExpression {
Token = CurToken, Left = left, Operator = CurToken.Literal
};
var precedence = CurPrecedence();
NextToken();
exp.Right = ParseExpression(precedence);
return(exp);
}
private Expression ParseInfixExpression(Expression left)
{
InfixExpression exp = new InfixExpression {
Token = this._curToken,
Operator = this._curToken.Literal,
Left = left,
};
Precedence prece = this.CurPrecedence();
this.NextToken();
exp.Right = this.ParseExpression(prece);
return(exp);
}
public async Task CalcCommand(SocketMessage message, [FullText] string expression)
{
var expr = new InfixExpression(expression);
try
{
var value = expr.Evaluate(null);
await message.Channel.SendMessageAsync($"{value}");
}
catch (Exception)
{
await message.Channel.SendMessageAsync("Sorry, I can't calculate that");
}
}
private Expression ParseInfixExpression(Expression left)
{
InfixExpression exp = new InfixExpression
{
Left = left,
Token = _currentToken,
Operator = _currentToken.Literal,
};
Precedence precedence = _precedences[_currentToken.Type];
ReadNextToken();
exp.Right = ParseExpression(precedence);
return(exp);
}
public IExpression ParseInfixExpression(IExpression left)
{
var expression = new InfixExpression()
{
Token = this.CurrentToken,
Operator = this.CurrentToken.Literal,
Left = left,
};
var precedence = this.CurrentPrecedence;
this.ReadToken();
expression.Right = this.ParseExpression(precedence);
return(expression);
}
private IExpression ParseInfixExpression(IExpression left)
{
var expr = new InfixExpression
{
Token = currentToken,
Operator = currentToken.Literal,
Left = left
};
var precedence = CurrentPrecedence();
// skip current token
NextToken();
expr.Right = ParseExpression(precedence);
return(expr);
}
public static Object.Object EvalInfixExpression(InfixExpression expression)
{
Object.Object left = Eval(expression.Left);
Object.IntegerObject leftInteger = left as Object.IntegerObject;
if(leftInteger == null)
{
throw new Exception("Infix expression left branch is not Object.IntegerObject");
}
Object.Object right = Eval(expression.Right);
Object.IntegerObject rightInteger = right as Object.IntegerObject;
if(rightInteger == null)
{
throw new Exception("Infix expression right branch is not Object.IntegerObject");
}
return InfixExpression(leftInteger, expression.Operator, rightInteger);
}
private IExpression ParseInfixExpression(IExpression left)
{
var expression = new InfixExpression
{
Token = _currentToken,
Operator = _currentToken.Literal,
Left = left
};
var precedense = CurPrecedence();
NextToken();
expression.Right = ParseExpression(precedense);
return(expression);
}
public void Parser_CanParseInfixExpressions(string input, int expectedLeft, TokenType expectedOp, int expectedRight)
{
AST result = this.subject.ParseProgram(input);
Assert.Equal(1, result.Program.Statements.Count);
Assert.Empty(result.Errors);
ExpressionStatement stmt = this.AssertAndCast <ExpressionStatement>(result.Program.Statements[0]);
InfixExpression exp = this.AssertAndCast <InfixExpression>(stmt.Expression);
Assert.Equal(expectedOp, exp.Operator);
IntegerLiteral intExpression = this.AssertAndCast <IntegerLiteral>(exp.Left);
Assert.Equal(expectedLeft, intExpression.Value);
intExpression = this.AssertAndCast <IntegerLiteral>(exp.Right);
Assert.Equal(expectedRight, intExpression.Value);
}
private ExpressionNode ParseInfixExpression(ExpressionNode left)
{
if (TokenPrecedence == 0) // all infix tokens have binding powers
{
UnexpectedToken();
}
switch (Token)
{
case TokenType.ARROW:
return(ParseArrowFunction(left));
case TokenType.PERIOD:
return(ParseStaticLookupExpression(left));
case TokenType.LPAREN:
return(ParseInvocationExpression(left));
case TokenType.LBRACK:
return(ParseDynamicLookupExpression(left));
case TokenType.CONDITIONAL:
return(ParseConditionalExpression(left));
case TokenType.ASSIGN:
case TokenType.ASSIGN_ADD:
case TokenType.ASSIGN_DIV:
case TokenType.ASSIGN_MOD:
case TokenType.ASSIGN_MUL:
case TokenType.ASSIGN_SUB:
return(ParseAssignmentExpression(left));
default: {
InfixExpression ret = NewNode <InfixExpression>();
ret.Left = left;
int precedence = TokenPrecedence;
NextToken();
ret.Right = ParseExpression(precedence);
return(ret);
}
}
}
public void Parser_CanParseArrayLiterals()
{
string input = @"[1, 2 * 2, 3 + 3]";
AST result = this.subject.ParseProgram(input);
Assert.Empty(result.Errors);
Assert.Equal(1, result.Program.Statements.Count);
ExpressionStatement expr = this.AssertAndCast <ExpressionStatement>(result.Program.Statements[0]);
ArrayLiteral arrayResult = this.AssertAndCast <ArrayLiteral>(expr.Expression);
Assert.Equal(3, arrayResult.Elements.Count);
IntegerLiteral intLiteral = this.AssertAndCast <IntegerLiteral>(arrayResult.Elements[0]);
Assert.Equal(1, intLiteral.Value);
InfixExpression exprLiteral = this.AssertAndCast <InfixExpression>(arrayResult.Elements[1]);
Assert.Equal("(2 * 2)", exprLiteral.StringValue);
exprLiteral = this.AssertAndCast <InfixExpression>(arrayResult.Elements[2]);
Assert.Equal("(3 + 3)", exprLiteral.StringValue);
}
private static bool HasDerivative(InfixExpression node)
{
return(HasDerivative(node.Left) || HasDerivative(node.Right));
}
private void CompileInfixExpression(InstructionSet instructionSet, InfixExpression node, Scope scope, LocalTable table)
{
CompileExpression(instructionSet, node.Left, scope, table);
CompileExpression(instructionSet, node.Right, scope, table);
instructionSet.Define(InstructionType.Send, node.Operator, "1");
}
private Expression CompileInfixExpression(InfixExpression node)
{
ValueTypes NeededType;
switch (node.Token)
{
case TokenType.EQ:
case TokenType.NE:
NeededType = ValueTypes.BOXED;
break;
case TokenType.COMMA:
NeededType = ValueTypes.VOID;
break;
case TokenType.OR:
case TokenType.AND:
NeededType = ValueTypes.BOOL;
break;
case TokenType.ADD:
case TokenType.SUB:
case TokenType.MUL:
case TokenType.DIV:
case TokenType.MOD:
case TokenType.LT:
case TokenType.GT:
case TokenType.LTE:
case TokenType.GTE:
NeededType = ValueTypes.DOUBLE;
break;
default:
throw new Exception(String.Format("Encounterd an impossible infix operator {0}", node.Token));
}
Expression Left = CompileExpression(node.Left, NeededType);
Expression Right = CompileExpression(node.Right, NeededType);
switch (node.Token)
{
case TokenType.COMMA:
return(Expression.Block(Left, Right));
case TokenType.OR:
return(Expression.OrElse(Left, Right));
case TokenType.AND:
return(Expression.AndAlso(Left, Right));
case TokenType.ADD:
return(Expression.Add(Left, Right));
case TokenType.SUB:
return(Expression.Subtract(Left, Right));
case TokenType.DIV:
return(Expression.Divide(Left, Right));
case TokenType.MUL:
return(Expression.Multiply(Left, Right));
case TokenType.MOD:
return(Expression.Modulo(Left, Right));
case TokenType.EQ:
return(Expression.Equal(Left, Right));
case TokenType.NE:
return(Expression.NotEqual(Left, Right));
case TokenType.LT:
return(Expression.LessThan(Left, Right));
case TokenType.GT:
return(Expression.GreaterThan(Left, Right));
case TokenType.LTE:
return(Expression.LessThanOrEqual(Left, Right));
case TokenType.GTE:
return(Expression.GreaterThanOrEqual(Left, Right));
default:
throw new Exception(String.Format("Encounterd an impossible infix operator {0}", node.Token));
}
}
/// <summary>
/// This method converts infix to postfix notation
/// </summary>
/// <returns></returns>
public string Convert()
{
//this stack holds the operators
Stack <Operator> operator_stack = new Stack <Operator>();
//this stack check for correct parenthesis
Stack <String> parenthesis_check = new Stack <string>();
//this array of strings holds each "word" or "letter" or "symbol/operator" or etc.
String[] fields = InfixExpression.Split(' ');
//this loop makes sure there there is correct pairing of parenthesis
for (int i = 0; i < fields.Length; i++)
{
if (fields[i] == "(")
{
parenthesis_check.Push("(");
}
else if (fields[i] == ")")
{
parenthesis_check.Pop();
}
}
//if the parenthesis stack isn't empty, something went wrong
if (parenthesis_check.Count != 0)
{
MessageBox.Show("Error with expression, check for possible missing parenthesis", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return("");
}
//this for loop reads each field one at a time
for (int i = 0; i < fields.Length; i++)
{
//this adds fields that aren't operators to the output string
if (!IsOperatorSymbol(fields[i]) && fields[i] != ")")
{
PostfixExpression += fields[i] + " ";
}
//this pushes operators to the operator stack
else if (IsOperatorSymbol(fields[i]))
{
//if it is not a ( or ) and the stack's count is not 0
if (!fields[i].Equals("(") && !fields[i].Equals(")") && operator_stack.Count != 0)
{
//loop until lower precedence or ( are found. Pops a item off stack and adds to output string
while ((new Operator(operator_stack.Peek().ToString())).Precedence >= (new Operator(fields[i]).Precedence) && !operator_stack.Peek().ToString().Equals("("))
{
PostfixExpression += operator_stack.Pop() + " ";
if (operator_stack.Count == 0)
{
break; //if the stack is empty break out of the loop
}
}
operator_stack.Push(new Operator(fields[i])); //push the new operator onto the stack
}
else
{
operator_stack.Push(new Operator(fields[i]));
}
}
//Upon finding a close parenthesis, the stack is popped and added to the output string until the opening parenthesis is found. Then the opening parenthesis is popped off.
else if (fields[i].Equals(")"))
{
try
{
//while the top of that stack isn't a (
while (operator_stack.Peek().ToString() != "(")
{
//if the operator on top isn't a (, pop it and add it to the output string
if (!(operator_stack.Peek().ToString() == "("))
{
PostfixExpression += operator_stack.Pop() + " ";
}
}
//pop the ( from the stack
operator_stack.Pop();
}
catch (Exception exc)
{
MessageBox.Show("Error with expression, check for possible missing parenthesis", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
//This pops the rest of the operators off the stack and adds them to the output string
}
while (operator_stack.Count > 0)
{
PostfixExpression += operator_stack.Pop() + " ";
}
return(PostfixExpression);
}
