private LLVMValueRef GenerateExpression(Expression expression, LLVMBuilderRef builder)
{
switch (expression.ExpressionType)
{
case ExpressionType.IntegerLiteral:
{
IntegerLiteral i = (IntegerLiteral)expression;
return LLVM.ConstInt(LLVM.Int32Type(), (ulong)i.Value, true);
}
case ExpressionType.FloatLiteral:
{
FloatLiteral f = (FloatLiteral)expression;
return LLVM.ConstReal(LLVM.DoubleType(), f.Value);
}
case ExpressionType.StringLiteral:
{
StringLiteral str = (StringLiteral)expression;
LLVMValueRef[] data = str.Value.Select(x => LLVM.ConstInt(LLVM.Int8Type(), x, true)).ToArray();
return LLVM.ConstArray(LLVM.Int8Type(), data);
}
case ExpressionType.UnaryOperator:
{
throw new Exception("not implemented");
}
case ExpressionType.BinaryOperator:
{
BinaryExpression be = (BinaryExpression)expression;
return GenerateBinaryExpression(be, builder);
}
case ExpressionType.Identifier:
{
Identifier var = (Identifier)expression;
LLVMValueRef inst = _table.GetVar(var.Value);
return LLVM.BuildLoad(builder, inst, "");
}
case ExpressionType.Declaration:
{
Declaration decl = (Declaration)expression;
LLVMTypeRef type = StringToType(decl.TypeName);
LLVMValueRef inst = LLVM.BuildAlloca(builder, type, "");
_table.AddVar(decl.Name, inst);
return inst;
}
case ExpressionType.Return:
{
ReturnStatement ret = (ReturnStatement)expression;
LLVMValueRef exp = GenerateExpression(ret.Expression, builder);
return LLVM.BuildRet(builder, exp);
}
case ExpressionType.Cast:
{
Cast cast = (Cast)expression;
LLVMValueRef exp = GenerateExpression(cast.Expression, builder);
LLVMTypeRef type = StringToType(cast.CastType);
// TODO: a more generic casting mechanism
if (type.TypeKind == LLVM.DoubleType().TypeKind)
{
return LLVM.BuildSIToFP(builder, exp, LLVM.DoubleType(), "");
}
else if (type.TypeKind == LLVM.Int32Type().TypeKind)
{
return LLVM.BuildFPToSI(builder, exp, LLVM.Int32Type(), "");
}
else
{
throw new Exception("unsupported cast");
}
}
case ExpressionType.FunctionCall:
{
FunctionCall fcn = (FunctionCall)expression;
return GenerateFunctionCall(fcn, builder);
}
case ExpressionType.Empty:
return GenerateNoOp(builder);
default:
throw new Exception("Unknown expression type in codegen");
}
}
public BinaryExpression(Expression lhs, Expression rhs, string op)
{
_lhs = lhs;
_rhs = rhs;
_op = op;
}
public ReturnStatement(Expression expression)
{
_expression = expression;
}
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;
}
public Cast(string castType, Expression expression)
{
_castType = castType;
_expression = expression;
}
