第5章 フロントエンドの作成

リスト5.1: dummyC-ebnf

 1: (* C言語のサブセット *)
 2: (* 名前はDummyCとしておく *)
 3: (* 機能はかなりミニマル *)
 4: (* 一応EBNFで書いているつもり *)
 5: (* {}は0回以上の繰り返し *)
 6: (* []はオプション *)
 7: 
 8: 
 9: translation_unit
10:   : { external_declaration }
11:   ;
12: 
13: external_declaration
14:   : function_declaration
15:   | function_definition
16:   ;
17: 
18: function_declaration
19:   : prototype , ";"
20:   ;
21: 
22: function_definition
23:   : prototype , function_statement
24:   ;
25: 
26: prototype
27:   : "int" , identifier , "(" , [ parameter , { "," , parameter} ] , ")"
28:   ;
29: 
30: parameter
31:   : "int" , identifier
32:   ;
33: 
34: function_statement
35:   : "{" , [ variable_declaration_list ] , statement_list , "}"
36:   ;
37: 
38: variable_declaration_list
39:   : { variable_declaration }
40:   ;
41: 
42: variable_declaration
43:   : "int" , identifier , ";"
44:   ;
45: 
46: statement_list
47:   : { statement }
48:   ;
49: 
50: statement
51:   : expression_statement
52:   | jump_statement
53:   ;
54: 
55: expression_statement
56:   : ";"
57:   | assignment_expression , ";"
58:   ;
59: 
60: jump_statement
61:   : "return" , assignment_expression , ";"
62:   ;
63: 
64: assignment_expression
65:   : identifier , "=" , additive_expression
66:   | additive_expression
67:   ;
68: 
69: additive_expression
70:   : multiplicative_expression , [ { "+" , multiplicative_expression  |  "-" , multiplicative_expression } ]
71:   ;
72: 
73: multiplicative_expression
74:   : postfix_expression , [ { "*" , postfix_expression  |  "/" , postfix_expression } ]
75:   ;
76: 
77: postfix_expression
78:   : primary_expression
79:   | identifier , "(" , [ assignment_expression , { "," , assignment_expresstion } ] , ")"
80:   ;
81: 
82: primary_expression
83:   : identifier
84:   | integer
85:   | "(" , additive_expression , ")"
86:   ;
87: 
88: identifier
89:   : character , [ { character | digit } ]
90:   ;
91: 
92: integer
93:   : "0" | [ "-" ] digit_excluding_zero , [ { digit } ]
94:   ;
95: 
96: character
97:   : "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J"
98:   | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T"
99:   | "U" | "V" | "W" | "X" | "Y" | "Z"
100:   | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j"
101:   | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t"
102:   | "u" | "v" | "w" | "x" | "y" | "z"
103:   ;
104: 
105: digit_excluding_zero
106:   : "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
107:   ;
108: 
109: digit
110:   : "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
111:   ;

リスト5.2: 目標とするDummyCのサンプルコード

 1: int test(int j) {
 2:   int i;
 3:   i = j * 10;
 4:   return i;
 5: }
 6: 
 7: int main() {
 8:   int i;
 9:   i = 10;
10:   test(i);
11:   return 0;
12: }

リスト5.3: 共通マクロの定義

 1: #ifndef _APP_H_
 2: 
 3: #define SAFE_DELETE(x) {delete x;x=NULL;}
 4: #define SAFE_DELETEA(x) {delete[] x;x=NULL;}
 5: 
 6: #endif

リスト5.4: Token classの定義

 1: /**
 2:  * トークン種別
 3:  */
 4: enum TokenType {
 5:   TOK_IDENTIFIER, // 識別子
 6:   TOK_DIGIT,      // 数字
 7:   TOK_SYMBOL,     // 記号
 8:   TOK_INT,        // INT
 9:   TOK_RETURN,     // RETURN
10:   TOK_EOF         // EOF
11: };
12: 
13: /**
14:  * 個別トークン格納クラス
15:  */
16: class Token {
17: private:
18:   TokenType Type;
19:   std::string TokenString;
20:   int Number;
21:   int Line;
22: 
23: public:
24:   Token(std::string string, TokenType type, int line)
25:       : TokenString(string), Type(type), Line(line) {
26:     if (type == TOK_DIGIT)
27:       Number = atoi(string.c_str());
28:     else
29:       Number = 0x7fffffff;
30:   };
31:   ~Token() {};
32: 
33:   // トークンの種別を取得
34:   TokenType getTokenType() {
35:     return Type;
36:   };
37: 
38:   // トークンの文字列表現を取得
39:   std::string getTokenString() {
40:     return TokenString;
41:   };
42: 
43:   // トークンの数値を取得(種別が数字である場合に使用)
44:   int getNumberValue() {
45:     return Number;
46:   };
47: 
48:   // トークンの出現した行数を取得
49:   int getLine() { return Line; }
50: };

リスト5.5: TokenStream classの宣言

 1: /**
 2:   * 切り出したToken格納用クラス
 3:   */
 4: class TokenStream {
 5: private:
 6:   std::vector<Token *> Tokens;
 7:   int CurIndex;
 8: 
 9: public:
10:   TokenStream() : CurIndex(0) {}
11:   ~TokenStream();
12: 
13:   bool ungetToken(int Times = 1);
14:   bool nextToken();
15:   bool pushToken(Token *token) {
16:     Tokens.push_back(token);
17:     return true;
18:   }
19:   Token getToken();
20: 
21:   // トークンの種類を取得
22:   TokenType getCurType() { return Tokens[CurIndex]->getTokenType(); }
23: 
24:   // トークンの文字列表現を取得
25:   std::string getCurString() { return Tokens[CurIndex]->getTokenString(); }
26: 
27:   // トークンの数値を取得
28:   int getCurNumVal() { return Tokens[CurIndex]->getNumberValue(); }
29: 
30:   // 現在のインデックスを取得
31:   int getCurIndex() { return CurIndex; }
32: 
33:   // インデックスを指定した値に設定
34:   bool applyTokenIndex(int index) {
35:     CurIndex = index;
36:     return true;
37:   }
38: 
39:   bool printTokens();
40: };

リスト5.6: TokenStream classの定義

 1: /**
 2:   * デストラクタ
 3:   */
 4: TokenStream::~TokenStream() {
 5:   for (int i = 0; i < Tokens.size(); i++) {
 6:     SAFE_DELETE(Tokens[i]);
 7:   }
 8:   Tokens.clear();
 9: }
10: 
11: /**
12:   * トークン取得
13:   * @return CureIndex番目のToken
14:   */
15: Token TokenStream::getToken() { return *Tokens[CurIndex]; }
16: 
17: /**
18:   * インデックスを一つ増やして次のトークンに進める
19:   * @return 成功時：true　失敗時：false
20:   */
21: bool TokenStream::nextToken() {
22:   int size = Tokens.size();
23:   if (--size <= CurIndex) {
24:     return false;
25:   } else {
26:     CurIndex++;
27:     return true;
28:   }
29: }
30: 
31: /**
32:   * インデックスをtimes回戻す
33:   */
34: bool TokenStream::ungetToken(int times) {
35:   for (int i = 0; i < times; i++) {
36:     if (CurIndex == 0)
37:       return false;
38:     else
39:       CurIndex--;
40:   }
41:   return true;
42: }
43: 
44: /**
45:   * 格納されたトークン一覧を表示する
46:   */
47: bool TokenStream::printTokens() {
48:   std::vector<Token *>::iterator titer = Tokens.begin();
49:   while (titer != Tokens.end()) {
50:     fprintf(stdout, "%d:", (*titer)->getTokenType());
51:     if ((*titer)->getTokenType() != TOK_EOF)
52:       fprintf(stdout, "%s\n", (*titer)->getTokenString().c_str());
53:     ++titer;
54:   }
55:   return true;
56: }

リスト5.7: lexer

 1: /**
 2:  * トークン切り出し関数
 3:  * @param 字句解析対象ファイル名
 4:  * @return 切り出したトークンを格納したTokenStream
 5:  */
 6: TokenStream *LexicalAnalysis(std::string input_filename) {
 7:   TokenStream *tokens = new TokenStream();
 8:   std::ifstream ifs;
 9:   std::string cur_line;
10:   std::string token_str;
11:   int line_num = 0;
12:   bool iscomment = false;
13: 
14:   ifs.open(input_filename.c_str(), std::ios::in);
15:   if (!ifs)
16:     return NULL;
17:   while (ifs && getline(ifs, cur_line)) {
18:     char next_char;
19:     std::string line;
20:     Token *next_token;
21:     int index = 0;
22:     int length = cur_line.length();
23: 
24:     while (index < length) {
25:       next_char = cur_line.at(index++);
26: 
27:       // コメントアウト読み飛ばし
28:       if (iscomment) {
29:         if (((length - index) >= 1) && (next_char == '*') &&
30:             (cur_line.at(index) == '/')) {
31:           iscomment = false;
32:           index++;
33:         }
34:         continue;
35:       }
36: 
37:       // EOF
38:       if (next_char == EOF) {
39:         token_str = EOF;
40:         next_token = new Token(token_str, TOK_EOF, line_num);
41: 
42:       } else if (isspace(next_char)) {
43:         continue;
44: 
45:       // IDENTIFIER
46:       } else if (isalpha(next_char)) {
47:         while (isalnum(next_char)) {
48:           token_str += next_char;
49:           if (index == length)
50:             break;
51:           next_char = cur_line.at(index++);
52:         }
53:         if (!isalnum(next_char))
54:           index--;
55: 
56:         if (token_str == "int") {
57:           next_token = new Token(token_str, TOK_INT, line_num);
58:         } else if (token_str == "return") {
59:           next_token = new Token(token_str, TOK_RETURN, line_num);
60:         } else {
61:           next_token = new Token(token_str, TOK_IDENTIFIER, line_num);
62:         }
63: 
64:       // 数字
65:       } else if (isdigit(next_char)) {
66:         if (next_char == '0') {
67:           token_str += next_char;
68:           next_token = new Token(token_str, TOK_DIGIT, line_num);
69:         } else {
70:           while (isdigit(next_char)) {
71:             token_str += next_char;
72:             if (index == length)
73:               break;
74:             next_char = cur_line.at(index++);
75:           }
76:           next_token = new Token(token_str, TOK_DIGIT, line_num);
77:           if (!isdigit(next_char))
78:             index--;
79:         }
80: 
81:       // コメント or '/'
82:       } else if (next_char == '/') {
83:         token_str += next_char;
84: 
85:         // コメントの場合
86:         if (((length - index) >= 1) && (cur_line.at(index) == '/')) {
87:           break;
88: 
89:         // コメントの場合
90:         } else if (((length - index) >= 1) && (cur_line.at(index) == '*')) {
91:           index++;
92:           iscomment = true;
93:           continue;
94: 
95:         // DIVIDER('/')
96:         } else {
97:           next_token = new Token(token_str, TOK_SYMBOL, line_num);
98:         }
99: 
100:       // それ以外(記号)
101:       } else {
102:         if (next_char == '*' || next_char == '+' || next_char == '-' ||
103:             next_char == '=' || next_char == ';' || next_char == ',' ||
104:             next_char == '(' || next_char == ')' || next_char == '{' ||
105:             next_char == '}') {
106:           token_str += next_char;
107:           next_token = new Token(token_str, TOK_SYMBOL, line_num);
108: 
109:         // 解析不能字句
110:         } else {
111:           fprintf(stderr, "unclear token : %c", next_char);
112:           SAFE_DELETE(tokens);
113:           return NULL;
114:         }
115:       }
116: 
117:       // Tokensに追加
118:       tokens->pushToken(next_token);
119:       token_str.clear();
120:     }
121: 
122:     token_str.clear();
123:     line_num++;
124:   }
125: 
126:   // EOFの確認
127:   if (ifs.eof()) {
128:     tokens->pushToken(new Token(token_str, TOK_EOF, line_num));
129:   }
130: 
131:   // クローズ
132:   ifs.close();
133:   return tokens;
134: }

リスト5.8: ASTの基底クラス

 1: /**
 2:   * ASTの種類
 3:   */
 4: enum AstID {
 5:   BaseID
 6: };
 7: 
 8: /**
 9:   * ASTの基底クラス
10:   */
11: class BaseAST {
12:   AstID ID;
13: 
14: public:
15:   BaseAST(AstID id) : ID(id) {}
16:   virtual ~BaseAST() {}
17:   AstID getValueID() const { return ID; }
18: };

