WIP

[kaleidoscope.git] / Kaleidoscope / ast.hpp

diff --git a/Kaleidoscope/ast.hpp b/Kaleidoscope/ast.hpp
index 34a52258085b9d3fcd48453e9e5896f2c2b2c02d..7730f8ec0f630b54e8d2e6a0f92e32ec255da0d9 100644 (file)
--- a/Kaleidoscope/ast.hpp
+++ b/Kaleidoscope/ast.hpp
@@ -11,6 +11,8 @@ public:
        virtual Value *codegen() = 0;
 };
 
+std::unique_ptr<ExprAST> LogError(std::string str);
+
 class NumberExprAST: public ExprAST {
        double Val;
        
@@ -48,21 +50,35 @@ public:
        virtual Value *codegen();
 };
 
-/*
+/**
  Captures the prototype for a function
  which is basically its name and arguments
  */
 class PrototypeAST {
        std::string Name;
        std::vector<std::string> Args;
+       bool IsOperator;
+       unsigned Precedence;
        
 public:
        virtual ~PrototypeAST() = default;
-       PrototypeAST(std::string Name, std::vector<std::string> Args)
-       : Name(Name), Args(std::move(Args)) {}
+       PrototypeAST(std::string Name, std::vector<std::string> Args,
+                               bool IsOperator = false, unsigned Prec = 0)
+       : Name(Name), Args(std::move(Args)), IsOperator(IsOperator),
+      Precedence(Prec) {}
        
        const std::string &getName() const { return Name; }
        virtual Function *codegen();
+
+       bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
+       bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
+
+       char getOperatorName() const {
+               assert(isUnaryOp() || isBinaryOp());
+               return Name[Name.size() - 1];
+       }
+
+       unsigned getBinaryPrecedence() const { return Precedence; }
 };
 
 class FunctionAST {
@@ -76,4 +92,35 @@ public:
        virtual Function *codegen();
 };
 
-std::unique_ptr<ExprAST> LogError(const char *Str);
+/// An expression for an if/then/else combo
+class IfExprAST: public ExprAST {
+       std::unique_ptr<ExprAST> Cond, Then, Else;
+       
+public:
+       IfExprAST(std::unique_ptr<ExprAST> Cond,
+                         std::unique_ptr<ExprAST> Then,
+                         std::unique_ptr<ExprAST> Else)
+       : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
+       
+       Value *codegen() override;
+};
+
+/// An expression for a for loop
+class ForExprAST: public ExprAST {
+       std::string VarName;
+       std::unique_ptr<ExprAST> Start, End, Step, Body;
+       
+public:
+       ForExprAST(const std::string &VarName,
+                          std::unique_ptr<ExprAST> Start,
+                          std::unique_ptr<ExprAST> End,
+                          std::unique_ptr<ExprAST> Step,
+                          std::unique_ptr<ExprAST> Body)
+       : VarName(VarName),
+       Start(std::move(Start)),
+       End(std::move(End)),
+       Step(std::move(Step)),
+       Body(std::move(Body)) {}
+       
+       Value *codegen() override;
+};