I should change the snippets to include a reference to the license type used. Till then, I grant an MIT license to the above snippet (is this enough?) For completeness (or at least self-containment…), I include the full snippet herein, with the license reference added.

Thanks,

David

———————————————

/*

File: parse_arith.cpp
Author: David Bergman

This file describes a simple arithmetic language
using Boost.Spirit.

It does so by creating an AST and then implementing
an evaluating visitor for such nodes. Not really a
visitor, since it handles the traversal itself, but
you get the point…

License Information (MIT License):

Copyright (c) 2006-2008 David Bergman

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

*/

#include
#include
#include

using namespace std;
using namespace boost::spirit;
using namespace boost;

typedef tree_match TreeMatch;
typedef TreeMatch::tree_iterator TreeIter;

// We use Abstract Syntax Trees

struct expression : public grammar
{
// Need explicit identifiers to switch properly
// when evaluating the AST
static const int factorID = 1;
static const int termID = 2;
static const int expID = 3;

// Meta function from scanner type to a proper
// rule type
template
struct definition
{
rule,
parser_tag > exp_p;
rule,
parser_tag > factor_p;
rule,
parser_tag > term_p;
definition(const expression& self) {
factor_p =
leaf_node_d[int_p] |
inner_node_d['(' >> exp_p >> ')'];
term_p =
factor_p >> *(root_node_d[ch_p('*')] >>
factor_p
|
root_node_d[ch_p('/')] >>
factor_p);
exp_p = term_p >>
*(root_node_d[ch_p('+')] >> term_p |
root_node_d[ch_p('-')] >> term_p);
BOOST_SPIRIT_DEBUG_RULE(factor_p);
BOOST_SPIRIT_DEBUG_RULE(term_p);
BOOST_SPIRIT_DEBUG_RULE(exp_p);
}

const rule,
parser_tag >&
start()
const {
return exp_p;
}
};
};

// Map operators to operations

static map > op;

// The evaluation function for the ASTs

static int eval_expression(const TreeIter& i);

int evaluate(tree_parse_info<> match)
{
return eval_expression(match.trees.begin());
}

int eval_expression(const TreeIter& i)
{
return
(i->value.id() == expression::factorID) ?
// Simple numeric literal
lexical_cast(string(i->value.begin(),
i->value.end())) :
// A dyadic operation
op[*i->value.begin()]
(eval_expression(i->children.begin()),
eval_expression(i->children.begin() + 1));
}

int main(int argc, char* argv[])
{
// Init the operations

op['*'] = multiplies();
op['/'] = divides();
op['+'] = plus();
op['-'] = minus();

const string input(argv[1]);
expression my_exp;
tree_parse_info tree =
ast_parse(input.c_str(), my_exp);
if (tree.full) {
cout << “result is ” << evaluate(tree)
<< endl;
}
}

I adjusted the grammar to support exponentiation and negation which are both right-to-left. I also added expect clauses to get better information on why a parse fails. Here is the new grammar:

factor_p = // numbers or parentheticals:
leaf_node_d[ureal_p]
| (inner_node_d['(' >> expectexpression(start_p) >> expectclose(ch_p(')'))]);
power_p = // exponentials (right-to-left)
(factor_p >> root_node_d[ch_p('^')]) >> expectexpression(unary_p) | factor_p;
unary_p = // unary operators (right-to-left)
(root_node_d[ch_p('-')]) >> expectexpression(unary_p) | power_p;
term_p = // multiplicatives (left-to-right)
unary_p >> ( *(root_node_d[ch_p('x')|'/'] >> expectexpression(unary_p)) ) ;
exp_p = // additives (left-to-right)
term_p >> *(root_node_d[ch_p('+')|'-'] >> expectexpression(term_p));
start_p = expectexpression(exp_p);

Would you be willing to release this code into a boost, GPL, or MIT style license? I’d like to use it in a class and put it on a course website.

ps. I posted a similar comment, but it didn’t post so resubmitting.

Thanks,

Joel