リスト5.9: 各種ステートメントのAST

 1: /**
 2:   * ASTの種類
 3:   */
 4: enum AstID {
 5:   BaseID,
 6:   VariableDeclID,
 7:   BinaryExprID,
 8:   CallExprID,
 9:   JumpStmtID,
10:   VariableID,
11:   NumberID
12: };
13: 
14: /**
15:   * ASTの基底クラス
16:   */
17: class BaseAST {
18:   AstID ID;
19: 
20: public:
21:   BaseAST(AstID id) : ID(id) {}
22:   virtual ~BaseAST() {}
23:   AstID getValueID() const { return ID; }
24: };
25: 
26: /**
27:   * 変数宣言を表すAST
28:   */
29: class VariableDeclAST : public BaseAST {
30: public:
31:   typedef enum {
32:     param,
33:     local
34:   } DeclType;
35: 
36: private:
37:   std::string Name;
38:   DeclType Type;
39: 
40: public:
41:   VariableDeclAST(const std::string &name)
42:       : BaseAST(VariableDeclID), Name(name) {}
43: 
44:   // VariableDeclASTなのでtrueを返却
45:   static inline bool classof(VariableDeclAST const *) { return true; }
46: 
47:   // 渡されたBaseASTクラスがVariableDeclASTか判定する
48:   static inline bool classof(BaseAST const *base) {
49:     return base->getValueID() == VariableDeclID;
50:   }
51:   ~VariableDeclAST() {}
52: 
53:   // 変数名を取得する
54:   std::string getName() { return Name; }
55: 
56:   // 変数の宣言種別を設定する
57:   bool setDeclType(DeclType type) {
58:     Type = type;
59:     return true;
60:   };
61: 
62:   // 変数の宣下種別を設定する
63:   DeclType getType() { return Type; }
64: };
65: 
66: /**
67:   * 二項演算を表すAST
68:   */
69: class BinaryExprAST : public BaseAST {
70:   std::string Op;
71:   BaseAST *LHS, *RHS;
72: 
73: public:
74:   BinaryExprAST(std::string op, BaseAST *lhs, BaseAST *rhs)
75:       : BaseAST(BinaryExprID), Op(op), LHS(lhs), RHS(rhs) {}
76:   ~BinaryExprAST() {
77:     SAFE_DELETE(LHS);
78:     SAFE_DELETE(RHS);
79:   }
80: 
81:   // BinaryExprASTなのでtrueを返却
82:   static inline bool classof(BinaryExprAST const *) { return true; }
83: 
84:   // 渡されたBaseASTがBinaryExprASTか判定する
85:   static inline bool classof(BaseAST const *base) {
86:     return base->getValueID() == BinaryExprID;
87:   }
88: 
89:   // 演算子を取得する
90:   std::string getOp() { return Op; }
91: 
92:   // 左辺値を取得する
93:   BaseAST *getLHS() { return LHS; }
94: 
95:   // 右辺値を取得する
96:   BaseAST *getRHS() { return RHS; }
97: };
98: 
99: /**
100:   * 関数呼び出しを表すAST
101:   */
102: class CallExprAST : public BaseAST {
103:   std::string Callee;
104:   std::vector<BaseAST *> Args;
105: 
106: public:
107:   CallExprAST(const std::string &callee, std::vector<BaseAST *> &args)
108:       : BaseAST(CallExprID), Callee(callee), Args(args) {}
109:   ~CallExprAST();
110: 
111:   // CallExprASTなのでtrueを返却
112:   static inline bool classof(CallExprAST const *) { return true; }
113: 
114:   // 渡されたBaseASTがCallExprASTか判定する
115:   static inline bool classof(BaseAST const *base) {
116:     return base->getValueID() == CallExprID;
117:   }
118: 
119:   // 呼び出す関数名を取得する
120:   std::string getCallee() { return Callee; }
121: 
122:   // i番目の引数を取得する
123:   BaseAST *getArgs(int i) {
124:     if (i < Args.size())
125:       return Args.at(i);
126:     else
127:       return NULL;
128:   }
129: };
130: 
131: /**
132:   * ジャンプ(今回はreturn)を表すAST
133:   */
134: class JumpStmtAST : public BaseAST {
135:   BaseAST *Expr;
136: 
137: public:
138:   JumpStmtAST(BaseAST *expr) : BaseAST(JumpStmtID), Expr(expr) {}
139:   ~JumpStmtAST() { SAFE_DELETE(Expr); }
140: 
141:   // JumpStmtASTなのでtrueを返却
142:   static inline bool classof(JumpStmtAST const *) { return true; }
143: 
144:   // 渡されたBaseASTがJumpStmtASTか判定する
145:   static inline bool classof(BaseAST const *base) {
146:     return base->getValueID() == JumpStmtID;
147:   }
148: 
149:   // returnで返却するExpressionを取得する
150:   BaseAST *getExpr() { return Expr; }
151: };
152: 
153: /**
154:   * 変数参照を表すAST
155:   */
156: class VariableAST : public BaseAST {
157:   // Name
158:   std::string Name;
159: 
160: public:
161:   VariableAST(const std::string &name) : BaseAST(VariableID), Name(name) {}
162:   virtual ~VariableAST() {}
163: 
164:   // VariableASTなのでtrueを返却
165:   static inline bool classof(VariableAST const *) { return true; }
166: 
167:   // 渡されたBaseASTがVariableASTか判定する
168:   static inline bool classof(BaseAST const *base) {
169:     return base->getValueID() == VariableID;
170:   }
171: 
172:   // 変数名を取得する
173:   std::string getName() { return Name; }
174: };
175: 
176: /**
177:   * 整数を表すAST
178:   */
179: class NumberAST : public BaseAST {
180:   int Val;
181: 
182: public:
183:   NumberAST(int val) : BaseAST(NumberID), Val(val) {}
184:   ~NumberAST() {}
185: 
186:   // NumberASTなのでtrueを返却
187:   static inline bool classof(NumberAST const *) { return true; }
188: 
189:   // 渡されたBaseASTがNumberASTか判定する
190:   static inline bool classof(BaseAST const *base) {
191:     return base->getValueID() == NumberID;
192:   }
193: 
194:   // このASTが表現する数値を取得する
195:   int getNumberValue() { return Val; }
196: };

リスト5.10: モジュールと関数

 1: /**
 2:   * ソースコードを表すAST
 3:   */
 4: class TranslationUnitAST {
 5:   std::vector<PrototypeAST *> Prototypes;
 6:   std::vector<FunctionAST *> Functions;
 7: 
 8: public:
 9:   TranslationUnitAST() {}
10:   ~TranslationUnitAST();
11: 
12:   // モジュールにプロトタイプ宣言を追加する
13:   bool addPrototype(PrototypeAST *proto);
14: 
15:   // モジュールに関数を追加する
16:   bool addFunction(FunctionAST *func);
17: 
18:   // モジュールが空か判定する
19:   bool empty();
20: 
21:   // i番目のプロトタイプ宣言を取得する
22:   PrototypeAST *getPrototype(int i) {
23:     if (i < Prototypes.size())
24:       return Prototypes.at(i);
25:     else
26:       return NULL;
27:   }
28: 
29:   // i番目の関数を取得する
30:   FunctionAST *getFunction(int i) {
31:     if (i < Functions.size())
32:       return Functions.at(i);
33:     else
34:       return NULL;
35:   }
36: };
37: 
38: /**
39:   * 関数宣言を表すAST
40:   */
41: class PrototypeAST {
42:   std::string Name;
43:   std::vector<std::string> Params;
44: 
45: public:
46:   PrototypeAST(const std::string &name, const std::vector<std::string> &params)
47:       : Name(name), Params(params) {}
48: 
49:   // 関数名を取得する
50:   std::string getName() { return Name; }
51: 
52:   // i番目の引数名を取得する
53:   std::string getParamName(int i) {
54:     if (i < Params.size())
55:       return Params.at(i);
56:     return NULL;
57:   }
58: 
59:   // 引数の数を取得する
60:   int getParamNum() { return Params.size(); }
61: };
62: 
63: /**
64:   * 関数定義を表すAST
65:   */
66: class FunctionAST {
67:   PrototypeAST *Proto;
68:   FunctionStmtAST *Body;
69: 
70: public:
71:   FunctionAST(PrototypeAST *proto, FunctionStmtAST *body)
72:       : Proto(proto), Body(body) {}
73:   ~FunctionAST();
74: 
75:   // 関数名を取得する
76:   std::string getName() { return Proto->getName(); }
77: 
78:   // この関数のプロトタイプ宣言を取得する
79:   PrototypeAST *getPrototype() { return Proto; }
80: 
81:   // この関数のボディを取得する
82:   FunctionStmtAST *getBody() { return Body; }
83: };
84: 
85: /**
86:   * 関数定義(ボディ)を表すAST
87:   */
88: class FunctionStmtAST {
89:   std::vector<VariableDeclAST *> VariableDecls;
90:   std::vector<BaseAST *> StmtLists;
91: 
92: public:
93:   FunctionStmtAST() {}
94:   ~FunctionStmtAST();
95: 
96:   // 関数に変数を追加する
97:   bool addVariableDeclaration(VariableDeclAST *vdecl);
98: 
99:   // 関数にステートメントを追加する
100:   bool addStatement(BaseAST *stmt) { StmtLists.push_back(stmt); }
101: 
102:   // i番目の変数を取得する
103:   VariableDeclAST *getVariableDecl(int i) {
104:     if (i < VariableDecls.size())
105:       return VariableDecls.at(i);
106:     else
107:       return NULL;
108:   }
109: 
110:   // i番目のステートメントを取得する
111:   BaseAST *getStatement(int i) {
112:     if (i < StmtLists.size())
113:       return StmtLists.at(i);
114:     else
115:       return NULL;
116:   }
117: };

リスト5.11: parserクラス宣言

 1: /**
 2:   * 構文解析・意味解析クラス
 3:   */
 4: class Parser {
 5: private:
 6:   TokenStream *Tokens;
 7:   TranslationUnitAST *TU;
 8: 
 9: public:
10:   Parser(std::string filename);
11:   ~Parser() {
12:     SAFE_DELETE(TU);
13:     SAFE_DELETE(Tokens);
14:   }
15:   bool doParse();
16:   TranslationUnitAST &getAST();
17: 
18: private:
19:   /**
20:     * 各種構文解析メソッド
21:     */
22:   bool visitTranslationUnit();
23:   bool visitExternalDeclaration(TranslationUnitAST *tunit);
24:   PrototypeAST *visitFunctionDeclaration();
25:   FunctionAST *visitFunctionDefinition();
26:   PrototypeAST *visitPrototype();
27:   FunctionStmtAST *visitFunctionStatement(PrototypeAST *proto);
28:   VariableDeclAST *visitVariableDeclaration();
29:   BaseAST *visitStatement();
30:   BaseAST *visitExpressionStatement();
31:   BaseAST *visitJumpStatement();
32:   BaseAST *visitAssignmentExpression();
33:   BaseAST *visitAdditiveExpression(BaseAST *lhs);
34:   BaseAST *visitMultiplicativeExpression(BaseAST *lhs);
35:   BaseAST *visitPostfixExpression();
36:   BaseAST *visitPrimaryExpression();
37: };

リスト5.12: Parserクラスのpublicメソッド

 1: /**
 2:   * コンストラクタ
 3:   */
 4: Parser::Parser(std::string filename) { Tokens = LexicalAnalysis(filename); }
 5: 
 6: /**
 7:   * 構文解析実行
 8:   * @return 解析成功：true　解析失敗：false
 9:   */
10: bool Parser::doParse() {
11:   if (!Tokens) {
12:     fprintf(stderr, "error at lexer\n");
13:     return false;
14:   } else
15:     return visitTranslationUnit();
16: }
17: 
18: /**
19:   * AST取得
20:   * @return TranslationUnitへの参照
21:   */
22: TranslationUnitAST &Parser::getAST() {
23:   if (TU)
24:     return *TU;
25:   else
26:     return *(new TranslationUnitAST());
27: }

リスト5.13: visitTranslationUnitとvisitExternalDeclaration

 1: /**
 2:   * TranslationUnit用構文解析メソッド
 3:   * @return 解析成功：true　解析失敗：false
 4:   */
 5: bool Parser::visitTranslationUnit() {
 6:   TU = new TranslationUnitAST();
 7: 
 8:   // ExternalDecl
 9:   while (true) {
10:     if (!visitExternalDeclaration(TU)) {
11:       SAFE_DELETE(TU);
12:       return false;
13:     }
14:     if (Tokens->getCurType() == TOK_EOF)
15:       break;
16:   }
17:   return true;
18: }
19: 
20: /**
21:   * ExternalDeclaration用構文解析クラス
22:   * 解析したPrototyupeとFunctionASTをTranslationUitに追加
23:   * @param TranslationUnitAST
24:   * @return true
25:   */
26: bool Parser::visitExternalDeclaration(TranslationUnitAST *tunit) {
27:   // FunctionDeclaration
28:   PrototypeAST *proto = visitFunctionDeclaration();
29:   if (proto) {
30:     tunit->addPrototype(proto);
31:     return true;
32:   }
33: 
34:   // FunctionDefinition
35:   FunctionAST *func_def = visitFunctionDefinition();
36:   if (func_def) {
37:     tunit->addFunction(func_def);
38:     return true;
39:   }
40: 
41:   return false;
42: }

