Subject: [Boost-commit] svn:boost r69444 - in trunk/libs/spirit/example/qi/compiler_tutorial: . calc7 calc8
From: joel_at_[hidden]
Date: 2011-03-01 12:26:58
Author: djowel
Date: 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
New Revision: 69444
URL: http://svn.boost.org/trac/boost/changeset/69444
Log:
calc8
Added:
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/annotation.hpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/ast.hpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.cpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.hpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/error_handler.hpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/expression.cpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/expression.hpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/expression_def.hpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/main.cpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/statement.cpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/statement.hpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/statement_def.hpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/vm.cpp (contents, props changed)
trunk/libs/spirit/example/qi/compiler_tutorial/calc8/vm.hpp (contents, props changed)
Text files modified:
trunk/libs/spirit/example/qi/compiler_tutorial/Jamfile | 7 +++++++
trunk/libs/spirit/example/qi/compiler_tutorial/calc7/ast.hpp | 10 +++++-----
trunk/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.cpp | 10 ++--------
trunk/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.hpp | 2 +-
trunk/libs/spirit/example/qi/compiler_tutorial/calc7/main.cpp | 2 +-
trunk/libs/spirit/example/qi/compiler_tutorial/calc7/statement.hpp | 4 ++--
trunk/libs/spirit/example/qi/compiler_tutorial/calc7/statement_def.hpp | 10 +++++-----
7 files changed, 23 insertions(+), 22 deletions(-)
Modified: trunk/libs/spirit/example/qi/compiler_tutorial/Jamfile
==============================================================================
--- trunk/libs/spirit/example/qi/compiler_tutorial/Jamfile (original)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/Jamfile 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -27,3 +27,10 @@
calc7/main.cpp
;
+exe calc8 :
+ calc8/vm.cpp
+ calc8/compiler.cpp
+ calc8/expression.cpp
+ calc8/statement.cpp
+ calc8/main.cpp
+ ;
Modified: trunk/libs/spirit/example/qi/compiler_tutorial/calc7/ast.hpp
==============================================================================
--- trunk/libs/spirit/example/qi/compiler_tutorial/calc7/ast.hpp (original)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc7/ast.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -73,13 +73,13 @@
assignment assign;
};
- typedef std::list<
- boost::variant<
- variable_declaration,
- assignment>
- >
+ typedef boost::variant<
+ variable_declaration
+ , assignment>
statement;
+ typedef std::list<statement> statement_list;
+
// print functions for debugging
inline std::ostream& operator<<(std::ostream& out, nil) { out << "nil"; return out; }
inline std::ostream& operator<<(std::ostream& out, variable const& var) { out << var.name; return out; }
Modified: trunk/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.cpp
==============================================================================
--- trunk/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.cpp (original)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.cpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -200,19 +200,13 @@
return r;
}
- bool compiler::operator()(ast::statement const& x) const
+ bool compiler::operator()(ast::statement_list const& x) const
{
- typedef
- boost::variant<
- ast::variable_declaration,
- ast::assignment>
- statement;
-
program.clear();
// op_adstk 0 for now. we'll know how many variables we'll have later
program.op(op_adstk, 0);
- BOOST_FOREACH(statement const& s, x)
+ BOOST_FOREACH(ast::statement const& s, x)
{
if (!boost::apply_visitor(*this, s))
{
Modified: trunk/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.hpp
==============================================================================
--- trunk/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.hpp (original)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -72,7 +72,7 @@
bool operator()(ast::expression const& x) const;
bool operator()(ast::assignment const& x) const;
bool operator()(ast::variable_declaration const& x) const;
- bool operator()(ast::statement const& x) const;
+ bool operator()(ast::statement_list const& x) const;
client::program& program;
Modified: trunk/libs/spirit/example/qi/compiler_tutorial/calc7/main.cpp
==============================================================================
--- trunk/libs/spirit/example/qi/compiler_tutorial/calc7/main.cpp (original)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc7/main.cpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -54,7 +54,7 @@
client::vmachine vm; // Our virtual machine
client::program program; // Our VM program
- client::ast::statement ast; // Our AST
+ client::ast::statement_list ast; // Our AST
client::error_handler<iterator_type>
error_handler(iter, end); // Our error handler
Modified: trunk/libs/spirit/example/qi/compiler_tutorial/calc7/statement.hpp
==============================================================================
--- trunk/libs/spirit/example/qi/compiler_tutorial/calc7/statement.hpp (original)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc7/statement.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -15,12 +15,12 @@
// The statement grammar
///////////////////////////////////////////////////////////////////////////////
template <typename Iterator>
- struct statement : qi::grammar<Iterator, ast::statement(), ascii::space_type>
+ struct statement : qi::grammar<Iterator, ast::statement_list(), ascii::space_type>
{
statement(error_handler<Iterator>& error_handler);
expression<Iterator> expr;
- qi::rule<Iterator, ast::statement(), ascii::space_type> start;
+ qi::rule<Iterator, ast::statement_list(), ascii::space_type> statement_list;
qi::rule<Iterator, ast::variable_declaration(), ascii::space_type> variable_declaration;
qi::rule<Iterator, ast::assignment(), ascii::space_type> assignment;
qi::rule<Iterator, std::string(), ascii::space_type> identifier;
Modified: trunk/libs/spirit/example/qi/compiler_tutorial/calc7/statement_def.hpp
==============================================================================
--- trunk/libs/spirit/example/qi/compiler_tutorial/calc7/statement_def.hpp (original)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc7/statement_def.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -12,7 +12,7 @@
{
template <typename Iterator>
statement<Iterator>::statement(error_handler<Iterator>& error_handler)
- : statement::base_type(start), expr(error_handler)
+ : statement::base_type(statement_list), expr(error_handler)
{
qi::_1_type _1;
qi::_2_type _2;
@@ -33,7 +33,7 @@
typedef function<client::error_handler<Iterator> > error_handler_function;
typedef function<client::annotation<Iterator> > annotation_function;
- start =
+ statement_list =
+(variable_declaration | assignment)
;
@@ -55,14 +55,14 @@
// Debugging and error handling and reporting support.
BOOST_SPIRIT_DEBUG_NODES(
- (start)
+ (statement_list)
(identifier)
(variable_declaration)
(assignment)
);
- // Error handling: on error in start, call error_handler.
- on_error<fail>(start,
+ // Error handling: on error in statement_list, call error_handler.
+ on_error<fail>(statement_list,
error_handler_function(error_handler)(
"Error! Expecting ", _4, _3));
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/annotation.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/annotation.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,68 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_ANNOTATION_HPP)
+#define BOOST_SPIRIT_CALC8_ANNOTATION_HPP
+
+#include <map>
+#include <boost/variant/apply_visitor.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+ ///////////////////////////////////////////////////////////////////////////////
+ // The annotation handler links the AST to a map of iterator positions
+ // for the purpose of subsequent semantic error handling when the
+ // program is being compiled.
+ ///////////////////////////////////////////////////////////////////////////////
+ template <typename Iterator>
+ struct annotation
+ {
+ template <typename, typename>
+ struct result { typedef void type; };
+
+ std::vector<Iterator>& iters;
+ annotation(std::vector<Iterator>& iters)
+ : iters(iters) {}
+
+ struct set_id
+ {
+ typedef void result_type;
+
+ int id;
+ set_id(int id) : id(id) {}
+
+ // This will catch all nodes inheriting from ast::tagged
+ void operator()(ast::tagged& x) const
+ {
+ x.id = id;
+ }
+
+ // This will catch all nodes except those inheriting from ast::tagged
+ void operator()(...) const
+ {
+ // (no-op) no need for tags
+ }
+ };
+
+ void operator()(ast::operand& ast, Iterator pos) const
+ {
+ int id = iters.size();
+ iters.push_back(pos);
+ boost::apply_visitor(set_id(id), ast);
+ }
+
+ void operator()(ast::assignment& ast, Iterator pos) const
+ {
+ int id = iters.size();
+ iters.push_back(pos);
+ ast.lhs.id = id;
+ }
+ };
+}
+
+#endif
+
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/ast.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/ast.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,172 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_AST_HPP)
+#define BOOST_SPIRIT_CALC8_AST_HPP
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <boost/optional.hpp>
+#include <list>
+
+namespace client { namespace ast
+{
+ ///////////////////////////////////////////////////////////////////////////
+ // The AST
+ ///////////////////////////////////////////////////////////////////////////
+ struct tagged
+ {
+ int id; // Used to annotate the AST with the iterator position.
+ // This id is used as a key to a map<int, Iterator>
+ // (not really part of the AST.)
+ };
+
+ struct nil {};
+ struct unary;
+ struct expression;
+
+ struct variable : tagged
+ {
+ variable(std::string const& name = "") : name(name) {}
+ std::string name;
+ };
+
+ typedef boost::variant<
+ nil
+ , bool
+ , unsigned int
+ , variable
+ , boost::recursive_wrapper<unary>
+ , boost::recursive_wrapper<expression>
+ >
+ operand;
+
+ enum optoken
+ {
+ op_plus,
+ op_minus,
+ op_times,
+ op_divide,
+ op_positive,
+ op_negative,
+ op_not,
+ op_equal,
+ op_not_equal,
+ op_less,
+ op_less_equal,
+ op_greater,
+ op_greater_equal,
+ op_and,
+ op_or
+ };
+
+ struct unary
+ {
+ optoken operator_;
+ operand operand_;
+ };
+
+ struct operation
+ {
+ optoken operator_;
+ operand operand_;
+ };
+
+ struct expression
+ {
+ operand first;
+ std::list<operation> rest;
+ };
+
+ struct assignment
+ {
+ variable lhs;
+ expression rhs;
+ };
+
+ struct variable_declaration
+ {
+ assignment assign;
+ };
+
+ struct if_statement;
+ struct while_statement;
+ struct statement_list;
+
+ typedef boost::variant<
+ variable_declaration
+ , assignment
+ , boost::recursive_wrapper<if_statement>
+ , boost::recursive_wrapper<while_statement>
+ , boost::recursive_wrapper<statement_list>
+ >
+ statement;
+
+ struct statement_list : std::list<statement> {};
+
+ struct if_statement
+ {
+ expression condition;
+ statement then;
+ boost::optional<statement> else_;
+ };
+
+ struct while_statement
+ {
+ expression condition;
+ statement body;
+ };
+
+ // print functions for debugging
+ inline std::ostream& operator<<(std::ostream& out, nil) { out << "nil"; return out; }
+ inline std::ostream& operator<<(std::ostream& out, variable const& var) { out << var.name; return out; }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::ast::unary,
+ (client::ast::optoken, operator_)
+ (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::ast::operation,
+ (client::ast::optoken, operator_)
+ (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::ast::expression,
+ (client::ast::operand, first)
+ (std::list<client::ast::operation>, rest)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::ast::variable_declaration,
+ (client::ast::assignment, assign)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::ast::assignment,
+ (client::ast::variable, lhs)
+ (client::ast::expression, rhs)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::ast::if_statement,
+ (client::ast::expression, condition)
+ (client::ast::statement, then)
+ (boost::optional<client::ast::statement>, else_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::ast::while_statement,
+ (client::ast::expression, condition)
+ (client::ast::statement, body)
+)
+
+#endif
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.cpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,352 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#include "compiler.hpp"
+#include "vm.hpp"
+#include <boost/foreach.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/assert.hpp>
+
+namespace client
+{
+ void program::op(int a)
+ {
+ code.push_back(a);
+ }
+
+ void program::op(int a, int b)
+ {
+ code.push_back(a);
+ code.push_back(b);
+ }
+
+ void program::op(int a, int b, int c)
+ {
+ code.push_back(a);
+ code.push_back(b);
+ code.push_back(c);
+ }
+
+ int const* program::find_var(std::string const& name) const
+ {
+ std::map<std::string, int>::const_iterator i = variables.find(name);
+ if (i == variables.end())
+ return 0;
+ return &i->second;
+ }
+
+ void program::add_var(std::string const& name)
+ {
+ variables[name] = variables.size();
+ }
+
+ void program::print_variables(std::vector<int> const& stack) const
+ {
+ typedef std::pair<std::string, int> pair;
+ BOOST_FOREACH(pair const& p, variables)
+ {
+ std::cout << " " << p.first << ": " << stack[p.second] << std::endl;
+ }
+ }
+
+ void program::print_assembler() const
+ {
+ std::vector<int>::const_iterator pc = code.begin();
+
+ std::vector<std::string> locals(variables.size());
+ typedef std::pair<std::string, int> pair;
+ BOOST_FOREACH(pair const& p, variables)
+ {
+ locals[p.second] = p.first;
+ std::cout << " local "
+ << p.first << ", @" << p.second << std::endl;
+ }
+
+ std::cout << "start:" << std::endl;
+ while (pc != code.end())
+ {
+ std::size_t pos = pc-code.begin();
+ if (jumps.find(pos) != jumps.end())
+ std::cout << pos << ':' << std::endl;
+
+ switch (*pc++)
+ {
+ case op_neg:
+ std::cout << " op_neg" << std::endl;
+ break;
+
+ case op_not:
+ std::cout << " op_not" << std::endl;
+ break;
+
+ case op_add:
+ std::cout << " op_add" << std::endl;
+ break;
+
+ case op_sub:
+ std::cout << " op_sub" << std::endl;
+ break;
+
+ case op_mul:
+ std::cout << " op_mul" << std::endl;
+ break;
+
+ case op_div:
+ std::cout << " op_div" << std::endl;
+ break;
+
+ case op_eq:
+ std::cout << " op_eq" << std::endl;
+ break;
+
+ case op_neq:
+ std::cout << " op_neq" << std::endl;
+ break;
+
+ case op_lt:
+ std::cout << " op_lt" << std::endl;
+ break;
+
+ case op_lte:
+ std::cout << " op_lte" << std::endl;
+ break;
+
+ case op_gt:
+ std::cout << " op_gt" << std::endl;
+ break;
+
+ case op_gte:
+ std::cout << " op_gte" << std::endl;
+ break;
+
+ case op_and:
+ std::cout << " op_and" << std::endl;
+ break;
+
+ case op_or:
+ std::cout << " op_or" << std::endl;
+ break;
+
+ case op_load:
+ std::cout << " op_load " << locals[*pc++] << std::endl;
+ break;
+
+ case op_store:
+ std::cout << " op_store " << locals[*pc++] << std::endl;
+ break;
+
+ case op_int:
+ std::cout << " op_int " << *pc++ << std::endl;
+ break;
+
+ case op_true:
+ std::cout << " op_true" << std::endl;
+ break;
+
+ case op_false:
+ std::cout << " op_false" << std::endl;
+ break;
+
+ case op_jump:
+ std::cout << " op_jump " << *pc++ << std::endl;
+ break;
+
+ case op_jump_if:
+ std::cout << " op_jump_if " << *pc++ << std::endl;
+ break;
+
+ case op_adstk:
+ std::cout << " op_adstk " << *pc++ << std::endl;
+ break;
+ }
+ }
+
+ if (jumps.find(code.size()) != jumps.end())
+ std::cout << code.size() << ':' << std::endl;
+ }
+
+ bool compiler::operator()(unsigned int x) const
+ {
+ program.op(op_int, x);
+ return true;
+ }
+
+ bool compiler::operator()(bool x) const
+ {
+ program.op(x ? op_true : op_false);
+ return true;
+ }
+
+ bool compiler::operator()(ast::variable const& x) const
+ {
+ int const* p = program.find_var(x.name);
+ if (p == 0)
+ {
+ std::cout << x.id << std::endl;
+ error_handler(x.id, "Undeclared variable: " + x.name);
+ return false;
+ }
+ program.op(op_load, *p);
+ return true;
+ }
+
+ bool compiler::operator()(ast::operation const& x) const
+ {
+ if (!boost::apply_visitor(*this, x.operand_))
+ return false;
+ switch (x.operator_)
+ {
+ case ast::op_plus: program.op(op_add); break;
+ case ast::op_minus: program.op(op_sub); break;
+ case ast::op_times: program.op(op_mul); break;
+ case ast::op_divide: program.op(op_div); break;
+
+ case ast::op_equal: program.op(op_eq); break;
+ case ast::op_not_equal: program.op(op_neq); break;
+ case ast::op_less: program.op(op_lt); break;
+ case ast::op_less_equal: program.op(op_lte); break;
+ case ast::op_greater: program.op(op_gt); break;
+ case ast::op_greater_equal: program.op(op_gte); break;
+
+ case ast::op_and: program.op(op_and); break;
+ case ast::op_or: program.op(op_or); break;
+ default: BOOST_ASSERT(0); return false;
+ }
+ return true;
+ }
+
+ bool compiler::operator()(ast::unary const& x) const
+ {
+ if (!boost::apply_visitor(*this, x.operand_))
+ return false;
+ switch (x.operator_)
+ {
+ case ast::op_negative: program.op(op_neg); break;
+ case ast::op_not: program.op(op_not); break;
+ case ast::op_positive: break;
+ default: BOOST_ASSERT(0); return false;
+ }
+ return true;
+ }
+
+ bool compiler::operator()(ast::expression const& x) const
+ {
+ if (!boost::apply_visitor(*this, x.first))
+ return false;
+ BOOST_FOREACH(ast::operation const& oper, x.rest)
+ {
+ if (!(*this)(oper))
+ return false;
+ }
+ return true;
+ }
+
+ bool compiler::operator()(ast::assignment const& x) const
+ {
+ if (!(*this)(x.rhs))
+ return false;
+ int const* p = program.find_var(x.lhs.name);
+ if (p == 0)
+ {
+ std::cout << x.lhs.id << std::endl;
+ error_handler(x.lhs.id, "Undeclared variable: " + x.lhs.name);
+ return false;
+ }
+ program.op(op_store, *p);
+ return true;
+ }
+
+ bool compiler::operator()(ast::variable_declaration const& x) const
+ {
+ int const* p = program.find_var(x.assign.lhs.name);
+ if (p != 0)
+ {
+ std::cout << x.assign.lhs.id << std::endl;
+ error_handler(x.assign.lhs.id, "Duplicate variable: " + x.assign.lhs.name);
+ return false;
+ }
+ bool r = (*this)(x.assign.rhs);
+ if (r) // don't add the variable if the RHS fails
+ {
+ program.add_var(x.assign.lhs.name);
+ program.op(op_store, *program.find_var(x.assign.lhs.name));
+ }
+ return r;
+ }
+
+ bool compiler::operator()(ast::statement const& x) const
+ {
+ return boost::apply_visitor(*this, x);
+ }
+
+ bool compiler::operator()(ast::statement_list const& x) const
+ {
+ BOOST_FOREACH(ast::statement const& s, x)
+ {
+ if (!(*this)(s))
+ return false;
+ }
+ return true;
+ }
+
+ bool compiler::operator()(ast::if_statement const& x) const
+ {
+ if (!(*this)(x.condition))
+ return false;
+ program.op(op_jump_if, 0); // we shall fill this (0) in later
+ std::size_t skip = program.size()-1; // mark its position
+ if (!(*this)(x.then))
+ return false;
+ program[skip] = program.size(); // now we know where to jump to (after the if branch)
+
+ if (x.else_) // We got an alse
+ {
+ program[skip] += 2; // adjust for the "else" jump
+ program.op(op_jump, 0); // we shall fill this (0) in later
+ std::size_t exit = program.size()-1;// mark its position
+ if (!(*this)(*x.else_))
+ return false;
+ program[exit] = program.size(); // now we know where to jump to (after the else branch)
+ program.add_jump(program[exit]);
+ }
+
+ program.add_jump(program[skip]);
+ return true;
+ }
+
+ bool compiler::operator()(ast::while_statement const& x) const
+ {
+ std::size_t loop = program.size(); // mark our position
+ if (!(*this)(x.condition))
+ return false;
+ program.op(op_jump_if, 0); // we shall fill this (0) in later
+ std::size_t exit = program.size()-1; // mark its position
+ if (!(*this)(x.body))
+ return false;
+ program.op(op_jump, loop); // loop back
+ program[exit] = program.size(); // now we know where to jump to (to exit the loop)
+
+ program.add_jump(loop);
+ program.add_jump(program[exit]);
+ return true;
+ }
+
+ bool compiler::start(ast::statement_list const& x) const
+ {
+ program.clear();
+ // op_adstk 0 for now. we'll know how many variables we'll have later
+ program.op(op_adstk, 0);
+
+ if (!(*this)(x))
+ {
+ program.clear();
+ return false;
+ }
+ program[1] = program.nvars(); // now store the actual number of variables
+ return true;
+ }
+}
+
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,96 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_COMPILER_HPP)
+#define BOOST_SPIRIT_CALC8_COMPILER_HPP
+
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+#include <map>
+#include <set>
+#include <boost/function.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+namespace client
+{
+ ///////////////////////////////////////////////////////////////////////////
+ // The Program
+ ///////////////////////////////////////////////////////////////////////////
+ struct program
+ {
+ void op(int a);
+ void op(int a, int b);
+ void op(int a, int b, int c);
+
+ int& operator[](std::size_t i) { return code[i]; }
+ int const& operator[](std::size_t i) const { return code[i]; }
+ void clear() { code.clear(); variables.clear(); jumps.clear(); }
+ std::size_t size() const { return code.size(); }
+ std::vector<int> const& operator()() const { return code; }
+
+ int nvars() const { return variables.size(); }
+ int const* find_var(std::string const& name) const;
+ void add_var(std::string const& name);
+
+ void print_variables(std::vector<int> const& stack) const;
+ void print_assembler() const;
+
+ void add_jump(std::size_t jump) { jumps.insert(jump); }
+
+ private:
+
+ std::map<std::string, int> variables;
+ std::set<std::size_t> jumps;
+ std::vector<int> code;
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ // The Compiler
+ ///////////////////////////////////////////////////////////////////////////
+ struct compiler
+ {
+ typedef bool result_type;
+
+ template <typename ErrorHandler>
+ compiler(client::program& program, ErrorHandler& error_handler_)
+ : program(program)
+ {
+ using namespace boost::phoenix::arg_names;
+ using boost::phoenix::cref;
+ using boost::phoenix::function;
+
+ error_handler = function<ErrorHandler>(error_handler_)(
+ "Error! ", _2, cref(error_handler_.iters)[_1]);
+ }
+
+ bool operator()(ast::nil) const { BOOST_ASSERT(0); return false; }
+ bool operator()(unsigned int x) const;
+ bool operator()(bool x) const;
+ bool operator()(ast::variable const& x) const;
+ bool operator()(ast::operation const& x) const;
+ bool operator()(ast::unary const& x) const;
+ bool operator()(ast::expression const& x) const;
+ bool operator()(ast::assignment const& x) const;
+ bool operator()(ast::variable_declaration const& x) const;
+ bool operator()(ast::statement_list const& x) const;
+ bool operator()(ast::statement const& x) const;
+ bool operator()(ast::if_statement const& x) const;
+ bool operator()(ast::while_statement const& x) const;
+
+ bool start(ast::statement_list const& x) const;
+
+ client::program& program;
+
+ boost::function<
+ void(int tag, std::string const& what)>
+ error_handler;
+ };
+}
+
+#endif
\ No newline at end of file
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/error_handler.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/error_handler.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,93 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_CALC8_ERROR_HANDLER_HPP
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+ ///////////////////////////////////////////////////////////////////////////////
+ // The error handler
+ ///////////////////////////////////////////////////////////////////////////////
+ template <typename Iterator>
+ struct error_handler
+ {
+ template <typename, typename, typename>
+ struct result { typedef void type; };
+
+ error_handler(Iterator first, Iterator last)
+ : first(first), last(last) {}
+
+ template <typename Message, typename What>
+ void operator()(
+ Message const& message,
+ What const& what,
+ Iterator err_pos) const
+ {
+ int line;
+ Iterator line_start = get_pos(err_pos, line);
+ if (err_pos != last)
+ {
+ std::cout << message << what << " line " << line << ':' << std::endl;
+ std::cout << get_line(line_start) << std::endl;
+ for (; line_start != err_pos; ++line_start)
+ std::cout << ' ';
+ std::cout << '^' << std::endl;
+ }
+ else
+ {
+ std::cout << "Unexpected end of file. ";
+ std::cout << message << what << " line " << line << std::endl;
+ }
+ }
+
+ Iterator get_pos(Iterator err_pos, int& line) const
+ {
+ line = 1;
+ Iterator i = first;
+ Iterator line_start = first;
+ while (i != err_pos)
+ {
+ bool eol = false;
+ if (i != err_pos && *i == '\r') // CR
+ {
+ eol = true;
+ line_start = ++i;
+ }
+ if (i != err_pos && *i == '\n') // LF
+ {
+ eol = true;
+ line_start = ++i;
+ }
+ if (eol)
+ ++line;
+ else
+ ++i;
+ }
+ return line_start;
+ }
+
+ std::string get_line(Iterator err_pos) const
+ {
+ Iterator i = err_pos;
+ // position i to the next EOL
+ while (i != last && (*i != '\r' && *i != '\n'))
+ ++i;
+ return std::string(err_pos, i);
+ }
+
+ Iterator first;
+ Iterator last;
+ std::vector<Iterator> iters;
+ };
+}
+
+#endif
+
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/expression.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/expression.cpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,14 @@
+/*=============================================================================
+ Copyright (c) 2001-2010 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "expression_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::expression<iterator_type>;
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/expression.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/expression.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,68 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_EXPRESSION_HPP)
+#define BOOST_SPIRIT_CALC8_EXPRESSION_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+// #define BOOST_SPIRIT_QI_DEBUG
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/spirit/include/qi.hpp>
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+
+namespace client
+{
+ namespace qi = boost::spirit::qi;
+ namespace ascii = boost::spirit::ascii;
+
+ ///////////////////////////////////////////////////////////////////////////////
+ // The expression grammar
+ ///////////////////////////////////////////////////////////////////////////////
+ template <typename Iterator>
+ struct expression : qi::grammar<Iterator, ast::expression(), ascii::space_type>
+ {
+ expression(error_handler<Iterator>& error_handler);
+
+ qi::rule<Iterator, ast::expression(), ascii::space_type>
+ expr, equality_expr, relational_expr,
+ logical_expr, additive_expr, multiplicative_expr
+ ;
+
+ qi::rule<Iterator, ast::operand(), ascii::space_type>
+ unary_expr, primary_expr
+ ;
+
+ qi::rule<Iterator, std::string(), ascii::space_type>
+ identifier
+ ;
+
+ qi::symbols<char, ast::optoken>
+ equality_op, relational_op, logical_op,
+ additive_op, multiplicative_op, unary_op
+ ;
+
+ qi::symbols<char>
+ keywords
+ ;
+ };
+}
+
+#endif
+
+
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/expression_def.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/expression_def.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,158 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#include "expression.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+#include <boost/spirit/include/phoenix_function.hpp>
+
+namespace client
+{
+ template <typename Iterator>
+ expression<Iterator>::expression(error_handler<Iterator>& error_handler)
+ : expression::base_type(expr)
+ {
+ qi::_1_type _1;
+ qi::_2_type _2;
+ qi::_3_type _3;
+ qi::_4_type _4;
+
+ qi::char_type char_;
+ qi::uint_type uint_;
+ qi::_val_type _val;
+ qi::raw_type raw;
+ qi::lexeme_type lexeme;
+ qi::alpha_type alpha;
+ qi::alnum_type alnum;
+ qi::bool_type bool_;
+
+ using qi::on_error;
+ using qi::on_success;
+ using qi::fail;
+ using boost::phoenix::function;
+
+ typedef function<client::error_handler<Iterator> > error_handler_function;
+ typedef function<client::annotation<Iterator> > annotation_function;
+
+ ///////////////////////////////////////////////////////////////////////
+ // Tokens
+ equality_op.add
+ ("==", ast::op_equal)
+ ("!=", ast::op_not_equal)
+ ;
+
+ relational_op.add
+ ("<", ast::op_less)
+ ("<=", ast::op_less_equal)
+ (">", ast::op_greater)
+ (">=", ast::op_greater_equal)
+ ;
+
+ logical_op.add
+ ("&&", ast::op_and)
+ ("||", ast::op_or)
+ ;
+
+ additive_op.add
+ ("+", ast::op_plus)
+ ("-", ast::op_minus)
+ ;
+
+ multiplicative_op.add
+ ("*", ast::op_times)
+ ("/", ast::op_divide)
+ ;
+
+ unary_op.add
+ ("+", ast::op_positive)
+ ("-", ast::op_negative)
+ ("!", ast::op_not)
+ ;
+
+ keywords.add
+ ("true")
+ ("false")
+ ("if")
+ ("else")
+ ("while")
+ ;
+
+ ///////////////////////////////////////////////////////////////////////
+ // Main expression grammar
+ expr =
+ equality_expr.alias()
+ ;
+
+ equality_expr =
+ relational_expr
+ >> *(equality_op > relational_expr)
+ ;
+
+ relational_expr =
+ logical_expr
+ >> *(relational_op > logical_expr)
+ ;
+
+ logical_expr =
+ additive_expr
+ >> *(logical_op > additive_expr)
+ ;
+
+ additive_expr =
+ multiplicative_expr
+ >> *(additive_op > multiplicative_expr)
+ ;
+
+ multiplicative_expr =
+ unary_expr
+ >> *(multiplicative_op > unary_expr)
+ ;
+
+ unary_expr =
+ primary_expr
+ | (unary_op > primary_expr)
+ ;
+
+ primary_expr =
+ uint_
+ | identifier
+ | bool_
+ | '(' > expr > ')'
+ ;
+
+ identifier =
+ !keywords
+ >> raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+ ;
+
+ ///////////////////////////////////////////////////////////////////////
+ // Debugging and error handling and reporting support.
+ BOOST_SPIRIT_DEBUG_NODES(
+ (expr)
+ (equality_expr)
+ (relational_expr)
+ (logical_expr)
+ (additive_expr)
+ (multiplicative_expr)
+ (unary_expr)
+ (primary_expr)
+ (identifier)
+ );
+
+ ///////////////////////////////////////////////////////////////////////
+ // Error handling: on error in expr, call error_handler.
+ on_error<fail>(expr,
+ error_handler_function(error_handler)(
+ "Error! Expecting ", _4, _3));
+
+ ///////////////////////////////////////////////////////////////////////
+ // Annotation: on success in primary_expr, call annotation.
+ on_success(primary_expr,
+ annotation_function(error_handler.iters)(_val, _1));
+ }
+}
+
+
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/main.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/main.cpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,95 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+// Now we'll introduce boolean expressions and control structures.
+// Is it obvious now what we are up to? ;-)
+//
+// [ JDG April 9, 2007 ] spirit2
+// [ JDG February 18, 2011 ] Pure attributes. No semantic actions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "statement.hpp"
+#include "vm.hpp"
+#include "compiler.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+ std::cout << "/////////////////////////////////////////////////////////\n\n";
+ std::cout << "Statement parser...\n\n";
+ std::cout << "/////////////////////////////////////////////////////////\n\n";
+ std::cout << "Type some statements... ";
+ std::cout << "An empty line ends input, compiles, runs and prints results\n\n";
+ std::cout << "Example:\n\n";
+ std::cout << " var a = 123;\n";
+ std::cout << " var b = 456;\n";
+ std::cout << " var c = a + b * 2;\n\n";
+ std::cout << "-------------------------\n";
+
+ std::string str;
+ std::string source;
+ while (std::getline(std::cin, str))
+ {
+ if (str.empty())
+ break;
+ source += str + '\n';
+ }
+
+ typedef std::string::const_iterator iterator_type;
+ iterator_type iter = source.begin();
+ iterator_type end = source.end();
+
+ client::vmachine vm; // Our virtual machine
+ client::program program; // Our VM program
+ client::ast::statement_list ast; // Our AST
+
+ client::error_handler<iterator_type>
+ error_handler(iter, end); // Our error handler
+ client::statement<iterator_type> parser(error_handler); // Our parser
+ client::compiler compile(program, error_handler); // Our compiler
+
+ boost::spirit::ascii::space_type space;
+ bool success = phrase_parse(iter, end, parser, space, ast);
+
+ std::cout << "-------------------------\n";
+
+ if (success && iter == end)
+ {
+ if (compile.start(ast))
+ {
+ std::cout << "Success\n";
+ std::cout << "-------------------------\n";
+ vm.execute(program());
+
+ std::cout << "-------------------------\n";
+ std::cout << "Assembler----------------\n\n";
+ program.print_assembler();
+
+ std::cout << "-------------------------\n";
+ std::cout << "Results------------------\n\n";
+ program.print_variables(vm.get_stack());
+ }
+ else
+ {
+ std::cout << "Compile failure\n";
+ }
+ }
+ else
+ {
+ std::cout << "Parse failure\n";
+ }
+
+ std::cout << "-------------------------\n\n";
+ return 0;
+}
+
+
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/statement.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/statement.cpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,14 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "statement_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::statement<iterator_type>;
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/statement.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/statement.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,37 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_STATEMENT_HPP)
+#define BOOST_SPIRIT_CALC8_STATEMENT_HPP
+
+#include "expression.hpp"
+
+namespace client
+{
+ ///////////////////////////////////////////////////////////////////////////////
+ // The statement grammar
+ ///////////////////////////////////////////////////////////////////////////////
+ template <typename Iterator>
+ struct statement : qi::grammar<Iterator, ast::statement_list(), ascii::space_type>
+ {
+ statement(error_handler<Iterator>& error_handler);
+
+ expression<Iterator> expr;
+ qi::rule<Iterator, ast::statement_list(), ascii::space_type>
+ statement_list, compound_statement;
+
+ qi::rule<Iterator, ast::statement(), ascii::space_type> statement_;
+ qi::rule<Iterator, ast::variable_declaration(), ascii::space_type> variable_declaration;
+ qi::rule<Iterator, ast::assignment(), ascii::space_type> assignment;
+ qi::rule<Iterator, ast::if_statement(), ascii::space_type> if_statement;
+ qi::rule<Iterator, ast::while_statement(), ascii::space_type> while_statement;
+ qi::rule<Iterator, std::string(), ascii::space_type> identifier;
+ };
+}
+
+#endif
+
+
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/statement_def.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/statement_def.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,111 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#include "statement.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client
+{
+ template <typename Iterator>
+ statement<Iterator>::statement(error_handler<Iterator>& error_handler)
+ : statement::base_type(statement_list), expr(error_handler)
+ {
+ qi::_1_type _1;
+ qi::_2_type _2;
+ qi::_3_type _3;
+ qi::_4_type _4;
+
+ qi::_val_type _val;
+ qi::raw_type raw;
+ qi::lexeme_type lexeme;
+ qi::alpha_type alpha;
+ qi::alnum_type alnum;
+ qi::lit_type lit;
+
+ using qi::on_error;
+ using qi::on_success;
+ using qi::fail;
+ using boost::phoenix::function;
+
+ typedef function<client::error_handler<Iterator> > error_handler_function;
+ typedef function<client::annotation<Iterator> > annotation_function;
+
+ statement_list =
+ +statement_
+ ;
+
+ statement_ =
+ variable_declaration
+ | assignment
+ | compound_statement
+ | if_statement
+ | while_statement
+ ;
+
+ identifier =
+ !expr.keywords
+ >> raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+ ;
+
+ variable_declaration =
+ lexeme["var" >> !(alnum | '_')] // make sure we have whole words
+ > &identifier // expect an identifier
+ > assignment
+ ;
+
+ assignment =
+ identifier
+ > '='
+ > expr
+ > ';'
+ ;
+
+ if_statement =
+ lit("if")
+ > '('
+ > expr
+ > ')'
+ > statement_
+ >
+ -(
+ lexeme["else" >> !(alnum | '_')] // make sure we have whole words
+ > statement_
+ )
+ ;
+
+ while_statement =
+ lit("while")
+ > '('
+ > expr
+ > ')'
+ > statement_
+ ;
+
+ compound_statement =
+ '{' >> -statement_list >> '}'
+ ;
+
+ // Debugging and error handling and reporting support.
+ BOOST_SPIRIT_DEBUG_NODES(
+ (statement_list)
+ (identifier)
+ (variable_declaration)
+ (assignment)
+ );
+
+ // Error handling: on error in statement_list, call error_handler.
+ on_error<fail>(statement_list,
+ error_handler_function(error_handler)(
+ "Error! Expecting ", _4, _3));
+
+ // Annotation: on success in assignment, call annotation.
+ on_success(assignment,
+ annotation_function(error_handler.iters)(_val, _1));
+ }
+}
+
+
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/vm.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/vm.cpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,135 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#include "vm.hpp"
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4800) // forcing value to bool 'true' or 'false'
+ // (performance warning)
+#endif
+
+namespace client
+{
+ void vmachine::execute(std::vector<int> const& code)
+ {
+ std::vector<int>::const_iterator pc = code.begin();
+ std::vector<int>::iterator locals = stack.begin();
+ stack_ptr = stack.begin();
+
+ while (pc != code.end())
+ {
+ switch (*pc++)
+ {
+ case op_neg:
+ stack_ptr[-1] = -stack_ptr[-1];
+ break;
+
+ case op_not:
+ stack_ptr[-1] = !bool(stack_ptr[-1]);
+ break;
+
+ case op_add:
+ --stack_ptr;
+ stack_ptr[-1] += stack_ptr[0];
+ break;
+
+ case op_sub:
+ --stack_ptr;
+ stack_ptr[-1] -= stack_ptr[0];
+ break;
+
+ case op_mul:
+ --stack_ptr;
+ stack_ptr[-1] *= stack_ptr[0];
+ break;
+
+ case op_div:
+ --stack_ptr;
+ stack_ptr[-1] /= stack_ptr[0];
+ break;
+
+ case op_eq:
+ --stack_ptr;
+ stack_ptr[-1] = bool(stack_ptr[-1] == stack_ptr[0]);
+ break;
+
+ case op_neq:
+ --stack_ptr;
+ stack_ptr[-1] = bool(stack_ptr[-1] != stack_ptr[0]);
+ break;
+
+ case op_lt:
+ --stack_ptr;
+ stack_ptr[-1] = bool(stack_ptr[-1] < stack_ptr[0]);
+ break;
+
+ case op_lte:
+ --stack_ptr;
+ stack_ptr[-1] = bool(stack_ptr[-1] <= stack_ptr[0]);
+ break;
+
+ case op_gt:
+ --stack_ptr;
+ stack_ptr[-1] = bool(stack_ptr[-1] > stack_ptr[0]);
+ break;
+
+ case op_gte:
+ --stack_ptr;
+ stack_ptr[-1] = bool(stack_ptr[-1] >= stack_ptr[0]);
+ break;
+
+ case op_and:
+ --stack_ptr;
+ stack_ptr[-1] = bool(stack_ptr[-1]) && bool(stack_ptr[0]);
+ break;
+
+ case op_or:
+ --stack_ptr;
+ stack_ptr[-1] = bool(stack_ptr[-1]) || bool(stack_ptr[0]);
+ break;
+
+ case op_load:
+ *stack_ptr++ = locals[*pc++];
+ break;
+
+ case op_store:
+ --stack_ptr;
+ locals[*pc++] = stack_ptr[0];
+ break;
+
+ case op_int:
+ *stack_ptr++ = *pc++;
+ break;
+
+ case op_true:
+ *stack_ptr++ = true;
+ break;
+
+ case op_false:
+ *stack_ptr++ = false;
+ break;
+
+ case op_jump:
+ pc = code.begin() + *pc;
+ break;
+
+ case op_jump_if:
+ if (!bool(stack_ptr[-1]))
+ pc = code.begin() + *pc;
+ else
+ ++pc;
+ --stack_ptr;
+ break;
+
+ case op_adstk:
+ stack_ptr = stack.begin() + *pc++;
+ break;
+ }
+ }
+ }
+}
+
+
Added: trunk/libs/spirit/example/qi/compiler_tutorial/calc8/vm.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/qi/compiler_tutorial/calc8/vm.hpp 2011-03-01 12:26:06 EST (Tue, 01 Mar 2011)
@@ -0,0 +1,70 @@
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_VM_HPP)
+#define BOOST_SPIRIT_CALC8_VM_HPP
+
+#include <vector>
+
+namespace client
+{
+ ///////////////////////////////////////////////////////////////////////////
+ // The Virtual Machine
+ ///////////////////////////////////////////////////////////////////////////
+ enum byte_code
+ {
+ op_neg, // negate the top stack entry
+ op_add, // add top two stack entries
+ op_sub, // subtract top two stack entries
+ op_mul, // multiply top two stack entries
+ op_div, // divide top two stack entries
+
+ op_not, // boolean negate the top stack entry
+ op_eq, // compare the top two stack entries for ==
+ op_neq, // compare the top two stack entries for !=
+ op_lt, // compare the top two stack entries for <
+ op_lte, // compare the top two stack entries for <=
+ op_gt, // compare the top two stack entries for >
+ op_gte, // compare the top two stack entries for >=
+
+ op_and, // logical and top two stack entries
+ op_or, // logical or top two stack entries
+
+ op_load, // load a variable
+ op_store, // store a variable
+ op_adstk, // adjust the stack for local variables
+
+ op_int, // push constant integer into the stack
+ op_true, // push constant 0 into the stack
+ op_false, // push constant 1 into the stack
+
+ op_jump_if, // jump to an absolute position in the code if top stack
+ // evaluates to false
+ op_jump // jump to an absolute position in the code
+ };
+
+ class vmachine
+ {
+ public:
+
+ vmachine(unsigned stackSize = 4096)
+ : stack(stackSize)
+ , stack_ptr(stack.begin())
+ {
+ }
+
+ void execute(std::vector<int> const& code);
+ std::vector<int> const& get_stack() const { return stack; };
+
+ private:
+
+ std::vector<int> stack;
+ std::vector<int>::iterator stack_ptr;
+ };
+}
+
+#endif
+