1/*=============================================================================
2 Copyright (c) 2001-2011 Joel de Guzman
3
4 Distributed under the Boost Software License, Version 1.0. (See accompanying
5 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6=============================================================================*/
7#include "compiler.hpp"
8#include "vm.hpp"
9#include <boost/foreach.hpp>
10#include <boost/variant/apply_visitor.hpp>
11#include <boost/assert.hpp>
12#include <boost/lexical_cast.hpp>
13#include <set>
14
15namespace client { namespace code_gen
16{
17 void program::op(int a)
18 {
19 code.push_back(x: a);
20 }
21
22 void program::op(int a, int b)
23 {
24 code.push_back(x: a);
25 code.push_back(x: b);
26 }
27
28 void program::op(int a, int b, int c)
29 {
30 code.push_back(x: a);
31 code.push_back(x: b);
32 code.push_back(x: c);
33 }
34
35 int const* program::find_var(std::string const& name) const
36 {
37 std::map<std::string, int>::const_iterator i = variables.find(x: name);
38 if (i == variables.end())
39 return 0;
40 return &i->second;
41 }
42
43 void program::add_var(std::string const& name)
44 {
45 std::size_t n = variables.size();
46 variables[name] = n;
47 }
48
49 void program::print_variables(std::vector<int> const& stack) const
50 {
51 typedef std::pair<std::string, int> pair;
52 BOOST_FOREACH(pair const& p, variables)
53 {
54 std::cout << " " << p.first << ": " << stack[p.second] << std::endl;
55 }
56 }
57
58 void program::print_assembler() const
59 {
60 std::vector<int>::const_iterator pc = code.begin();
61
62 std::vector<std::string> locals(variables.size());
63 typedef std::pair<std::string, int> pair;
64 BOOST_FOREACH(pair const& p, variables)
65 {
66 locals[p.second] = p.first;
67 std::cout << " local "
68 << p.first << ", @" << p.second << std::endl;
69 }
70
71 std::map<std::size_t, std::string> lines;
72 std::set<std::size_t> jumps;
73
74 while (pc != code.end())
75 {
76 std::string line;
77 std::size_t address = pc - code.begin();
78
79 switch (*pc++)
80 {
81 case op_neg:
82 line += " op_neg";
83 break;
84
85 case op_not:
86 line += " op_not";
87 break;
88
89 case op_add:
90 line += " op_add";
91 break;
92
93 case op_sub:
94 line += " op_sub";
95 break;
96
97 case op_mul:
98 line += " op_mul";
99 break;
100
101 case op_div:
102 line += " op_div";
103 break;
104
105 case op_eq:
106 line += " op_eq";
107 break;
108
109 case op_neq:
110 line += " op_neq";
111 break;
112
113 case op_lt:
114 line += " op_lt";
115 break;
116
117 case op_lte:
118 line += " op_lte";
119 break;
120
121 case op_gt:
122 line += " op_gt";
123 break;
124
125 case op_gte:
126 line += " op_gte";
127 break;
128
129 case op_and:
130 line += " op_and";
131 break;
132
133 case op_or:
134 line += " op_or";
135 break;
136
137 case op_load:
138 line += " op_load ";
139 line += locals[*pc++];
140 break;
141
142 case op_store:
143 line += " op_store ";
144 line += locals[*pc++];
145 break;
146
147 case op_int:
148 line += " op_int ";
149 line += boost::lexical_cast<std::string>(arg: *pc++);
150 break;
151
152 case op_true:
153 line += " op_true";
154 break;
155
156 case op_false:
157 line += " op_false";
158 break;
159
160 case op_jump:
161 {
162 line += " op_jump ";
163 std::size_t pos = (pc - code.begin()) + *pc++;
164 if (pos == code.size())
165 line += "end";
166 else
167 line += boost::lexical_cast<std::string>(arg: pos);
168 jumps.insert(x: pos);
169 }
170 break;
171
172 case op_jump_if:
173 {
174 line += " op_jump_if ";
175 std::size_t pos = (pc - code.begin()) + *pc++;
176 if (pos == code.size())
177 line += "end";
178 else
179 line += boost::lexical_cast<std::string>(arg: pos);
180 jumps.insert(x: pos);
181 }
182 break;
183
184 case op_stk_adj:
185 line += " op_stk_adj ";
186 line += boost::lexical_cast<std::string>(arg: *pc++);
187 break;
188 }
189 lines[address] = line;
190 }
191
192 std::cout << "start:" << std::endl;
193 typedef std::pair<std::size_t, std::string> line_info;
194 BOOST_FOREACH(line_info const& l, lines)
195 {
196 std::size_t pos = l.first;
197 if (jumps.find(x: pos) != jumps.end())
198 std::cout << pos << ':' << std::endl;
199 std::cout << l.second << std::endl;
200 }
201
202 std::cout << "end:" << std::endl;
203 }
204
205 bool compiler::operator()(unsigned int x) const
206 {
207 program.op(a: op_int, b: x);
208 return true;
209 }
210
211 bool compiler::operator()(bool x) const
212 {
213 program.op(a: x ? op_true : op_false);
214 return true;
215 }
216
217 bool compiler::operator()(ast::variable const& x) const
218 {
219 int const* p = program.find_var(name: x.name);
220 if (p == 0)
221 {
222 std::cout << x.id << std::endl;
223 error_handler(x.id, "Undeclared variable: " + x.name);
224 return false;
225 }
226 program.op(a: op_load, b: *p);
227 return true;
228 }
229
230 bool compiler::operator()(ast::operation const& x) const
231 {
232 if (!boost::apply_visitor(visitor: *this, visitable: x.operand_))
233 return false;
234 switch (x.operator_)
235 {
236 case ast::op_plus: program.op(a: op_add); break;
237 case ast::op_minus: program.op(a: op_sub); break;
238 case ast::op_times: program.op(a: op_mul); break;
239 case ast::op_divide: program.op(a: op_div); break;
240
241 case ast::op_equal: program.op(a: op_eq); break;
242 case ast::op_not_equal: program.op(a: op_neq); break;
243 case ast::op_less: program.op(a: op_lt); break;
244 case ast::op_less_equal: program.op(a: op_lte); break;
245 case ast::op_greater: program.op(a: op_gt); break;
246 case ast::op_greater_equal: program.op(a: op_gte); break;
247
248 case ast::op_and: program.op(a: op_and); break;
249 case ast::op_or: program.op(a: op_or); break;
250 default: BOOST_ASSERT(0); return false;
251 }
252 return true;
253 }
254
255 bool compiler::operator()(ast::unary const& x) const
256 {
257 if (!boost::apply_visitor(visitor: *this, visitable: x.operand_))
258 return false;
259 switch (x.operator_)
260 {
261 case ast::op_negative: program.op(a: op_neg); break;
262 case ast::op_not: program.op(a: op_not); break;
263 case ast::op_positive: break;
264 default: BOOST_ASSERT(0); return false;
265 }
266 return true;
267 }
268
269 bool compiler::operator()(ast::expression const& x) const
270 {
271 if (!boost::apply_visitor(visitor: *this, visitable: x.first))
272 return false;
273 BOOST_FOREACH(ast::operation const& oper, x.rest)
274 {
275 if (!(*this)(oper))
276 return false;
277 }
278 return true;
279 }
280
281 bool compiler::operator()(ast::assignment const& x) const
282 {
283 if (!(*this)(x.rhs))
284 return false;
285 int const* p = program.find_var(name: x.lhs.name);
286 if (p == 0)
287 {
288 std::cout << x.lhs.id << std::endl;
289 error_handler(x.lhs.id, "Undeclared variable: " + x.lhs.name);
290 return false;
291 }
292 program.op(a: op_store, b: *p);
293 return true;
294 }
295
296 bool compiler::operator()(ast::variable_declaration const& x) const
297 {
298 int const* p = program.find_var(name: x.assign.lhs.name);
299 if (p != 0)
300 {
301 std::cout << x.assign.lhs.id << std::endl;
302 error_handler(x.assign.lhs.id, "Duplicate variable: " + x.assign.lhs.name);
303 return false;
304 }
305 bool r = (*this)(x.assign.rhs);
306 if (r) // don't add the variable if the RHS fails
307 {
308 program.add_var(name: x.assign.lhs.name);
309 program.op(a: op_store, b: *program.find_var(name: x.assign.lhs.name));
310 }
311 return r;
312 }
313
314 bool compiler::operator()(ast::statement const& x) const
315 {
316 return boost::apply_visitor(visitor: *this, visitable: x);
317 }
318
319 bool compiler::operator()(ast::statement_list const& x) const
320 {
321 BOOST_FOREACH(ast::statement const& s, x)
322 {
323 if (!(*this)(s))
324 return false;
325 }
326 return true;
327 }
328
329 bool compiler::operator()(ast::if_statement const& x) const
330 {
331 if (!(*this)(x.condition))
332 return false;
333 program.op(a: op_jump_if, b: 0); // we shall fill this (0) in later
334 std::size_t skip = program.size()-1; // mark its position
335 if (!(*this)(x.then))
336 return false;
337 program[skip] = program.size()-skip; // now we know where to jump to (after the if branch)
338
339 if (x.else_) // We got an alse
340 {
341 program[skip] += 2; // adjust for the "else" jump
342 program.op(a: op_jump, b: 0); // we shall fill this (0) in later
343 std::size_t exit = program.size()-1; // mark its position
344 if (!(*this)(*x.else_))
345 return false;
346 program[exit] = program.size()-exit; // now we know where to jump to (after the else branch)
347 }
348
349 return true;
350 }
351
352 bool compiler::operator()(ast::while_statement const& x) const
353 {
354 std::size_t loop = program.size(); // mark our position
355 if (!(*this)(x.condition))
356 return false;
357 program.op(a: op_jump_if, b: 0); // we shall fill this (0) in later
358 std::size_t exit = program.size()-1; // mark its position
359 if (!(*this)(x.body))
360 return false;
361 program.op(a: op_jump,
362 b: int(loop-1) - int(program.size())); // loop back
363 program[exit] = program.size()-exit; // now we know where to jump to (to exit the loop)
364 return true;
365 }
366
367 bool compiler::start(ast::statement_list const& x) const
368 {
369 program.clear();
370 // op_stk_adj 0 for now. we'll know how many variables we'll have later
371 program.op(a: op_stk_adj, b: 0);
372
373 if (!(*this)(x))
374 {
375 program.clear();
376 return false;
377 }
378 program[1] = program.nvars(); // now store the actual number of variables
379 return true;
380 }
381}}
382
383

source code of boost/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.cpp