リスト5.14: visitFunctionDeclaration

 1: /**
 2:   * FunctionDclaration用構文解析メソッド
 3:   * @return 解析成功：PrototypeAST　解析失敗：NULL
 4:   */
 5: PrototypeAST *Parser::visitFunctionDeclaration() {
 6:   int bkup = Tokens->getCurIndex();
 7:   PrototypeAST *proto = visitPrototype();
 8:   if (!proto) {
 9:     return NULL;
10:   }
11: 
12:   // prototype;
13:   if (Tokens->getCurString() == ";") {
14: 
15:     ・・・本来であればここで再定義されていないか確認・・・
16: 
17:     Tokens->nextToken();
18:     return proto;
19:   } else {
20:     SAFE_DELETE(proto);
21:     Tokens->applyTokenIndex(bkup);
22:     return NULL;
23:   }
24: }

リスト5.15: visitFunctionDefinition

 1: /**
 2:   * FunctionDefinition用構文解析メソッド
 3:   * @return 解析成功：FunctionAST　解析失敗：NULL
 4:   */
 5: FunctionAST *Parser::visitFunctionDefinition() {
 6:   int bkup = Tokens->getCurIndex();
 7: 
 8:   PrototypeAST *proto = visitPrototype();
 9:   if (!proto) {
10:     return NULL;
11:   }
12: 
13:   ・・・本来であればここで再定義されていないか確認・・・
14: 
15:   FunctionStmtAST *func_stmt = visitFunctionStatement(proto);
16: 
17:   ・・・省略・・・
18: }

リスト5.16: 変数宣言のチェック

 1: /**
 2:   * Prototype用構文解析メソッド
 3:   * @return 解析成功：PrototypeAST　解析失敗：NULL
 4:   */
 5: PrototypeAST *Parser::visitPrototype() {
 6:   // indexを保存
 7:   int bkup = Tokens->getCurIndex();
 8:   　　・・・省略・・・
 9: 
10:   // parameter_list
11:   bool is_first_param = true;
12:   std::vector<std::string> param_list;
13:   while (true) {
14:     //,
15:     if (!is_first_param && Tokens->getCurType() == TOK_SYMBOL &&
16:         Tokens->getCurString() == ",") {
17:       Tokens->nextToken();
18:     }
19:     if (Tokens->getCurType() == TOK_INT) {
20:       Tokens->nextToken();
21:     } else {
22:       break;
23:     }
24: 
25:     if (Tokens->getCurType() == TOK_IDENTIFIER) {
26: 
27:       ・・・本来ならここで引数名に被りがないか確認・・・
28: 
29:       param_list.push_back(Tokens->getCurString());
30:       Tokens->nextToken();
31:     } else {
32:       Tokens->applyTokenIndex(bkup);
33:       return NULL;
34:     }
35:   }
36:   　　・・・省略・・・
37: }

リスト5.17: visitFunctionStatement

 1: /**
 2:   * FunctionStatement用構文解析メソッド
 3:   * @param 関数名や引数を格納したPrototypeクラスのインスタンス
 4:   * @return 解析成功：FunctionStmtAST　解析失敗：NULL
 5:   */
 6: FunctionStmtAST *Parser::visitFunctionStatement(PrototypeAST *proto) {
 7:   int bkup = Tokens->getCurIndex();
 8: 
 9:   if (Tokens->getCurString() == "{") {
10:     Tokens->nextToken();
11:   } else {
12:     return NULL;
13:   }
14: 
15:   FunctionStmtAST *func_stmt = new FunctionStmtAST();
16: 
17:   // 引数をfunc_stmtの変数宣言リストに追加
18:   for (int i = 0; i < proto->getParamNum(); i++) {
19:     VariableDeclAST *vdecl = new VariableDeclAST(proto->getParamName(i));
20:     vdecl->setDeclType(VariableDeclAST::param);
21:     func_stmt->addVariableDeclaration(vdecl);
22:     VariableTable.push_back(vdecl->getName());
23:   }
24: 
25:   ・・・省略・・・
26: 
27:   } else if (var_decl = visitVariableDeclaration()) {
28:     while (var_decl) {
29:       var_decl->setDeclType(VariableDeclAST::local);
30: 
31:       ・・・本来ならここで変数が二重宣言されていないことを確認・・・
32: 
33:       func_stmt->addVariableDeclaration(var_decl);
34:       VariableTable.push_back(var_decl->getName());
35:       var_decl = visitVariableDeclaration();
36:     }
37: 
38:     if (stmt = visitStatement()) {
39:       while (stmt) {
40:         last_stmt = stmt;
41:         func_stmt->addStatement(stmt);
42:         stmt = visitStatement();
43:       }
44:     }
45: 
46:   // other
47:   } else {
48:     SAFE_DELETE(func_stmt);
49:     Tokens->applyTokenIndex(bkup);
50:     return NULL;
51:   }
52: 
53:   ・・・本来ならここで戻り値の確認・・・
54: 
55:   if (Tokens->getCurString() == "}") {
56:     Tokens->nextToken();
57:     return func_stmt;
58:   } else {
59:     SAFE_DELETE(func_stmt);
60:     Tokens->applyTokenIndex(bkup);
61:     return NULL;
62:   }
63: }

リスト5.18: visitAssignmentExpression

 1: /**
 2:   * AssignmentExpression用構文解析メソッド
 3:   * @return 解析成功：AST　解析失敗：NULL
 4:   */
 5: BaseAST *Parser::visitAssignmentExpression() {
 6:   int bkup = Tokens->getCurIndex();
 7: 
 8:   BaseAST *lhs;
 9:   if (Tokens->getCurType() == TOK_IDENTIFIER) {
10:     ・・・本来はここで変数の宣言確認・・・
11:     lhs = new VariableAST(Tokens->getCurString());
12:     Tokens->nextToken();
13:     BaseAST *rhs;
14:     if (Tokens->getCurType() == TOK_SYMBOL && Tokens->getCurString() == "=") {
15:       Tokens->nextToken();
16:       if (rhs = visitAdditiveExpression(NULL)) {
17:         return new BinaryExprAST("=", lhs, rhs);
18:       } else {
19:         SAFE_DELETE(lhs);
20:         Tokens->applyTokenIndex(bkup);
21:       }
22:     } else {
23:       SAFE_DELETE(lhs);
24:       Tokens->applyTokenIndex(bkup);
25:     }
26:   }
27:   BaseAST *add_expr = visitAdditiveExpression(NULL);
28:   if (add_expr) {
29:     return add_expr;
30:   }
31: 
32:   return NULL;
33: }

リスト5.19: visitPrimaryExpression

 1: /**
 2:   * PrimaryExpression用構文解析メソッド
 3:   * @return 解析成功時：AST失敗時：NULL
 4:   */
 5: BaseAST *Parser::visitPrimaryExpression() {
 6:   // indexを保存
 7:   int bkup = Tokens->getCurIndex();
 8: 
 9:   // VARIABLE_IDENTIFIER
10:   if (Tokens->getCurType() == TOK_IDENTIFIER) {
11: 
12:     ・・・本来ならここで変数の宣言確認・・・
13: 
14:     std::string var_name = Tokens->getCurString();
15:     Tokens->nextToken();
16:     return new VariableAST(var_name);
17: 
18:   // integer
19:   } else if (Tokens->getCurType() == TOK_DIGIT) {
20:     int val = Tokens->getCurNumVal();
21:     Tokens->nextToken();
22:     return new NumberAST(val);
23: 
24:   // integer(-)
25:   } else if (Tokens->getCurType() == TOK_SYMBOL &&
26:              Tokens->getCurString() == "-") {
27: 
28:     ・・・省略・・・
29:   }
30: 
31:   return NULL;
32: }

リスト5.20: visitPostfixExpression

 1: /**
 2:   * PostfixExpression用構文解析メソッド
 3:   * @return 解析成功：AST　解析失敗：NULL
 4:   */
 5: BaseAST *Parser::visitPostfixExpression() {
 6:   // get index
 7:   int bkup = Tokens->getCurIndex();
 8: 
 9:   ・・・省略・・・
10: 
11:   // FUNCTION_IDENTIFIER
12:   if (Tokens->getCurType() == TOK_IDENTIFIER) {
13: 
14:     ・・・本来ならここで関数の宣言確認・・・
15: 
16:     // 関数名取得
17:     std::string Callee = Tokens->getCurString();
18:     Tokens->nextToken();
19: 
20:     // LEFT PAREN
21:     if (Tokens->getCurType() != TOK_SYMBOL || Tokens->getCurString() != "(") {
22:       Tokens->applyTokenIndex(bkup);
23:       return NULL;
24:     }
25: 
26:     Tokens->nextToken();
27:     std::vector<BaseAST *> args;
28:     // 引数を解析
29:     BaseAST *assign_expr = visitAssignmentExpression();
30:     if (assign_expr) {
31:       args.push_back(assign_expr);
32:       // ","が続く限り繰り返し
33:       while (Tokens->getCurType() == TOK_SYMBOL &&
34:              Tokens->getCurString() == ",") {
35:         Tokens->nextToken();
36:         assign_expr = visitAssignmentExpression();
37:         if (assign_expr) {
38:           args.push_back(assign_expr);
39:         } else {
40:           break;
41:         }
42:       } // end while
43:     }
44: 
45:     ・・・本来ならここで引数の数を確認・・・
46: 
47:     // RIGHT PAREN
48:     if (Tokens->getCurType() == TOK_SYMBOL && Tokens->getCurString() == ")") {
49:       Tokens->nextToken();
50:       return new CallExprAST(Callee, args);
51:     } else {
52:       for (int i = 0; i < args.size(); i++)
53:         SAFE_DELETE(args[i]);
54:       Tokens->applyTokenIndex(bkup);
55:       return NULL;
56:     }
57:   } else {
58:     return NULL;
59:   }
60: }

リスト5.21: 四則演算

 1: /**
 2:   * AdditiveExpression用構文解析メソッド
 3:   * @param lhs(左辺),初回呼び出し時はNULL
 4:   * @return 解析成功：AST　解析失敗：NULL
 5:   */
 6: BaseAST *Parser::visitAdditiveExpression(BaseAST *lhs) {
 7:   // indexを保存
 8:   int bkup = Tokens->getCurIndex();
 9: 
10:   if (!lhs)
11:     lhs = visitMultiplicativeExpression(NULL);
12: 
13:   if (!lhs)
14:     return NULL;
15: 
16:   BaseAST *rhs;
17:   // +
18:   if (Tokens->getCurType() == TOK_SYMBOL && Tokens->getCurString() == "+") {
19:     Tokens->nextToken();
20:     rhs = visitMultiplicativeExpression(NULL);
21:     if (rhs) {
22:       return visitAdditiveExpression(new BinaryExprAST("+", lhs, rhs));
23:     } else {
24:       SAFE_DELETE(lhs);
25:       Tokens->applyTokenIndex(bkup);
26:       return NULL;
27:     }
28: 
29:     // -
30:   } else if (Tokens->getCurType() == TOK_SYMBOL &&
31:              Tokens->getCurString() == "-") {
32:     Tokens->nextToken();
33:     rhs = visitMultiplicativeExpression(NULL);
34:     if (rhs) {
35:       return visitAdditiveExpression(new BinaryExprAST("-", lhs, rhs));
36:     } else {
37:       SAFE_DELETE(lhs);
38:       Tokens->applyTokenIndex(bkup);
39:       return NULL;
40:     }
41:   }
42:   return lhs;
43: }

リスト5.22: AstIDの修正とNullExprAST

 1: /**
 2:   * ASTの種類
 3:   */
 4: enum AstID {
 5:   BaseID,
 6:   VariableDeclID,
 7:   BinaryExprID,
 8:   NullExprID,
 9:   CallExprID,
10:   JumpStmtID,
11:   VariableID,
12:   NumberID
13: };
14: 
15: /**
16:   * ";"を表すAST
17:   */
18: class NullExprAST : public BaseAST {
19: public:
20:   NullExprAST() : BaseAST(NullExprID) {}
21:   static inline bool classof(NullExprAST const *) { return true; }
22:   static inline bool classof(BaseAST const *base) {
23:     return base->getValueID() == NullExprID;
24:   }
25: };

リスト5.23: visitfExpressionStatement

 1: /**
 2:   * ExpressionStatement用構文解析メソッド
 3:   * @return  解析成功：AST 解析失敗：NULL
 4:   */
 5: BaseAST *Parser::visitExpressionStatement() {
 6:   BaseAST *assign_expr;
 7: 
 8:   // NULL Expression
 9:   if (Tokens->getCurString() == ";") {
10:     Tokens->nextToken();
11:     return new NullExprAST();
12:   } else if (assign_expr = visitAssignmentExpression()) {
13:     if (Tokens->getCurString() == ";") {
14:       Tokens->nextToken();
15:       return assign_expr;
16:     }
17:   }
18:   return NULL;
19: }

