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; }