private LLVMValueRef GenerateBinaryExpression(BinaryExpression expression, LLVMBuilderRef builder)
{
string op = expression.Operator;
LLVMValueRef rhs = GenerateExpression(expression.Rhs, builder);
if (op.Equals("="))
{
Expression binLhs = expression.Lhs;
if (binLhs == null
||
(binLhs.ExpressionType != ExpressionType.Identifier &&
binLhs.ExpressionType != ExpressionType.Declaration))
{
// only can store to variable.
throw new Exception("invalid, need to decide what to do for error stuff.");
}
LLVMValueRef inst;
if (binLhs.ExpressionType == ExpressionType.Identifier)
{
Identifier castLhs = (Identifier)binLhs;
inst = _table.GetVar(castLhs.Value);
}
else // if(binLhs.TypeOf().TypeKind == Declaration)
{
LLVMValueRef exp = GenerateExpression(binLhs, builder);
inst = exp;
}
return LLVM.BuildStore(builder, rhs, inst);
}
LLVMValueRef lhs = GenerateExpression(expression.Lhs, builder);
if (lhs.TypeOf().TypeKind == LLVM.DoubleType().TypeKind
|| rhs.TypeOf().TypeKind == LLVM.DoubleType().TypeKind)
{
return GenerateFloatingPointMath(op, lhs, rhs, builder);
}
else if (lhs.TypeOf().TypeKind == LLVM.Int32Type().TypeKind
&& rhs.TypeOf().TypeKind == LLVM.Int32Type().TypeKind)
{
return GenerateIntegerMath(op, lhs, rhs, builder);
}
else
{
throw new Exception("need to support strings and such here eventually");
}
}
private Expression ParseStatementHelper(Expression curr, int minPrecedence)
{
//TODO: figure out unary operators (increment, decrement, function call, etc.)
if (_tokens.Current.Type != TokenType.Operator)
{
throw new Exception("Expected operator in expression.");
}
while (_tokens.Current.Type == TokenType.Operator && OperatorPrecedence(_tokens.Current) >= minPrecedence)
{
Token op = _tokens.Current;
_tokens.Advance();
Expression next = MakeNode();
while (_tokens.Current.Type == TokenType.Operator &&
OperatorPrecedence(_tokens.Current) > OperatorPrecedence(op))
{
next = ParseStatementHelper(next, OperatorPrecedence(_tokens.Current));
}
curr = new BinaryExpression(curr, next, op.Text);
}
return curr;
}