リスト5.24: 修正したparserクラスの宣言

 1: /**
 2:   * 構文解析・意味解析クラス
 3:   */
 4: class Parser {
 5: private:
 6:   TokenStream *Tokens;
 7:   TranslationUnitAST *TU;
 8: 
 9:   // 意味解析用各種識別子表
10:   std::vector<std::string> VariableTable;
11:   std::map<std::string, int> PrototypeTable;
12:   std::map<std::string, int> FunctionTable;
13: 
14: public:
15:   Parser(std::string filename) { Tokens = LexicalAnalysis(filename); }
16:   ~Parser() {
17:     SAFE_DELETE(TU);
18:     SAFE_DELETE(Tokens);
19:   }
20:   bool doParse();
21:   TranslationUnitAST &getAST();
22: 
23:   ・・・省略・・・
24: };

リスト5.25: 意味解析を実装したvisitFunctionDeclaration

 1: /**
 2:   * FunctionDclaration用構文解析メソッド
 3:   * @return 解析成功：PrototypeAST　解析失敗：NULL
 4:   */
 5: PrototypeAST *Parser::visitFunctionDeclaration() {
 6:   int bkup = Tokens->getCurIndex();
 7:   PrototypeAST *proto = visitPrototype();
 8:   if (!proto) {
 9:     return NULL;
10:   }
11: 
12:   // prototype;
13:   if (Tokens->getCurString() == ";") {
14: 
15:     // ここで再定義されていないか確認
16:     if (PrototypeTable.find(proto->getName()) != PrototypeTable.end() ||
17:         (FunctionTable.find(proto->getName()) != FunctionTable.end() &&
18:          FunctionTable[proto->getName()] != proto->getParamNum())) {
19: 
20:       // エラーメッセージを出してNULL返却
21:       fprintf(stderr, "Function：%s is redefined", proto->getName().c_str());
22:       SAFE_DELETE(proto);
23:       return NULL;
24:     }
25:     // (関数名，引数)のペアをプロトタイプ宣言テーブル(Map)に追加
26:     PrototypeTable[proto->getName()] = proto->getParamNum();
27:     Tokens->nextToken();
28:     return proto;
29:   } else {
30:     SAFE_DELETE(proto);
31:     Tokens->applyTokenIndex(bkup);
32:     return NULL;
33:   }
34: }

リスト5.26: 意味解析を実装したvisitFunctionDefinition

 1: /**
 2:   * FunctionDefinition用構文解析メソッド
 3:   * @return 解析成功：FunctionAST　解析失敗：NULL
 4:   */
 5: FunctionAST *Parser::visitFunctionDefinition() {
 6:   int bkup = Tokens->getCurIndex();
 7: 
 8:   PrototypeAST *proto = visitPrototype();
 9:   if (!proto) {
10:     return NULL;
11: 
12:   // ここでプロトタイプ宣言と違いがないか，
13:   // 既に関数定義が行われていないか確認
14:   } else if ((PrototypeTable.find(proto->getName()) != PrototypeTable.end() &&
15:               PrototypeTable[proto->getName()] != proto->getParamNum()) ||
16:              FunctionTable.find(proto->getName()) != FunctionTable.end()) {
17: 
18:     // エラーメッセージを出してNULL返却
19:     fprintf(stderr, "Function：%s is redefined", proto->getName().c_str());
20:     SAFE_DELETE(proto);
21:     return NULL;
22:   }
23: 
24:   VariableTable.clear();
25:   FunctionStmtAST *func_stmt = visitFunctionStatement(proto);
26:   if (func_stmt) {
27:     // ここで(関数名，引数の数)のペアを関数テーブル(Map)に追加
28:     FunctionTable[proto->getName()] = proto->getParamNum();
29: 
30:     return new FunctionAST(proto, func_stmt);
31:   }
32:   ・・・省略・・・
33: }

リスト5.27: 意味解析を実装したvisitPrototype

 1: /**
 2:   * Prototype用構文解析メソッド
 3:   * @return 解析成功：PrototypeAST　解析失敗：NULL
 4:   */
 5: PrototypeAST *Parser::visitPrototype() {
 6:   // indexを保存
 7:   int bkup = Tokens->getCurIndex();
 8:   ・・・省略・・・
 9:   std::vector<std::string> param_list;
10:   bool is_first_param = true;
11:   while (true) {
12:     if (!is_first_param && Tokens->getCurType() == TOK_SYMBOL &&
13:         Tokens->getCurString() == ",") {
14:       Tokens->nextToken();
15:     }
16:     if (Tokens->getCurType() == TOK_INT) {
17:       Tokens->nextToken();
18:     } else {
19:       break;
20:     }
21: 
22:     if (Tokens->getCurType() == TOK_IDENTIFIER) {
23:       // 引数の変数名に被りがないか確認
24:       if (std::find(param_list.begin(), param_list.end(),
25:                     Tokens->getCurString()) != param_list.end()) {
26:         Tokens->applyTokenIndex(bkup);
27:         return NULL;
28:       }
29:       param_list.push_back(Tokens->getCurString());
30:       Tokens->nextToken();
31:     } else {
32:       Tokens->applyTokenIndex(bkup);
33:       return NULL;
34:     }
35:   }
36:   　　・・・省略・・・
37: }

リスト5.28: 意味解析を実装したvisitFunctionStatement

 1: /**
 2:   * FunctionStatement用構文解析メソッド
 3:   * @param 関数名，引数を格納したPrototypeクラスのインスタンス
 4:   * @return 解析成功：FunctionStmtAST　解析失敗：NULL
 5:   */
 6: FunctionStmtAST *Parser::visitFunctionStatement(PrototypeAST *proto) {
 7:   int bkup = Tokens->getCurIndex();
 8: 
 9:   if (Tokens->getCurString() == "{") {
10:     Tokens->nextToken();
11:   } else {
12:     return NULL;
13:   }
14: 
15:   FunctionStmtAST *func_stmt = new FunctionStmtAST();
16: 
17:   ・・・省略・・・
18: 
19:   } else if (var_decl = visitVariableDeclaration()) {
20:     while (var_decl) {
21:       var_decl->setDeclType(VariableDeclAST::local);
22:       // 変数名に被りがないか確認
23:       if (std::find(VariableTable.begin(), VariableTable.end(),
24:                     var_decl->getName()) != VariableTable.end()) {
25:         SAFE_DELETE(var_decl);
26:         SAFE_DELETE(func_stmt);
27:         return NULL;
28:       }
29:       // 変数名テーブルに新しく読み取った変数名を追加
30:       VariableTable.push_back(var_decl->getName());
31:       func_stmt->addVariableDeclaration(var_decl);
32:       var_decl = visitVariableDeclaration();
33:     }
34: 
35:     if (stmt = visitStatement()) {
36:       while (stmt) {
37:         last_stmt = stmt;
38:         func_stmt->addStatement(stmt);
39:         stmt = visitStatement();
40:       }
41:     }
42: 
43:   // other
44:   } else {
45:     SAFE_DELETE(func_stmt);
46:     Tokens->applyTokenIndex(bkup);
47:     return NULL;
48:   }
49: 
50:   // 最後のStatementがjump_statementであるか確認
51:   if (!last_stmt || !isa<JumpStmtAST>(last_stmt)) {
52:     SAFE_DELETE(func_stmt);
53:     Tokens->applyTokenIndex(bkup);
54:     return NULL;
55:   }
56: 
57:   if (Tokens->getCurString() == "}") {
58:     Tokens->nextToken();
59:     return func_stmt;
60:   } else {
61:     SAFE_DELETE(func_stmt);
62:     Tokens->applyTokenIndex(bkup);
63:     return NULL;
64:   }
65: }

リスト5.29: 意味解析を実装したvisitAssignmentExpression

 1: /**
 2:   * AssignmentExpression用構文解析メソッド
 3:   * @return 解析成功：AST　解析失敗：NULL
 4:   */
 5: BaseAST *Parser::visitAssignmentExpression() {
 6:   int bkup = Tokens->getCurIndex();
 7: 
 8:   BaseAST *lhs;
 9:   if (Tokens->getCurType() == TOK_IDENTIFIER) {
10:     // 変数が宣言されているか確認
11:     if (std::find(VariableTable.begin(), VariableTable.end(),
12:                   Tokens->getCurString()) != VariableTable.end()) {
13:       lhs = new VariableAST(Tokens->getCurString());
14:       Tokens->nextToken();
15:       BaseAST *rhs;
16:       if (Tokens->getCurType() == TOK_SYMBOL && Tokens->getCurString() == "=") {
17:         Tokens->nextToken();
18:         if (rhs = visitAdditiveExpression(NULL)) {
19:           return new BinaryExprAST("=", lhs, rhs);
20:         } else {
21:           SAFE_DELETE(lhs);
22:           Tokens->applyTokenIndex(bkup);
23:         }
24:       } else {
25:         SAFE_DELETE(lhs);
26:         Tokens->applyTokenIndex(bkup);
27:       }
28:     } else {
29:       Tokens->applyTokenIndex(bkup);
30:     }
31:   }
32: 
33:   BaseAST *add_expr = visitAdditiveExpression(NULL);
34:   if (add_expr) {
35:     return add_expr;
36:   }
37:   return NULL;
38: }

リスト5.30: 意味解析を実装したvisitPrimaryExpression

 1: /**
 2:   * PrimaryExpression用構文解析メソッド
 3:   * @return 解析成功時：AST　失敗時：NULL
 4:   */
 5: BaseAST *Parser::visitPrimaryExpression() {
 6:   // recored index
 7:   int bkup = Tokens->getCurIndex();
 8: 
 9:   // 変数が宣言されていることを確認
10:   // VARIABLE_IDENTIFIER
11:   if (Tokens->getCurType() == TOK_IDENTIFIER &&
12:       (std::find(VariableTable.begin(), VariableTable.end(),
13:                  Tokens->getCurString()) != VariableTable.end())) {
14:     std::string var_name = Tokens->getCurString();
15:     Tokens->nextToken();
16:     return new VariableAST(var_name);
17: 
18:   // integer
19:   } else if (Tokens->getCurType() == TOK_DIGIT) {
20:     int val = Tokens->getCurNumVal();
21:     Tokens->nextToken();
22:     return new NumberAST(val);
23: 
24:   // integer(-)
25:   } else if (Tokens->getCurType() == TOK_SYMBOL &&
26:              Tokens->getCurString() == "-") {
27: 
28:     ・・・省略・・・
29:   }
30:   return NULL;
31: }

リスト5.31: 意味解析を実装したvisitPostfixExpression

 1: /**
 2:   * PostfixExpression用構文解析メソッド
 3:   * @return 解析成功：AST　解析失敗：NULL
 4:   */
 5: BaseAST *Parser::visitPostfixExpression() {
 6:   // get index
 7:   int bkup = Tokens->getCurIndex();
 8: 
 9:   ・・・省略・・・
10: 
11:   // FUNCTION_IDENTIFIER
12:   if (Tokens->getCurType() == TOK_IDENTIFIER) {
13:     int param_num;
14:     // プロトタイプ宣言されているか確認，引数の数をテーブルから取得
15:     if (PrototypeTable.find(Tokens->getCurString()) != PrototypeTable.end()) {
16:       param_num = PrototypeTable[Tokens->getCurString()];
17: 
18:     // 関数定義済みであるか確認，引数の数をテーブルから取得
19:     } else if (FunctionTable.find(Tokens->getCurString()) !=
20:                FunctionTable.end()) {
21:       param_num = FunctionTable[Tokens->getCurString()];
22:     } else {
23:       return NULL;
24:     }
25: 
26:     // 関数名取得
27:     std::string Callee = Tokens->getCurString();
28:     Tokens->nextToken();
29: 
30:     // LEFT PAREN
31:     if (Tokens->getCurType() != TOK_SYMBOL || Tokens->getCurString() != "(") {
32:       Tokens->applyTokenIndex(bkup);
33:       return NULL;
34:     }
35: 
36:     Tokens->nextToken();
37:     std::vector<BaseAST *> args;
38:     BaseAST *assign_expr = visitAssignmentExpression();
39:     if (assign_expr) {
40:       args.push_back(assign_expr);
41:       while (Tokens->getCurType() == TOK_SYMBOL &&
42:              Tokens->getCurString() == ",") {
43:         Tokens->nextToken();
44: 
45:         // IDENTIFIER
46:         assign_expr = visitAssignmentExpression();
47:         if (assign_expr) {
48:           args.push_back(assign_expr);
49:         } else {
50:           break;
51:         }
52:       } // end while
53:     }
54: 
55:     // 引数の数を確認
56:     if (args.size() != param_num) {
57:       for (int i = 0; i < args.size(); i++)
58:         SAFE_DELETE(args[i]);
59:       Tokens->applyTokenIndex(bkup);
60:       return NULL;
61:     }
62: 
63:     ・・・省略・・・
64:   }
65: }

