Ast.IExpression ParseAddOp(ParseTreeNode node)
{
if (node.Term.Name == "AddOp")
{
ParseTreeNode left = node.ChildNodes[0];
Ast.IExpression lexpr = ParseMulOp(left);
if (node.ChildNodes[1].ChildNodes.Count == 0)
{
return(lexpr);
}
string opstring = node.ChildNodes[1].ChildNodes[0].ChildNodes[0].Token.ValueString;
Ast.BinaryOp op;
switch (opstring)
{
case "+":
op = Ast.BinaryOp.Addition; break;
case "-":
op = Ast.BinaryOp.Subtraction; break;
default:
throw new Exception("Invalid operator");
}
ParseTreeNode right = node.ChildNodes[1].ChildNodes[1];
Ast.IExpression rexpr = ParseMulOp(right);
return(new Ast.BinaryExpression()
{
Left = lexpr, Right = rexpr, Operation = op
});
}
throw new Exception("Invalid AddOp node");
}
Ast.FunctionCall ParseFunctionCall(ParseTreeNode node)
{
if (node.Term.Name == "FunctionCall")
{
Ast.IExpression expr = ParsePrefix(node.ChildNodes[0]);
Ast.FunctionCall call = new Ast.FunctionCall();
call.Arguments = new List <Ast.IExpression>();
call.Function = expr;
var root = node.ChildNodes[1].ChildNodes[0];
if (root.ChildNodes.Count != 0)
{
root = root.ChildNodes[0];
while (true)
{
call.Arguments.Add(ParseExpression(root.ChildNodes[0]));
if (root.ChildNodes.Count == 1)
{
break;
}
else
{
root = root.ChildNodes[1];
}
}
}
return(call);
}
throw new Exception("Invalid FunctionCall node");
}
Ast.UnaryExpression ParseUnaryExpr(ParseTreeNode node)
{
if (node.Term.Name == "UnaryExpr")
{
Ast.IExpression expr = ParseExpression(node.ChildNodes[1]);
var opNode = node.ChildNodes[0].ChildNodes[0];
Ast.UnaryOp op = Ast.UnaryOp.Invert;
switch (opNode.Token.ValueString)
{
case "not":
op = Ast.UnaryOp.Negate; break;
case "-":
op = Ast.UnaryOp.Invert; break;
case "#":
op = Ast.UnaryOp.Length; break;
}
return(new Ast.UnaryExpression()
{
Expression = expr,
Operation = op
});
}
throw new Exception("Invalid UnaryExpr node");
}
Ast.IAssignable ParseVariable(ParseTreeNode node)
{
if (node.Term != null)
{
if (node.ChildNodes.Count == 1)
{
string name = node.ChildNodes[0].Token.ValueString;
return(new Ast.Variable()
{
Name = name
});
}
else
{
Ast.IExpression prefix = ParsePrefix(node.ChildNodes[0]);
if (node.ChildNodes[1].Term.Name == "Expression")
{
Ast.IExpression index = ParseExpression(node.ChildNodes[1]);
return(new Ast.TableAccess()
{
Expression = prefix, Index = index
});
}
else
{
string name = node.ChildNodes[1].Token.ValueString;
return(new Ast.Variable()
{
Name = name, Prefix = prefix
});
}
}
}
throw new Exception("Invalid Variable node");
}
Ast.FunctionCall ParseOopCall(ParseTreeNode node)
{
if (node.Term.Name == "OopCall")
{
Ast.IExpression expr = ParsePrefix(node.ChildNodes[0]);
string name = node.ChildNodes[1].Token.ValueString;
Ast.FunctionCall call = new Ast.FunctionCall();
call.Arguments.Add(expr);
call.Function = new Ast.Variable()
{
Name = name, Prefix = expr
};
var root = node.ChildNodes[2].ChildNodes[0];
if (root.ChildNodes.Count != 0)
{
root = root.ChildNodes[0];
while (true)
{
call.Arguments.Add(ParseExpression(root.ChildNodes[0]));
if (root.ChildNodes.Count == 1)
{
break;
}
else
{
root = root.ChildNodes[1];
}
}
}
return(call);
}
throw new Exception("Invalid OopCall node");
}
private Ast.IExpression ParseCallExpression(Ast.IExpression function)
{
var exp = new Ast.CallExpression
{
Token = _curToken,
Function = function,
Arguments = ParseExpressionList(TokenType.Rparen)
};
return(exp);
}
Ast.RepeatStat ParseRepeat(ParseTreeNode node)
{
if (node.Term.Name == "Repeat")
{
Ast.Block block = ParseBlock(node.ChildNodes[1]);
Ast.IExpression condition = ParseExpression(node.ChildNodes[3]);
return(new Ast.RepeatStat()
{
Block = block,
Condition = condition
});
}
throw new Exception("Invalid Repeat node");
}
private Ast.IExpression ParseIndexExpression(Ast.IExpression left)
{
var exp = new Ast.IndexExpression {
Token = _curToken, Left = left
};
NextToken();
exp.Index = ParseExpression(Precedence.Lowest);
if (!ExpectPeek(TokenType.Rbracket))
{
return(null);
}
return(exp);
}
private Ast.IExpression ParseInfixExpression(Ast.IExpression left)
{
var expression = new Ast.InfixExpression
{
Token = _curToken,
Operator = _curToken.Literal,
Left = left
};
var precedence = CurPrecedence();
NextToken();
expression.Right = ParseExpression(precedence);
return(expression);
}
Ast.IExpression ParseRelOp(ParseTreeNode node)
{
if (node.Term.Name == "RelOp")
{
ParseTreeNode left = node.ChildNodes[0];
Ast.IExpression lexpr = ParseConcatOp(left);
if (node.ChildNodes[1].ChildNodes.Count == 0)
{
return(lexpr);
}
string opstring = node.ChildNodes[1].ChildNodes[0].ChildNodes[0].Token.ValueString;
Ast.BinaryOp op;
switch (opstring)
{
case ">":
op = Ast.BinaryOp.GreaterThan; break;
case ">=":
op = Ast.BinaryOp.GreaterOrEqual; break;
case "<":
op = Ast.BinaryOp.LessThan; break;
case "<=":
op = Ast.BinaryOp.LessOrEqual; break;
case "==":
op = Ast.BinaryOp.Equal; break;
case "~=":
op = Ast.BinaryOp.Different; break;
default:
throw new Exception("Invalid operator");
}
ParseTreeNode right = node.ChildNodes[1].ChildNodes[1];
Ast.IExpression rexpr = ParseConcatOp(right);
return(new Ast.BinaryExpression()
{
Left = lexpr, Right = rexpr, Operation = op
});
}
throw new Exception("Invalid RelOp node");
}
Ast.IExpression ParseAndOp(ParseTreeNode node)
{
if (node.Term.Name == "AndOp")
{
ParseTreeNode left = node.ChildNodes[0];
Ast.IExpression lexpr = ParseRelOp(left);
if (node.ChildNodes[1].ChildNodes.Count == 0)
{
return(lexpr);
}
ParseTreeNode right = node.ChildNodes[1].ChildNodes[1];
Ast.IExpression rexpr = ParseRelOp(right);
return(new Ast.BinaryExpression()
{
Left = lexpr, Right = rexpr, Operation = Ast.BinaryOp.And
});
}
throw new Exception("Invalid AndOp node");
}
private Ast.AssignExpression ParseAssignExpression(Ast.IExpression left)
{
if (left.GetType() != typeof(Ast.Identifier))
{
var msg = $"{_peekToken.TokenPosition()} expected identifier on left but got {left}";
Errors.Add(msg);
return(null);
}
var expression = new Ast.AssignExpression
{
Token = _curToken,
Name = (Ast.Identifier)left
};
NextToken();
expression.Value = ParseExpression(Precedence.Lowest);
return(expression);
}
Ast.IExpression ParsePowerOp(ParseTreeNode node)
{
if (node.Term.Name == "PowerOp")
{
ParseTreeNode left = node.ChildNodes[0];
Ast.IExpression lexpr = ParseExpression(left);
if (node.ChildNodes[1].ChildNodes.Count == 0)
{
return(lexpr);
}
ParseTreeNode right = node.ChildNodes[1].ChildNodes[1];
Ast.IExpression rexpr = ParseExpression(right);
return(new Ast.BinaryExpression()
{
Span = node.Span, Left = lexpr, Right = rexpr, Operation = Ast.BinaryOp.Power
});
}
throw new Exception("Invalid PowerOp node");
}
Ast.IfStat ParseIf(ParseTreeNode node)
{
if (node.Term.Name == "If")
{
Ast.IExpression condition = ParseExpression(node.ChildNodes[1]);
Ast.Block block = ParseBlock(node.ChildNodes[3]);
Ast.IfStat If = new Ast.IfStat();
If.Block = block;
If.Condition = condition;
If.ElseIfs = new List <Ast.IfStat>();
If.Span = node.Span;
ParseTreeNode ElseifNode = node.ChildNodes[4];
ParseTreeNode ElseNode = node.ChildNodes[5];
while (ElseifNode.ChildNodes.Count != 0)
{
var childnode = ElseifNode.ChildNodes[0];
Ast.IfStat elseif = new Ast.IfStat();
elseif.Span = childnode.Span;
elseif.Condition = ParseExpression(childnode.ChildNodes[1]);
elseif.Block = ParseBlock(childnode.ChildNodes[3]);
If.ElseIfs.Add(elseif);
ElseifNode = childnode.ChildNodes[4];
}
if (ElseNode.ChildNodes.Count != 0)
{
If.ElseBlock = ParseBlock(ElseNode.ChildNodes[0].ChildNodes[1]);
}
return(If);
}
throw new Exception("Invalid If node");
}
Ast.IExpression ParseConcatOp(ParseTreeNode node)
{
if (node.Term.Name == "ConcatOp")
{
ParseTreeNode left = node.ChildNodes[0];
Ast.IExpression lexpr = ParseAddOp(left);
if (node.ChildNodes[1].ChildNodes.Count == 0)
{
return(lexpr);
}
string opstring = node.ChildNodes[1].ChildNodes[0].Token.ValueString;
Ast.BinaryOp op = Ast.BinaryOp.Concat;
ParseTreeNode right = node.ChildNodes[1].ChildNodes[1];
Ast.IExpression rexpr = ParseAddOp(right);
return(new Ast.BinaryExpression()
{
Left = lexpr, Right = rexpr, Operation = op
});
}
throw new Exception("Invalid ConcatOp node");
}
Ast.IExpression ParseMulOp(ParseTreeNode node)
{
if (node.Term.Name == "MulOp")
{
ParseTreeNode left = node.ChildNodes[0];
Ast.IExpression lexpr = ParsePowerOp(left);
if (node.ChildNodes[1].ChildNodes.Count == 0)
{
return(lexpr);
}
string opstring = node.ChildNodes[1].ChildNodes[0].ChildNodes[0].Token.ValueString;
Ast.BinaryOp op;
switch (opstring)
{
case "*":
op = Ast.BinaryOp.Multiplication; break;
case "/":
op = Ast.BinaryOp.Division; break;
case "%":
op = Ast.BinaryOp.Modulo; break;
default:
throw new Exception("Invalid operator");
}
ParseTreeNode right = node.ChildNodes[1].ChildNodes[1];
Ast.IExpression rexpr = ParsePowerOp(right);
return(new Ast.BinaryExpression()
{
Span = node.Span, Left = lexpr, Right = rexpr, Operation = op
});
}
throw new Exception("Invalid MulOp node");
}
Ast.TableConstructor ParseTableConstruct(ParseTreeNode node)
{
if (node.Term.Name == "TableConstruct")
{
if (node.ChildNodes.Count == 0)
{
return(new Ast.TableConstructor()
{
Values = new Dictionary <Ast.IExpression, Ast.IExpression>()
});
}
else
{
var child = node.ChildNodes[0];
Ast.TableConstructor t = new Ast.TableConstructor();
t.Values = new Dictionary <Ast.IExpression, Ast.IExpression>();
int i = 1;
while (true)
{
if (child.ChildNodes.Count == 0)
{
break;
}
var value = child.ChildNodes[0];
if (value.ChildNodes.Count == 1)
{
t.Values.Add(new Ast.NumberLiteral()
{
Value = i
}, ParseExpression(value.ChildNodes[0]));
i++;
}
else
{
var prefix = value.ChildNodes[0];
Ast.IExpression key;
if (prefix.ChildNodes[0].Term.Name == "identifier")
{
key = new Ast.StringLiteral()
{
Value = prefix.ChildNodes[0].Token.ValueString
}
}
;
else
{
key = ParseExpression(prefix.ChildNodes[0]);
}
var expr = value.ChildNodes[1];
Ast.IExpression val = ParseExpression(expr);
t.Values.Add(key, val);
}
//child = child.ChildNodes[1].ChildNodes[0];
child = child.ChildNodes[1];
if (child.ChildNodes.Count == 0)
{
break;
}
child = child.ChildNodes[0];
}
return(t);
}
}
throw new Exception("Invalid TableConstruct node");
}
