From 09bf4c102f9f78bb50df36d22714e7048d3bef16 Mon Sep 17 00:00:00 2001 From: Lang Hames Date: Tue, 18 Aug 2015 18:11:06 +0000 Subject: [Kaleidoscope] Start C++11'ifying the kaleidoscope tutorials. llvm-svn: 245322 --- llvm/docs/tutorial/LangImpl2.rst | 115 +++++++++++++++++++++------------------ 1 file changed, 61 insertions(+), 54 deletions(-) (limited to 'llvm/docs/tutorial/LangImpl2.rst') diff --git a/llvm/docs/tutorial/LangImpl2.rst b/llvm/docs/tutorial/LangImpl2.rst index 06b18ff6c23..4b28e02a523 100644 --- a/llvm/docs/tutorial/LangImpl2.rst +++ b/llvm/docs/tutorial/LangImpl2.rst @@ -45,7 +45,7 @@ We'll start with expressions first: class NumberExprAST : public ExprAST { double Val; public: - NumberExprAST(double val) : Val(val) {} + NumberExprAST(double Val) : Val(Val) {} }; The code above shows the definition of the base ExprAST class and one @@ -66,16 +66,17 @@ language: class VariableExprAST : public ExprAST { std::string Name; public: - VariableExprAST(const std::string &name) : Name(name) {} + VariableExprAST(const std::string &Name) : Name(Name) {} }; /// BinaryExprAST - Expression class for a binary operator. class BinaryExprAST : public ExprAST { char Op; - ExprAST *LHS, *RHS; + std::unique_ptr LHS, RHS; public: - BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs) - : Op(op), LHS(lhs), RHS(rhs) {} + BinaryExprAST(char op, std::unique_ptr LHS, + std::unique_ptr RHS) + : Op(op), LHS(std::move(LHS)), RHS(std::move(RHS)) {} }; /// CallExprAST - Expression class for function calls. @@ -83,8 +84,9 @@ language: std::string Callee; std::vector Args; public: - CallExprAST(const std::string &callee, std::vector &args) - : Callee(callee), Args(args) {} + CallExprAST(const std::string &Callee, + std::vector> Args) + : Callee(Callee), Args(std::move(Args)) {} }; This is all (intentionally) rather straight-forward: variables capture @@ -110,17 +112,18 @@ way to talk about functions themselves: std::string Name; std::vector Args; public: - PrototypeAST(const std::string &name, const std::vector &args) - : Name(name), Args(args) {} + PrototypeAST(const std::string &name, std::vector Args) + : Name(name), Args(std::move(Args)) {} }; /// FunctionAST - This class represents a function definition itself. class FunctionAST { - PrototypeAST *Proto; - ExprAST *Body; + std::unique_ptr Proto; + std::unique_ptr Body; public: - FunctionAST(PrototypeAST *proto, ExprAST *body) - : Proto(proto), Body(body) {} + FunctionAST(std::unique_ptr Proto, + std::unique_ptr Body) + : Proto(std::move(Proto)), Body(std::move(Body)) {} }; In Kaleidoscope, functions are typed with just a count of their @@ -142,9 +145,10 @@ be generated with calls like this: .. code-block:: c++ - ExprAST *X = new VariableExprAST("x"); - ExprAST *Y = new VariableExprAST("y"); - ExprAST *Result = new BinaryExprAST('+', X, Y); + auto LHS = llvm::make_unique("x"); + auto RHS = llvm::make_unique("y"); + auto Result = std::make_unique('+', std::move(LHS), + std::move(RHS)); In order to do this, we'll start by defining some basic helper routines: @@ -190,10 +194,10 @@ which parses that production. For numeric literals, we have: .. code-block:: c++ /// numberexpr ::= number - static ExprAST *ParseNumberExpr() { - ExprAST *Result = new NumberExprAST(NumVal); + static std::unique_ptr ParseNumberExpr() { + auto Result = llvm::make_unique(NumVal); getNextToken(); // consume the number - return Result; + return std::move(Result); } This routine is very simple: it expects to be called when the current @@ -211,10 +215,10 @@ the parenthesis operator is defined like this: .. code-block:: c++ /// parenexpr ::= '(' expression ')' - static ExprAST *ParseParenExpr() { + static std::unique_ptr ParseParenExpr() { getNextToken(); // eat (. - ExprAST *V = ParseExpression(); - if (!V) return 0; + auto V = ParseExpression(); + if (!V) return nullptr; if (CurTok != ')') return Error("expected ')'"); @@ -250,22 +254,22 @@ function calls: /// identifierexpr /// ::= identifier /// ::= identifier '(' expression* ')' - static ExprAST *ParseIdentifierExpr() { + static std::unique_ptr ParseIdentifierExpr() { std::string IdName = IdentifierStr; getNextToken(); // eat identifier. if (CurTok != '(') // Simple variable ref. - return new VariableExprAST(IdName); + return llvm::make_unique(IdName); // Call. getNextToken(); // eat ( - std::vector Args; + std::vector> Args; if (CurTok != ')') { while (1) { - ExprAST *Arg = ParseExpression(); - if (!Arg) return 0; - Args.push_back(Arg); + auto Arg = ParseExpression(); + if (!Arg) return nullptr; + Args.push_back(std::move(Arg)); if (CurTok == ')') break; @@ -278,7 +282,7 @@ function calls: // Eat the ')'. getNextToken(); - return new CallExprAST(IdName, Args); + return llvm::make_unique(IdName, std::move(Args)); } This routine follows the same style as the other routines. (It expects @@ -303,7 +307,7 @@ primary expression, we need to determine what sort of expression it is: /// ::= identifierexpr /// ::= numberexpr /// ::= parenexpr - static ExprAST *ParsePrimary() { + static std::unique_ptr ParsePrimary() { switch (CurTok) { default: return Error("unknown token when expecting an expression"); case tok_identifier: return ParseIdentifierExpr(); @@ -390,11 +394,11 @@ a sequence of [binop,primaryexpr] pairs: /// expression /// ::= primary binoprhs /// - static ExprAST *ParseExpression() { - ExprAST *LHS = ParsePrimary(); - if (!LHS) return 0; + static std::unique_ptr ParseExpression() { + auto LHS = ParsePrimary(); + if (!LHS) return nullptr; - return ParseBinOpRHS(0, LHS); + return ParseBinOpRHS(0, std::move(LHS)); } ``ParseBinOpRHS`` is the function that parses the sequence of pairs for @@ -416,7 +420,8 @@ starts with: /// binoprhs /// ::= ('+' primary)* - static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) { + static std::unique_ptr ParseBinOpRHS(int ExprPrec, + std::unique_ptr LHS) { // If this is a binop, find its precedence. while (1) { int TokPrec = GetTokPrecedence(); @@ -440,8 +445,8 @@ expression: getNextToken(); // eat binop // Parse the primary expression after the binary operator. - ExprAST *RHS = ParsePrimary(); - if (!RHS) return 0; + auto RHS = ParsePrimary(); + if (!RHS) return nullptr; As such, this code eats (and remembers) the binary operator and then parses the primary expression that follows. This builds up the whole @@ -474,7 +479,8 @@ then continue parsing: } // Merge LHS/RHS. - LHS = new BinaryExprAST(BinOp, LHS, RHS); + LHS = llvm::make_unique(BinOp, std::move(LHS), + std::move(RHS)); } // loop around to the top of the while loop. } @@ -498,11 +504,12 @@ above two blocks duplicated for context): // the pending operator take RHS as its LHS. int NextPrec = GetTokPrecedence(); if (TokPrec < NextPrec) { - RHS = ParseBinOpRHS(TokPrec+1, RHS); + RHS = ParseBinOpRHS(TokPrec+1, std::move(RHS)); if (RHS == 0) return 0; } // Merge LHS/RHS. - LHS = new BinaryExprAST(BinOp, LHS, RHS); + LHS = llvm::make_unique(BinOp, std::move(LHS), + std::move(RHS)); } // loop around to the top of the while loop. } @@ -541,7 +548,7 @@ expressions): /// prototype /// ::= id '(' id* ')' - static PrototypeAST *ParsePrototype() { + static std::unique_ptr ParsePrototype() { if (CurTok != tok_identifier) return ErrorP("Expected function name in prototype"); @@ -561,7 +568,7 @@ expressions): // success. getNextToken(); // eat ')'. - return new PrototypeAST(FnName, ArgNames); + return llvm::make_unique(FnName, std::move(ArgNames)); } Given this, a function definition is very simple, just a prototype plus @@ -570,14 +577,14 @@ an expression to implement the body: .. code-block:: c++ /// definition ::= 'def' prototype expression - static FunctionAST *ParseDefinition() { + static std::unique_ptr ParseDefinition() { getNextToken(); // eat def. - PrototypeAST *Proto = ParsePrototype(); - if (Proto == 0) return 0; + auto Proto = ParsePrototype(); + if (!Proto) return nullptr; - if (ExprAST *E = ParseExpression()) - return new FunctionAST(Proto, E); - return 0; + if (auto E = ParseExpression()) + return llvm::make_unique(std::move(Proto), std::move(E)); + return nullptr; } In addition, we support 'extern' to declare functions like 'sin' and @@ -587,7 +594,7 @@ In addition, we support 'extern' to declare functions like 'sin' and .. code-block:: c++ /// external ::= 'extern' prototype - static PrototypeAST *ParseExtern() { + static std::unique_ptr ParseExtern() { getNextToken(); // eat extern. return ParsePrototype(); } @@ -599,13 +606,13 @@ nullary (zero argument) functions for them: .. code-block:: c++ /// toplevelexpr ::= expression - static FunctionAST *ParseTopLevelExpr() { - if (ExprAST *E = ParseExpression()) { + static std::unique_ptr ParseTopLevelExpr() { + if (auto E = ParseExpression()) { // Make an anonymous proto. - PrototypeAST *Proto = new PrototypeAST("", std::vector()); - return new FunctionAST(Proto, E); + auto Proto = llvm::make_unique("", std::vector()); + return llvm::make_unique(std::move(Proto), std::move(E)); } - return 0; + return nullptr; } Now that we have all the pieces, let's build a little driver that will -- cgit v1.2.3