リスト5.32: CodeGenクラスの宣言

 1: /**
 2:   * コード生成クラス
 3:   */
 4: class CodeGen {
 5: private:
 6:   Function *CurFunc; // 現在コード生成中のFunction
 7:   Module *Mod;       // 生成したModuleを格納
 8:   IRBuilder<> *Builder; // LLVM-IRを生成するIRBuilderクラス
 9: 
10: public:
11:   CodeGen();
12:   ~CodeGen();
13:   bool doCodeGen(TranslationUnitAST &tunit, std::string name);
14:   Module &getModule();
15: 
16: private:
17:   bool generateTranslationUnit(TranslationUnitAST &tunit, std::string name);
18:   Function *generateFunctionDefinition(FunctionAST *func, Module *mod);
19:   Function *generatePrototype(PrototypeAST *proto, Module *mod);
20:   Value *generateFunctionStatement(FunctionStmtAST *func_stmt);
21:   Value *generateVariableDeclaration(VariableDeclAST *vdecl);
22:   Value *generateStatement(BaseAST *stmt);
23:   Value *generateBinaryExpression(BinaryExprAST *bin_expr);
24:   Value *generateCallExpression(CallExprAST *call_expr);
25:   Value *generateJumpStatement(JumpStmtAST *jump_stmt);
26:   Value *generateVariable(VariableAST *var);
27:   Value *generateNumber(int value);
28: };

IRBuilder(LLVMContext &C, MDNode *FPMathTag = 0)

リスト5.33: CodeGenクラスのコンストラクタ

 1: /**
 2:   * コンストラクタ
 3:   */
 4: CodeGen::CodeGen(){
 5:   Builder = new IRBuilder<>(getGlobalContext());
 6:   Mod = NULL;
 7: }

リスト5.34: doCodeGen

 1: /**
 2:   * コード生成実行
 3:   * @param  TranslationUnitAST　Module名(入力ファイル名)
 4:   * @return 成功時：true　失敗時:false
 5:   */
 6: bool CodeGen::doCodeGen(TranslationUnitAST &tunit, std::string name) {
 7:   return generateTranslationUnit(tunit, name);
 8: }

リスト5.35: getModule

 1: /**
 2:   * Module取得
 3:   */
 4: Module &CodeGen::getModule(){
 5:   if(Mod)
 6:     return *Mod;
 7:   else
 8:     return *(new Module("null", getGlobalContext()));
 9: }

Module(StringRef ModuleID, LLVMContext &C)

リスト5.36: generateTranslationUnit

 1: /**
 2:   * Module生成メソッド
 3:   * @param  TranslationUnitAST Module名(入力ファイル名)
 4:   * @return 成功時：true　失敗時：false　
 5:   */
 6: bool CodeGen::generateTranslationUnit(TranslationUnitAST &tunit,
 7:                                       std::string name) {
 8:   // Moduleを生成
 9:   Mod = new Module(name, getGlobalContext());
10: 
11:   // funtion declaration
12:   for (int i = 0;; i++) {
13:     PrototypeAST *proto = tunit.getPrototype(i);
14:     if (!proto)
15:       break;
16:     else if (!generatePrototype(proto, Mod)) {
17:       SAFE_DELETE(Mod);
18:       return false;
19:     }
20:   }
21: 
22:   // function definition
23:   for (int i = 0;; i++) {
24:     FunctionAST *func = tunit.getFunction(i);
25:     if (!func)
26:       break;
27:     else if (!generateFunctionDefinition(func, Mod)) {
28:       SAFE_DELETE(Mod);
29:       return false;
30:     }
31:   }
32:   return true;
33: }

static Function *Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N = "", Module *M = 0)

static FunctionType *get(Type *Result, ArrayRef<Type *> Params, bool isVarArg)

static IntegerType *getInt32Ty(LLVMContext &C)

リスト5.37: generatePrototype

 1: /**
 2:   * 関数宣言生成メソッド
 3:   * @param  PrototypeAST, Module
 4:   * @return 生成したFunctionのポインタ
 5:   */
 6: Function *CodeGen::generatePrototype(PrototypeAST *proto, Module *mod) {
 7:   // already declared?
 8:   Function *func = mod->getFunction(proto->getName());
 9:   if (func) {
10:     if (func->arg_size() == proto->getParamNum() && func->empty()) {
11:       return func;
12:     } else {
13:       fprintf(stderr, "error::function %s is redefined",
14:               proto->getName().c_str());
15:       return NULL;
16:     }
17:   }
18: 
19:   // create arg_types
20:   std::vector<Type *> int_types(proto->getParamNum(),
21:                                 Type::getInt32Ty(getGlobalContext()));
22: 
23:   // create func type
24:   FunctionType *func_type =
25:       FunctionType::get(Type::getInt32Ty(getGlobalContext()), int_types, false);
26:   // create function
27:   func = Function::Create(func_type, Function::ExternalLinkage,
28:                           proto->getName(), mod);
29: 
30:   // set names
31:   Function::arg_iterator arg_iter = func->arg_begin();
32:   for (int i = 0; i < proto->getParamNum(); i++) {
33:     arg_iter->setName(proto->getParamName(i).append("_arg"));
34:     arg_iter++;
35:   }
36: 
37:   return func;
38: }

static BasicBlock *
Create(LLVMContext &Context, const Twine &Name = "", Function *Parent = 0,
       BasicBlock *InsertBefore = 0)

void SetInsertPoint(BasicBlock *TheBB)

リスト5.38: generateFunctionDefinition

 1: /**
 2:   * 関数定義生成メソッド
 3:   * @param  FunctionAST Module
 4:   * @return 生成したFunctionのポインタ
 5:   */
 6: Function *CodeGen::generateFunctionDefinition(FunctionAST *func_ast,
 7:                                               Module *mod) {
 8:   Function *func = generatePrototype(func_ast->getPrototype(), mod);
 9:   if (!func) {
10:     return NULL;
11:   }
12:   CurFunc = func;
13:   BasicBlock *bblock = BasicBlock::Create(getGlobalContext(), "entry", func);
14:   Builder->SetInsertPoint(bblock);
15:   // Functionのボディを生成
16:   generateFunctionStatement(func_ast->getBody());
17: 
18:   return func;
19: }

リスト5.39: generateFunctionStatement

 1: /**
 2:   * 関数生成メソッド
 3:   * 変数宣言、ステートメントの順に生成　
 4:   * @param  FunctionStmtAST
 5:   * @return 最後に生成したValueのポインタ
 6:   */
 7: Value *CodeGen::generateFunctionStatement(FunctionStmtAST *func_stmt) {
 8:   // insert variable decls
 9:   VariableDeclAST *vdecl;
10:   Value *v＝NULL;
11:   for (int i = 0;; i++) {
12:     // 最後まで見たら終了
13:     if (!func_stmt->getVariableDecl(i))
14:       break;
15: 
16:     // create alloca
17:     vdecl = dyn_cast<VariableDeclAST>(func_stmt->getVariableDecl(i));
18:     v = generateVariableDeclaration(vdecl);
19:   }
20: 
21:   // insert expr statement
22:   BaseAST *stmt;
23:   for (int i = 0;; i++) {
24:     // 最後まで見たら終了
25:     stmt = func_stmt->getStatement(i);
26:     if (!stmt)
27:       break;
28:     else if (!isa<NullExprAST>(stmt))
29:       v = generateStatement(stmt);
30:   }
31:   return v;
32: }

AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = 0, const Twine &Name = "")

StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false)

リスト5.40: generateVariableDeclaration

 1: /**
 2:   * 変数宣言(alloca命令)生成メソッド
 3:   * @param VariableDeclAST
 4:   * @return 生成したValueのポインタ
 5:   */
 6: Value *CodeGen::generateVariableDeclaration(VariableDeclAST *vdecl) {
 7:   // create alloca
 8:   AllocaInst *alloca = Builder->CreateAlloca(
 9:       Type::getInt32Ty(getGlobalContext()), 0, vdecl->getName());
10: 
11:   // if alloca is used for function arguments
12:   if (vdecl->getType() == VariableDeclAST::param) {
13:     // store args
14:     ValueSymbolTable &vs_table = CurFunc->getValueSymbolTable();
15:     Builder->CreateStore(vs_table.lookup(vdecl->getName().append("_arg")),
16:                          alloca);
17:   }
18:   return alloca;
19: }

リスト5.41: generateStatement

 1: /**
 2:   * ステートメント生成メソッド
 3:   * 実際にはASTの種類を確認して各種生成メソッドを呼び出し
 4:   * @param  JumpStmtAST
 5:   * @return 生成したValueのポインタ
 6:   */
 7: Value *CodeGen::generateStatement(BaseAST *stmt) {
 8:   if (isa<BinaryExprAST>(stmt)) {
 9:     return generateBinaryExpression(dyn_cast<BinaryExprAST>(stmt));
10:   } else if (isa<CallExprAST>(stmt)) {
11:     return generateCallExpression(dyn_cast<CallExprAST>(stmt));
12:   } else if (isa<JumpStmtAST>(stmt)) {
13:     return generateJumpStatement(dyn_cast<JumpStmtAST>(stmt));
14:   } else {
15:     return NULL;
16:   }
17: }

Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "", bool HasNUW = false,
                 bool HasNSW = false)
Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "", bool HasNUW = false,
                 bool HasNSW = false)
Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "", bool HasNUW = false,
                 bool HasNSW = false)
Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name= "",
                  bool isExact = false)

リスト5.42: generateBinaryExpression

 1: /**
 2:   * 二項演算生成メソッド
 3:   * @param  JumpStmtAST
 4:   * @return 生成したValueのポインタ
 5:   */
 6: Value *CodeGen::generateBinaryExpression(BinaryExprAST *bin_expr) {
 7:   BaseAST *lhs = bin_expr->getLHS();
 8:   BaseAST *rhs = bin_expr->getRHS();
 9: 
10:   Value *lhs_v;
11:   Value *rhs_v;
12: 
13:   // assignment
14:   if (bin_expr->getOp() == "=") {
15:     printf("genStore\n");
16:     // lhs is variable
17:     VariableAST *lhs_var = dyn_cast<VariableAST>(lhs);
18:     ValueSymbolTable &vs_table = CurFunc->getValueSymbolTable();
19:     lhs_v = vs_table.lookup(lhs_var->getName());
20: 
21:   // other operand
22:   } else {
23:     // lhs=?
24:     // Binary?
25:     if (isa<BinaryExprAST>(lhs))
26:       lhs_v = generateBinaryExpression(dyn_cast<BinaryExprAST>(lhs));
27: 
28:     // Variable?
29:     else if (isa<VariableAST>(lhs))
30:       lhs_v = generateVariable(dyn_cast<VariableAST>(lhs));
31: 
32:     // Number?
33:     else if (isa<NumberAST>(lhs)) {
34:       NumberAST *num = dyn_cast<NumberAST>(lhs);
35:       lhs_v = generateNumber(num->getNumberValue());
36:     }
37:   }
38: 
39:   // create rhs value
40:   if (isa<BinaryExprAST>(rhs)) {
41:     rhs_v = generateBinaryExpression(dyn_cast<BinaryExprAST>(rhs));
42: 
43:   // CallExpr?
44:   } else if (isa<CallExprAST>(rhs)) {
45:     rhs_v = generateCallExpression(dyn_cast<CallExprAST>(rhs));
46: 
47:   // Variable?
48:   } else if (isa<VariableAST>(rhs)) {
49:     rhs_v = generateVariable(dyn_cast<VariableAST>(rhs));
50: 
51:   // Number?
52:   } else if (isa<NumberAST>(rhs)) {
53:     NumberAST *num = dyn_cast<NumberAST>(rhs);
54:     rhs_v = generateNumber(num->getNumberValue());
55:   }
56: 
57:   if (bin_expr->getOp() == "=") {
58:     // store
59:     return Builder->CreateStore(rhs_v, lhs_v);
60:   } else if (bin_expr->getOp() == "+") {
61:     // add
62:     return Builder->CreateAdd(lhs_v, rhs_v, "add_tmp");
63:   } else if (bin_expr->getOp() == "-") {
64:     // sub
65:     return Builder->CreateSub(lhs_v, rhs_v, "sub_tmp");
66:   } else if (bin_expr->getOp() == "*") {
67:     // mul
68:     return Builder->CreateMul(lhs_v, rhs_v, "mul_tmp");
69:   } else if (bin_expr->getOp() == "/") {
70:     // div
71:     return Builder->CreateSDiv(lhs_v, rhs_v, "div_tmp");
72:   }
73: }

CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args, const Twine &Name = "")

リスト5.43: generateCallExpression

 1: /**
 2:   * 関数呼び出し(Call命令)生成メソッド
 3:   * @param CallExprAST
 4:   * @return 生成したValueのポインタ　
 5:   */
 6: Value *CodeGen::generateCallExpression(CallExprAST *call_expr) {
 7:   std::vector<Value *> arg_vec;
 8:   BaseAST *arg;
 9:   Value *arg_v;
10:   ValueSymbolTable &vs_table = CurFunc->getValueSymbolTable();
11:   for (int i = 0;; i++) {
12:     if (!(arg = call_expr->getArgs(i)))
13:       break;
14: 
15:     // isCall
16:     if (isa<CallExprAST>(arg))
17:       arg_v = generateCallExpression(dyn_cast<CallExprAST>(arg));
18: 
19:     // isBinaryExpr
20:     else if (isa<BinaryExprAST>(arg)) {
21:       BinaryExprAST *bin_expr = dyn_cast<BinaryExprAST>(arg);
22:       arg_v = generateBinaryExpression(dyn_cast<BinaryExprAST>(arg));
23:       if (bin_expr->getOp() == "=") {
24:         VariableAST *var = dyn_cast<VariableAST>(bin_expr->getLHS());
25:         arg_v = Builder->CreateLoad(vs_table.lookup(var->getName()), "arg_val");
26:       }
27:     }
28: 
29:     // isVar
30:     else if (isa<VariableAST>(arg))
31:       arg_v = generateVariable(dyn_cast<VariableAST>(arg));
32: 
33:     // isNumber
34:     else if (isa<NumberAST>(arg)) {
35:       NumberAST *num = dyn_cast<NumberAST>(arg);
36:       arg_v = generateNumber(num->getNumberValue());
37:     }
38:     arg_vec.push_back(arg_v);
39:   }
40:   return Builder->CreateCall(Mod->getFunction(call_expr->getCallee()), arg_vec,
41:                              "call_tmp");
42: }

ReturnInst *CreateRet(Value *V)

リスト5.44: generateJumpStatement

 1: /**
 2:   * ジャンプ(今回はreturn命令のみ)生成メソッド
 3:   * @param  JumpStmtAST
 4:   * @return 生成したValueのポインタ
 5:   */
 6: Value *CodeGen::generateJumpStatement(JumpStmtAST *jump_stmt) {
 7:   BaseAST *expr = jump_stmt->getExpr();
 8:   Value *ret_v;
 9:   if (isa<BinaryExprAST>(expr)) {
10:     ret_v = generateBinaryExpression(dyn_cast<BinaryExprAST>(expr));
11:   } else if (isa<VariableAST>(expr)) {
12:     VariableAST *var = dyn_cast<VariableAST>(expr);
13:     ret_v = generateVariable(var);
14:   } else if (isa<NumberAST>(expr)) {
15:     NumberAST *num = dyn_cast<NumberAST>(expr);
16:     ret_v = generateNumber(num->getNumberValue());
17:   }
18:   Builder->CreateRet(ret_v);
19: }

LoadInst *CreateLoad(Value *Ptr, const Twine &Name = "")

リスト5.45: generateVariable

 1: /**
 2:   * 変数参照(load命令)生成メソッド
 3:   * @param VariableAST
 4:   * @return  生成したValueのポインタ
 5:   */
 6: Value *CodeGen::generateVariable(VariableAST *var) {
 7:   ValueSymbolTable &vs_table = CurFunc->getValueSymbolTable();
 8:   return Builder->CreateLoad(vs_table.lookup(var->getName()), "var_tmp");
 9: }

static ConstantInt *get(LLVMContext &Context, const APInt &V)

リスト5.46: generateNumber

 1: /**
 2:  * 定数生成メソッド
 3:  * @param 生成する定数の値
 4:  * @return 生成したValueのポインタ
 5:  */
 6: Value *CodeGen::generateNumber(int value) {
 7:   return ConstantInt::get(Type::getInt32Ty(getGlobalContext()), value);
 8: }

リスト5.47: OptionParser

 1: /**
 2:  * オプション切り出し用クラス
 3:  */
 4: class OptionParser {
 5: private:
 6:   std::string InputFilename;
 7:   std::string OutputFilename;
 8:   int Argc;
 9:   char **Argv;
10: 
11: public:
12:   OptionParser(int argc, char **argv) : Argc(argc), Argv(argv) {}
13:   void printHelp() {
14:     // ヘルプ表示
15:     fprintf(stdout,
16:             "Compiler for DummyC...\n 試作中なのでバグがあったらご報告を\n");
17:   }
18:   void printHelp();
19:   std::string getInputFileName() { return InputFilename; } //入力ファイル名取得
20:   std::string getOutputFileName() { return OutputFilename; } //出力ファイル名取得
21:   bool parseOption();    //オプション切出しメソッド
22: };

リスト5.48: ParseOption

 1: /**
 2:  * オプション切り出し
 3:  * @return 成功時：true　失敗時：false
 4:  */
 5: bool OptionParser::parseOption() {
 6:   if (Argc < 2) {
 7:     fprintf(stderr, "引数が足りません\n");
 8:     return false;
 9:   }
10: 
11:   for (int i = 1; i < Argc; i++) {
12:     if (Argv[i][0] == '-' && Argv[i][1] == 'o' && Argv[i][2] == '\0') {
13:       // output filename
14:       OutputFilename.assign(Argv[++i]);
15:     } else if (Argv[i][0] == '-' && Argv[i][1] == 'h' && Argv[i][2] == '\0') {
16:       printHelp();
17:       reutrn false;
18:     } else if (Argv[i][0] == '-') {
19:       fprintf(stderr, "%s は不明なオプションです\n", Argv[i]);
20:       return false;
21:     } else {
22:       // inputfilename
23:       InputFilename.assign(Argv[i]);
24:     }
25:   }
26: 
27:   // OutputFilename
28:   std::string ifn = InputFilename;
29:   int len = ifn.length();
30:   if (OutputFilename.empty() && (len > 2) && ifn[len - 3] == '.' &&
31:       ((ifn[len - 2] == 'd' && ifn[len - 1] == 'c'))) {
32:     OutputFilename = std::string(ifn.begin(), ifn.end() - 3);
33:     OutputFilename += ".ll";
34:   } else if (OutputFilename.empty()) {
35:     OutputFilename = ifn;
36:     OutputFilename += ".ll";
37:   }
38: 
39:   return true;
40: }

リスト5.49: 初期化

 1: /**
 2:  * main関数
 3:  */
 4: int main(int argc, char **argv) {
 5:   InitializeNativeTarget();
 6:   sys::PrintStackTraceOnErrorSignal();
 7:   PrettyStackTraceProgram X(argc, argv);
 8:   EnableDebugBuffering = true;
 9: 
10:   OptionParser opt(argc, argv);
11:   if (!opt.parseOption())
12:     exit(1);
13: 
14:   ・・・省略・・・
15: }

リスト5.50: 作成した各種クラスによるコンパイル実行

 1: /**
 2:  * main関数
 3:  */
 4: int main(int argc, char **argv) {
 5:   ・・・初期化処理・・・
 6: 
 7:   // check
 8:   if (opt.getInputFileName().length() == 0) {
 9:     fprintf(stderr, "入力ファイル名が指定されていません\n");
10:     exit(1);
11:   }
12: 
13:   // lex and parse
14:   Parser *parser = new Parser(opt.getInputFileName());
15:   if (!parser->doParse()) {
16:     fprintf(stderr, "err at parser or lexer\n");
17:     SAFE_DELETE(parser);
18:     exit(1);
19:   }
20: 
21:   // get AST
22:   TranslationUnitAST &tunit = parser->getAST();
23:   if (tunit.empty()) {
24:     fprintf(stderr, "TranslationUnit is empty");
25:     SAFE_DELETE(parser);
26:     exit(1);
27:   }
28: 
29:   CodeGen *codegen = new CodeGen();
30:   if (!codegen->doCodeGen(tunit, opt.getInputFileName())) {
31:     fprintf(stderr, "err at codegen\n");
32:     SAFE_DELETE(parser);
33:     SAFE_DELETE(codegen);
34:     exit(1);
35:   }
36: 
37:   // get Module
38:   Module &mod = codegen->getModule();
39:   if (mod.empty()) {
40:     fprintf(stderr, "Module is empty");
41:     SAFE_DELETE(parser);
42:     SAFE_DELETE(codegen);
43:     exit(1);
44:   }
45: 
46:   ・・・ファイル出力と終了処理・・・
47: }

ModulePass *llvm::createPrintModulePass(raw_ostream * OS,
                                        bool DeleteStream = false,
                                        const std::string &Banner = "")

raw_fd_ostream(const char *Filename, std::string &ErrorInfo, unsigned Flags = 0)

リスト5.51: ファイル出力と終了処理

 1: /**
 2:  * main関数
 3:  */
 4: int main(int argc, char **argv) {
 5: 
 6:   ・・・初期化処理とコンパイル・・・
 7: 
 8:   PassManager pm;
 9: 
10:   //出力
11:   std::string error;
12:   raw_fd_ostream raw_stream(opt.getOutputFileName().c_str(), error);
13:   pm.add(createPrintModulePass(&raw_stream));
14:   pm.run(mod);
15:   raw_stream.close();
16: 
17:   // delete
18:   SAFE_DELETE(parser);
19:   SAFE_DELETE(codegen);
20: 
21:   return 0;
22: }

# githubからソースコードを取得
$ git clone git@github.com:Kmotiko/DummyCCompiler.git DummyCCompiler
$ cd DummyCCompiler

# チェックアウト
$ git checkout llvm-3.2_ch5.9

# 一時ファイル用ディレクトリを作成
$ mkdir -p ./obj

# dcc.cppを-cオプションでコンパイル
$ g++ -g ./src/dcc.cpp -I./inc `llvm-config --cxxflags --ldflags --libs` \
  -c -o ./obj/dcc.o

# lexer.cppを-cオプションでコンパイル
$ g++ -g ./src/lexer.cpp -I./inc `llvm-config --cxxflags --ldflags --libs` \
  -c -o ./obj/lexer.o

# AST.cppを-cオプションでコンパイル
$ g++ -g ./src/AST.cpp -I./inc `llvm-config --cxxflags --ldflags --libs` \
  -c -o ./obj/AST.o

# parser.cppを-cオプションでコンパイル
$ g++ -g ./src/parser.cpp -I./inc `llvm-config --cxxflags --ldflags --libs` \
  -c -o ./obj/parser.o

# codegen.cppを-cオプションでコンパイル
$ g++ -g ./src/codegen.cpp -I./inc `llvm-config --cxxflags --ldflags --libs` \
  -c -o ./obj/codegen.o

# 実行ファイル用ディレクトリを作成
$ mkdir -p ./bin

# 各オブジェクトファイルをリンクして実行ファイルdccを生成
$ g++ -g ./obj/dcc.o ./obj/lexer.o ./obj/AST.o ./obj/parser.o ./obj/codegen.o \
  `llvm-config --cxxflags --ldflags --libs` -ldl -o ./bin/dcc

リスト5.52: DummyCのサンプルコード

 1: int test(int j) {
 2:   int i;
 3:   i = j * 10;
 4:   return i;
 5: }
 6: 
 7: int main() {
 8:   int i;
 9:   i = 10;
10:   test(i);
11:   return 0;
12: }

# dccでサンプルコードをコンパイル
$ ./bin/dcc ./sample/test.dc -o ./sample/test.ll

リスト5.53: サンプルコードのLLVM IR表現

 1: ; ModuleID = './sample/test.dc'
 2: 
 3: define i32 @test(i32 %j_arg) {
 4: entry:
 5:   %j = alloca i32
 6:   store i32 %j_arg, i32* %j
 7:   %i = alloca i32
 8:   %var_tmp = load i32* %j
 9:   %mul_tmp = mul i32 %var_tmp, 10
10:   store i32 %mul_tmp, i32* %i
11:   %var_tmp1 = load i32* %i
12:   ret i32 %var_tmp1
13: }
14: 
15: define i32 @main() {
16: entry:
17:   %i = alloca i32
18:   store i32 10, i32* %i
19:   %var_tmp = load i32* %i
20:   %call_tmp = call i32 @test(i32 %var_tmp)
21:   ret i32 0
22: }

リスト5.54: PromotePassの追加

 1: /**
 2:  * main関数
 3:  */
 4: int main(int argc, char **argv) {
 5: 
 6:   ・・・初期化処理・コード生成・・・
 7: 
 8:   PassManager pm;
 9: 
10:   // mem2regをPassManagerに登録
11:   pm.add(createPromoteMemoryToRegisterPass());
12: 
13:   // 出力
14:   std::string error;
15:   raw_fd_ostream raw_stream(opt.getOutputFileName().c_str(), error);
16:   pm.add(createPrintModulePass(&raw_stream));
17:   pm.run(mod);
18:   raw_stream.close();
19: 
20:   ・・・終了処理・・・
21: }

リスト5.55: mem2reg適用後のLLVM

 1: ; ModuleID = './sample/test.dc'
 2: 
 3: declare i32 @printnum(i32)
 4: 
 5: define i32 @test(i32 %j_arg) {
 6: entry:
 7:   %mul_tmp = mul i32 %j_arg, 10
 8:   ret i32 %mul_tmp
 9: }
10: 
11: define i32 @main() {
12: entry:
13:   %call_tmp = call i32 @test(i32 10)
14:   ret i32 0
15: }

リスト5.56: printnumの定義

 1: #include <stdio.h>
 2: 
 3: int printnum(int i){
 4:   return printf("%d\n",i);
 5: }

$ clang -emit-llvm -S -O -o printnum.ll printnum.c

リスト5.57: printnumのLLVM IR

 1: ; ModuleID = 'lib/src/printnum.c'
 2: target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"
 3: target triple = "i386-pc-linux-gnu"
 4: 
 5: @.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
 6: 
 7: define i32 @printnum(i32 %i) nounwind {
 8: entry:
 9:   %call = tail call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i32 %i) nounwind
10:   ret i32 %call
11: }
12: 
13: declare i32 @printf(i8* nocapture, ...) nounwind

リスト5.58: システム関数導入によるvisitTranslationUnitの修正

 1: /**
 2:   * TranslationUnit用構文解析メソッド
 3:   * @return 解析成功：true　解析失敗：false
 4:   */
 5: bool Parser::visitTranslationUnit() {
 6:   // 最初にprintnumの宣言追加
 7:   TU = new TranslationUnitAST();
 8:   std::vector<std::string> param_list;
 9:   param_list.push_back("i");
10:   TU->addPrototype(new PrototypeAST("printnum", param_list));
11:   PrototypeTable["printnum"] = 1;
12: 
13:   ・・・省略・・・
14: }

リスト5.59: printnumを含むDummyCのサンプルコード

 1: int test(int j) {
 2:   int i;
 3:   i = j * 10;
 4:   return i;
 5: }
 6: 
 7: int main() {
 8:   int i;
 9:   i = 10;
10:   printnum(test(i));
11:   return 0;
12: }

リスト5.60: printnumを含むDummyCのLLVM IR

 1: ; ModuleID = './sample/test.dc'
 2: 
 3: declare i32 @printnum(i32)
 4: 
 5: define i32 @test(i32 %j_arg) {
 6: entry:
 7:   %mul_tmp = mul i32 %j_arg, 10
 8:   ret i32 %mul_tmp
 9: }
10: 
11: define i32 @main() {
12: entry:
13:   %call_tmp = call i32 @test(i32 10)
14:   %call_tmp1 = call i32 @printnum(i32 %call_tmp)
15:   ret i32 0
16: }

$ llvm-link test.ll printnum.ll -S -o  link_test.ll
$ lli link_test.ll
100

リスト5.61: リンク後のLLVM IR

 1: ; ModuleID = 'test.ll'
 2: target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"
 3: target triple = "i386-pc-linux-gnu"
 4: 
 5: @.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
 6: 
 7: define i32 @test(i32 %j_arg) {
 8: entry:
 9:   %mul_tmp = mul i32 %j_arg, 10
10:   ret i32 %mul_tmp
11: }
12: 
13: define i32 @main() {
14: entry:
15:   %call_tmp = call i32 @test(i32 10)
16:   %call_tmp1 = call i32 @printnum(i32 %call_tmp)
17:   ret i32 0
18: }
19: 
20: define i32 @printnum(i32 %i) nounwind {
21: entry:
22:   %call = tail call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i32 %i) nounwind
23:   ret i32 %call
24: }
25: 
26: declare i32 @printf(i8* nocapture, ...) nounwind

$ llc -o link_test.s link_test.ll
$ gcc -o link_test link_test.s
$ ./link_test
100

llvm::EngineBuilder::EngineBuilder(Module *m)

ExecutionEngine *llvm::EngineBuilder::create()

EngineBuilder &setEngineKind(EngineKind::Kind w)

EngineBuilder &setUseMCJIT(bool Value)

リスト5.62: ExecutionEngine生成を追加したdoCodeGen

 1: /**
 2:  * 引数を追加してJITが出来るように変更
 3:  */
 4: bool CodeGen::doCodeGen(TranslationUnitAST &tunit, std::string name,
 5:                         bool with_jit = false) {
 6:   // Module生成に失敗したら終了
 7:   if (!generateTranslationUnit(tunit, name)) {
 8:     return false;
 9:   }
10: 
11:   // JITのフラグが立っていたらJIT
12:   if (with_jit) {
13:     // ExecutionEngine生成
14:     ExecutionEngine *EE = EngineBuilder(Mod).create();
15: 
16:     ・・・最終的にこのあたりで関数を実行・・・
17:   }
18: 
19:   return true;
20: }

void *JIT::getPointerToFunction(Function *F)

リスト5.63: ExecutionEngine生成を追加したdoCodeGen

 1: /**
 2:  * 引数を追加してJITが出来るように変更
 3:  */
 4: bool CodeGen::doCodeGen(TranslationUnitAST &tunit, std::string name,
 5:                         bool with_jit = false) {
 6:   // Module生成に失敗したら終了
 7:   if (!generateTranslationUnit(tunit, name)) {
 8:     return false;
 9:   }
10: 
11:   // JITのフラグが立っていたらJIT
12:   if (with_jit) {
13:     llvm::ExecutionEngine *EE = llvm::EngineBuilder(Mod).create();
14:     llvm::Function *F;
15: 
16:     // main関数へのポインタを取得
17:     if (!(F = Mod->getFunction("main")))
18:       return false;
19: 
20:     // JIT済みmain関数のポインタを取得
21:     int (*fp)() = (int (*)())EE->getPointerToFunction(F);
22:     fprintf(stderr, "%d\n", fp());
23:   }
24: 
25:   return true;
26: }

リスト5.64: OptionParserクラスとmain関数の修正（JITの追加)

 1: /**
 2:  * オプション切り出し
 3:  * @return 成功時：true　失敗時：false
 4:  */
 5: bool OptionParser::parseOption() {
 6:   ・・・省略・・・
 7: 
 8:   for (int i = 1; i < Argc; i++) {
 9:     // 出力ファイル名取得
10:     if (Argv[i][0] == '-' && Argv[i][1] == 'o' && Argv[i][2] == '\0') {
11:       // output filename
12:       OutputFilename.assign(Argv[++i]);
13: 
14:     // ヘルプ
15:     } else if (Argv[i][0] == '-' && Argv[i][1] == 'h' && Argv[i][2] == '\0') {
16:       printHelp();
17:       reutrn false;
18: 
19:     // -jitが指定されたときはJITの有効フラグをtrueにする
20:     } else if (Argv[i][0] == '-' && Argv[i][1] == 'j' && Argv[i][2] == 'i' &&
21:                Argv[i][3] == 't' && Argv[i][4] == '\0') {
22:       WithJit = true;
23: 
24:     // 不明なオプション
25:     } else if (Argv[i][0] == '-') {
26:       fprintf(stderr, "%s は不明なオプションです\n", Argv[i]);
27:       return false;
28: 
29:     // 入力ファイル名取得
30:     } else {
31:       // inputfilename
32:       InputFileName.assign(Argv[i]);
33:     }
34:   }
35: 
36:   ・・・省略・・・
37: 
38:   return true;
39: }
40: 
41: /**
42:  * JIT実行フラグ取得
43:  */
44: bool OptionParser::getWithJit() { return WithJit; }
45: 
46: /**
47:  * main関数
48:  */
49: int main(int argc, char **argv) {
50:   ・・・省略・・・
51: 
52:   // コード生成実行時の引数を追加
53:   CodeGen *codegen = new CodeGen();
54:   if (!codegen->doCodeGen(tunit, opt.getInputFileName(), opt.getWithJit())) {
55:     fprintf(stderr, "err at codegen\n");
56:     SAFE_DELETE(parser);
57:     SAFE_DELETE(codegen);
58:     exit(1);
59:   }
60: 
61:   ・・・省略・・・
62: }

リスト5.65: DummyCのサンプルコード

 1: int main(){
 2:   return 0;
 3: }

# dccでサンプルコードをコンパイル
$ ./bin/dcc ./sample/test.dc -o ./sample/test.ll -jit
0

void DisableLazyCompilation(bool Disabled = true)

Module *ParseIRFile(const std::string &Filename, SMDiagnostic &Err, LLVMContext &Context)

static bool LinkModules(Module *Dest, Module *Src, unsigned Mode, std::string *ErrorMsg)

リスト5.66: linkModule

 1: /**
 2:  * Module結合用メソッド
 3:  */
 4: bool CodeGen::linkModule(llvm::Module *dest, std::string file_name) {
 5:   SMDiagnostic err;
 6:   // Moduleの読み込み
 7:   llvm::Module *link_mod =
 8:       llvm::ParseIRFile(file_name, err, llvm::getGlobalContext());
 9:   if (!link_mod)
10:     return false;
11: 
12:   // Moduleの結合
13:   std::string err_msg;
14:   if (llvm::Linker::LinkModules(dest, link_mod, llvm::Linker::DestroySource,
15:                                 &err_msg))
16:     return false;
17: 
18:   SAFE_DELETE(link_mod);
19: 
20:   return true;
21: }

リスト5.67: ExecutionEngine生成を追加したdoCodeGen

 1: /**
 2:  * 外部Module結合機能を追加したdoCodeGenメソッド
 3:  */
 4: bool CodeGen::doCodeGen(TranslationUnitAST &tunit, std::string name,
 5:                         std::string link_file, bool with_jit = false) {
 6:   if (!generateTranslationUnit(tunit, name)) {
 7:     return false;
 8:   }
 9: 
10:   // LinkFileの指定があったらModuleをリンク
11:   if (!link_file.empty() && !linkModule(link_file))
12:     return false;
13: 
14:   // JITのフラグが立っていたらJIT
15:   if (with_jit) {
16:     // ExecutionEngine生成
17:     EE = EngineBuilder(Mod).create();
18:     Function *F;
19: 
20:     // main関数のFunction取得
21:     if (!(F = Mod->getFunction("main")))
22:       return false;
23: 
24:     //コンパイル済みmain関数を取得して実行
25:     int (*fp)() = (int (*)())EE->getPointerToFunction(F);
26:     fprintf(stderr, "%d\n", fp());
27:   }
28: 
29:   return true;
30: }

リスト5.68: OptionParserクラスとmain関数の修正(リンク機能の追加)

 1: /**
 2:  * オプション切り出し
 3:  * @return 成功時：true　失敗時：false
 4:  */
 5: bool OptionParser::parseOption() {
 6:   ・・・省略・・・
 7: 
 8:   for (int i = 1; i < Argc; i++) {
 9:     // 出力ファイル名取得
10:     if (Argv[i][0] == '-' && Argv[i][1] == 'o' && Argv[i][2] == '\0') {
11:       // output filename
12:       OutputFilename.assign(Argv[++i]);
13: 
14:     //ヘルプ
15:     } else if (Argv[i][0] == '-' && Argv[i][1] == 'h' && Argv[i][2] == '\0') {
16:       printHelp();
17:       reutrn false;
18: 
19:     // -jitが指定されたときはJITの有効フラグをtrueにする
20:     } else if (Argv[i][0] == '-' && Argv[i][1] == 'j' && Argv[i][2] == 'i' &&
21:                Argv[i][3] == 't' && Argv[i][4] == '\0') {
22:       WithJit = true;
23: 
24:     // -lオプションが指定されたときは次のワードをリンクするファイル名として取得
25:     } else if (Argv[i][0] == '-' && Argv[i][1] == 'l' && Argv[i][2] == '\0') {
26:       LinkFileName.assign(Argv[++i]);
27: 
28:     // 不明なオプション
29:     } else if (Argv[i][0] == '-') {
30:       fprintf(stderr, "%s は不明なオプションです\n", Argv[i]);
31:       return false;
32: 
33:     // 入力ファイル名
34:     } else {
35:       // inputfilename
36:       InputFileName.assign(Argv[i]);
37:     }
38:   }
39: 
40:   ・・・省略・・・
41: 
42:   return true;
43: }
44: 
45: /**
46:  *リンクするファイルを取得
47:  */
48: std::string OptionParser::getLinkFileName() { return LinkFileName; }
49: 
50: /**
51:  * main関数
52:  */
53: int main(int argc, char **argv) {
54:   ・・・省略・・・
55: 
56:   // コード生成実行時の引数を追加
57:   CodeGen *codegen = new CodeGen();
58:   if (!codegen->doCodeGen(tunit, opt.getInputFileName(), opt.getLinkFileName(),
59:                           opt.getWithJit())) {
60:     fprintf(stderr, "err at codegen\n");
61:     SAFE_DELETE(parser);
62:     SAFE_DELETE(codegen);
63:     exit(1);
64:   }
65: 
66:   ・・・省略・・・
67: }

リスト5.69: DummyCのサンプルコード

 1: int test(int j){
 2:   printnum(i);
 3:   return 0;
 4: }
 5: 
 6: int main() {
 7:   int i;
 8:   i = 10;
 9:   test(i);
10:   return 0;
11: }

# dccにprintnumのLLVM IRを結合させてJITの処理をさせる
# -l ./lib/printnum.llでリンクするLLVM IRのパスを指定
$ ./bin/dcc -o ./sample/test.ll -l ./lib/printnum.ll ./sample/test.dc -jit
10
0

MDBuilder(LLVMContext &context)

MDString *createString(StringRef Str)
MDNode *createFPMath(float Accuracy)
MDNode *createRange(const APInt &Lo, const APInt &Hi)
MDNode *createAnonymousTBAARoot()
MDNode *createTBAARoot(StringRef Name)
MDNode *createTBAANode(StringRef Name, MDNode *Parent, bool isConstant = false)
MDNode *createTBAAStructNode(ArrayRef<TBAAStructField> Fields)
MDNode *createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight)
MDNode *createBranchWeights(ArrayRef<uint32_t> Weights)

リスト5.70: range Metadata生成のサンプルコード

 1: //MDBuilderの生成
 2: MDBuilder *MDB = new llvm::MDBuilder(llvm::getGlobalContext());
 3: 
 4: //0～100をあらわすrange Metadataの生成
 5: llvm::MDNode *mdn = MDB->createRange(llvm::APInt(32,0),llvm::APInt(32,100));

APInt(unsigned numBits, uint64_t val, bool isSigned = false)

リスト5.71: fpmath Metadata生成のサンプルコード

 1: //MDBuilderの生成
 2: MDBuilder *MDB = new llvm::MDBuilder(llvm::getGlobalContext());
 3: 
 4: //0.5 ULPのfpmath Metadataの生成
 5: llvm::MDNode *mdn = MDB->createFPMath(0.5);

void setMetadata(unsigned KindID, MDNode *Node)
void setMetadata(StringRef Kind, MDNode *Node)

unsigned LLVMContext::getMDKindID(StringRef Name)

リスト5.72: Metadata生成のサンプルコード

 1: //MDBuilderの生成
 2: MDBuilder *MDB = new llvm::MDBuilder(llvm::getGlobalContext());
 3: 
 4: //range Metadataの生成
 5: llvm::MDNode *mdn = MDB->createRange(llvm::APInt(32,0),llvm::APInt(32,100));
 6: 
 7: //load_valをロードするload命令を生成
 8: llvm::Instruction *inst = Builder->CreateLoad(load_val, "sample_var");
 9: 
10: //load命令へMetadataを付与
11: inst->setMetadata(llvm::getGlobalContext().getMDKindID("range"), mdn);

リスト5.73: 生成されるMetadata付きのLLVM IR

 1: ・・・省略・・・
 2: %sample_var = load i32* %i, !range !0
 3: ・・・省略・・・
 4: !0 = metadata !{i32 0, i32 100}

Value *CreateFAdd(Value *LHS, Value *RHS, const Twine &Name = "", MDNode *FPMathTag = 0)
Value *CreateFSub(Value *LHS, Value *RHS, const Twine &Name = "", MDNode *FPMathTag = 0)
Value *CreateFMul(Value *LHS, Value *RHS, const Twine &Name = "", MDNode *FPMathTag = 0)
Value *CreateFDiv(Value *LHS, Value *RHS, const Twine &Name = "", MDNode *FPMathTag = 0)
Value *CreateFRem(Value *LHS, Value *RHS, const Twine &Name = "", MDNode *FPMathTag = 0)
Value *CreateFNeg(Value *V, const Twine &Name= "" , MDNode *FPMathTag = 0)

BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
                         MDNode *BranchWeights = 0)
SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
                         MDNode *BranchWeights = 0)

リスト5.74: createFXXメソッドを使用する際のサンプルコード

 1: // MDBuilderの生成
 2: MDBuilder *MDB = new llvm::MDBuilder(llvm::getGlobalContext());
 3: 
 4: // 0.5 ULPのfpmath Metadataの生成
 5: llvm::MDNode *mdn = MDB->createFPMath(0.5);
 6: 
 7: // float型のValueをロードするload命令を生成(BuilderはIRBuilderクラスのインスタンス)
 8: llvm::Value *arg_v = Builder->CreateLoad(alloca, "float_tmp");
 9: 
10: // Metadataを付与するfsub命令を生成(BuilderはIRBuilderクラスのインスタンス)
11: llvm::Value *tmp = Builder->CreateFSub(
12:     arg_v, llvm::ConstantFP::get(
13:                llvm::Type::getFloatTy(llvm::getGlobalContext()), 1.0),
14:     "fpmath_sample", mdn);

リスト5.75: 生成されるfsub命令

 1: %float = alloca float
 2: %float_tmp = load float* %float
 3: %fpmath_sample = fsub float %float_tmp, 1.000000e+00, !fpmath !0
 4: ・・・省略・・・
 5: !0 = metadata !{float 5.000000e-01}

リスト5.76: llvm::cl::optの使用例

 1: #include "llvm/Support/CommandLine.h"
 2: #include <cstdio>
 3: 
 4: namespace {
 5:   llvm::cl::opt<std::string> OutputFile(
 6:     "o",
 7:     llvm::cl::desc("出力ファイルを指定します"),
 8:     llvm::cl::value_desc("filename"),
 9:     llvm::cl::init("-")
10:   );
11: }
12: 
13: /**
14:  * main関数
15:  */
16: int main(int argc, char **argv) {
17:   // 引数のパース
18:   llvm::cl::ParseCommandLineOptions(argc, argv, "CommandLine Sample\n");
19: 
20:   // OutputFileの取得
21:   fprintf(stderr, "output file : %s\n", OutputFile.c_str());
22: 
23:   return 0;
24: }

void ParseCommandLineOptions(int argc, const char * const *argv, const char *Overview = 0);

# cltest.cppという名前のソースコードだったとした場合のコンパイル
$ g++ -g cltest.cpp `llvm-config --cxxflags --ldflags --libs` -ldl -pthread \
-o cltest
#
# -oオプションの確認
$ ./cltest -o test
output file : test
#
# helpを表示
$ ./cltest -help
OVERVIEW: CommandLine Sample

USAGE: cltest [options]

OPTIONS:
  -help         - Display available options (-help-hidden for more)
  -o=<filename> - 出力ファイルを指定します
  -version      - Display the version of this program

リスト5.77: llvm::cl::optの使用例(入力ファイルを受け取る場合)

 1: #include "llvm/Support/CommandLine.h"
 2: #include <cstdio>
 3: using namespace llvm;
 4: 
 5: namespace {
 6: llvm::cl::opt<std::string> InputFile(llvm::cl::Positional,
 7:                                      llvm::cl::desc("<input file>"),
 8:                                      llvm::cl::init("-"));
 9: }
10: 
11: /**
12:  * main関数
13:  */
14: int main(int argc, char **argv) {
15:   // 引数のパース
16:   llvm::cl::ParseCommandLineOptions(argc, argv, "CommandLine Sample\n");
17: 
18:   // InputFileの取得
19:   fprintf(stderr, "input file : %s\n", InputFile.c_str());
20: 
21:   return 0;
22: }

# cltest.cppという名前のソースコードだったとした場合のコンパイル
$ g++ -g cltest.cpp `llvm-config --cxxflags --ldflags --libs` -ldl -pthread \
-o cltest
#
# -oオプションの確認
$ ./cltest test
input file : test
#
# helpを表示
$ ./cltest -help
OVERVIEW: CommandLine Sample

USAGE: cltest [options] <input file>

OPTIONS:
  -help    - Display available options (-help-hidden for more)
  -version - Display the version of this program

リスト5.78: llvm::cl::optの使用例(真偽値を管理する場合)

 1: #include "llvm/Support/CommandLine.h"
 2: #include <cstdio>
 3: 
 4: namespace {
 5: // JIT有効無効を示すオプション
 6: llvm::cl::opt<bool> WithJit("jit",
 7:                             llvm::cl::desc("JIT コンパイルを有効にします"),
 8:                             llvm::cl::init("false"));
 9: }
10: 
11: /**
12:  * main関数
13:  */
14: int main(int argc, char **argv) {
15:   // 引数のパース
16:   llvm::cl::ParseCommandLineOptions(argc, argv, "CommandLine Sample\n");
17: 
18:   // JITフラグの取得
19:   if (WithJit)
20:     fprintf(stderr, "enabled jit \n");
21: 
22:   return 0;
23: }

# cltest.cppという名前のソースコードだったとした場合のコンパイル
$ g++ -g cltest.cpp `llvm-config --cxxflags --ldflags --libs` -ldl -pthread \
-o cltest
#
# -jitオプションの確認
$ ./cltest -jit
enabled jit
#
# helpの表示
$ ./cltest -help
OVERVIEW: CommandLine Sample

USAGE: cltest [options]

OPTIONS:
  -help    - Display available options (-help-hidden for more)
  -jit     - JITコンパイルを有効にします
  -version - Display the version of this program

リスト5.79: llvm::cl::optの使用例(複数パラメータから選択する場合)

 1: #include "llvm/Support/CommandLine.h"
 2: #include <cstdio>
 3: 
 4: namespace {
 5: 
 6: //最適化レベルを示すenum
 7: enum OptLevel {
 8:   NONE,
 9:   O1,
10:   O2,
11:   O3
12: };
13: 
14: //オプション定義
15: llvm::cl::opt<OptLevel>
16: OLevel(llvm::cl::values(clEnumValN(NONE, "O0", "最適化しません"),
17:                         clEnumVal(O1, "基本的な最適化"),
18:                         clEnumVal(O2, "積極的な最適化"),
19:                         clEnumVal(O3, "さらに積極的な最適化"), clEnumValEnd),
20:        llvm::cl::desc("最適化レベルの選択"));
21: }
22: 
23: /**
24:  * main関数
25:  */
26: int main(int argc, char **argv) {
27:   // 引数のパース
28:   llvm::cl::ParseCommandLineOptions(argc, argv, "CommandLine Sample\n");
29: 
30:   // 最適化レベルの取得
31:   if (OLevel == O0)
32:     fprintf(stderr, "disable Optimization\n");
33: 
34:   return 0;
35: }

# cltest.cppという名前のソースコードだったとした場合のコンパイル
$ g++ -g cltest.cpp `llvm-config --cxxflags --ldflags --libs` -ldl -pthread \
-o cltest
#
# 最適化オプションの確認
$ ./cltest -O0
disable Optimization
#
# helpの表示
$ ./cltest -help
OVERVIEW: CommandLine Sample

USAGE: cltest [options]

OPTIONS:
  最適化レベルの選択
    -O0    - 最適化しません
    -O1    - 基本的な最適化
    -O2    - 積極的な最適化
    -O3    - さらに積極的な最適化
  -help    - Display available options (-help-hidden for more)
  -version - Display the version of this program

リスト5.80: llvm::cl::optの使用例(複数パラメータから選択する場合)

 1: #include "llvm/Support/CommandLine.h"
 2: #include <cstdio>
 3: 
 4: namespace {
 5: //入力ファイルのオプション定義(複数バージョン)
 6: llvm::cl::list<std::string> InputFiles(llvm::cl::Positional,
 7:                                        llvm::cl::desc("<input files>"),
 8:                                        llvm::cl::OneOrMore);
 9: }
10: 
11: /**
12:  * main関数
13:  */
14: int main(int argc, char **argv) {
15:   // 引数のパース
16:   llvm::cl::ParseCommandLineOptions(argc, argv, "CommandLine Sample\n");
17: 
18:   // 入力ファイル名の取得
19:   for (int i = 0; i < InputFiles.size(); i++)
20:     fprintf(stderr, "input file : %s\n", InputFiles[i].c_str());
21: 
22:   return 0;
23: }

# cltest.cppという名前のソースコードだったとした場合のコンパイル
$ g++ -g cltest.cpp `llvm-config --cxxflags --ldflags --libs` -ldl -pthread \
-o cltest
#
# 入力ファイルオプションの確認
$ ./cltest foo bar
input file : foo
input file : bar
#
# helpの表示
$ ./cltest -help
OVERVIEW: CommandLine Sample

USAGE: cltest [options] <input files>

OPTIONS:
  -help    - Display available options (-help-hidden for more)
  -version - Display the version of this program