Rosetta Code

Arithmetic evaluation: Difference between revisions

Page Discussion

Arithmetic evaluation (view source)

Revision as of 18:15, 2 September 2008

141 bytes removed ,  15 years ago
→‎{{header|C++}}
m (Moved to Arith cat)
Line 330:
{{libheader|Boost.Spirit}}1.8.4
 
<cpp> #include <boost/spirit/core.hpp>
#include <boost/spirit/tree/astattribute.hpp>
#include <stringiostream>
#include <cassertstring>
 
#include <iostream>
////////////////////////////////////////////////////////////////////////////
#include <istream>
using namespace std;
#include <ostream>
using namespace boost::spirit;
using boost::spirit::rulenamespace phoenix;
 
using boost::spirit::parser_tag;
usingstruct calc_closure : boost::spirit::ch_p;closure<calc_closure, double>
{
using boost::spirit::real_p;
member1 val;
};
using boost::spirit::tree_node;
 
using boost::spirit::node_val_data;
struct calculator : public grammar<calculator, calc_closure::context_t>
{
// The grammar
template <typename ScannerT>
struct parser: public boost::spirit::grammar<parser>
struct definition
{
{
enum rule_ids { addsub_id, multdiv_id, value_id, real_id };
definition(calculator const& self)
struct set_value {
top = expression[self.val = arg1];
{
 
set_value(parser const& p): self(p) {}
expression
void operator()(tree_node<node_val_data<std::string::iterator,
= term[expression.val = double> >& node,arg1]
>> std::string::iterator*( begin, ('+' >> term[expression.val += arg1])
std::string::iterator end) const | ('-' >> term[expression.val -= arg1])
)
{
node.value.value(self.tmp) ;
 
}
parser const& self; term
= factor[term.val = arg1]
};
>> *( ('*' >> factor[term.val *= arg1])
| ('/' >> factor[term.val /= arg1])
mutable double tmp;
)
;
template<typename Scanner> struct definition
 
{
factor
rule<Scanner, parser_tag<addsub_id> > addsub;
= ureal_p[factor.val = arg1]
rule<Scanner, parser_tag<multdiv_id> > multdiv;
| '(' >> expression[factor.val = arg1] >> ')'
rule<Scanner, parser_tag<value_id> > value;
| ('-' >> factor[factor.val = -arg1])
rule<Scanner, parser_tag<real_id> > real;
| ('+' >> factor[factor.val = arg1])
;
definition(parser const& self)
{ }
 
using namespace boost::spirit;
typedef rule<ScannerT, calc_closure::context_t> rule_t;
addsub = multdiv
rule_t expression, term, factor;
>> *((root_node_d[ch_p('+')] | root_node_d[ch_p('-')]) >> multdiv);
multdiv =rule<ScannerT> valuetop;
 
>> *((root_node_d[ch_p('*')] | root_node_d[ch_p('/')]) >> value);
rule<ScannerT> const&
value = real | inner_node_d[('(' >> addsub >> ')')];
start() const { return top; }
real = leaf_node_d[access_node_d[real_p[assign_a(self.tmp)]][set_value(self)]];
};
};
 
rule<Scanner, parser_tag<addsub_id> > const& start() const
////////////////////////////////////////////////////////////////////////////
{
// Main program
return addsub;
////////////////////////////////////////////////////////////////////////////
}
int
};
main()
};
{
cout << "/////////////////////////////////////////////////////////\n\n";
template<typename TreeIter>
cout << "\t\tExpression parser using Phoenix...\n\n";
double evaluate(TreeIter const& i)
cout << "/////////////////////////////////////////////////////////\n\n";
{
cout << "Type an expression...or [q or Q] to quit\n\n";
double op1, op2;
 
switch (i->value.id().to_long())
calculator calc; // Our parser
{
 
case parser::real_id:
string str;
return i->value.value();
while (getline(cin, str))
case parser::value_id:
{
case parser::addsub_id:
if (str.empty() || str[0] == 'q' || str[0] == 'Q')
case parser::multdiv_id:
break;
op1 = evaluate(i->children.begin());
 
op2 = evaluate(i->children.begin()+1);
double n = 0;
switch(*i->value.begin())
parse_info<> info = parse(str.c_str(), calc[var(n) = arg1], space_p);
{
 
case '+':
// calc[var(n) = arg1] invokes the calculator and extracts
return op1 + op2;
// the result of the computation. See calculator grammar
case '-':
return op1// - op2;note above.
 
case '*':
return op1if * op2;(info.full)
case '/': {
cout << "-------------------------\n";
return op1 / op2;
cout << "Parsing succeeded\n";
default:
assert(! cout << "Shouldresult not= happen") << n << endl;
cout << "-------------------------\n";
}
default: }
assert(!"Should not happen"); else
} {
cout << "-------------------------\n";
return 0;
cout << "Parsing failed\n";
}
cout << "stopped at: \": " << info.stop << "\"\n";
cout << "-------------------------\n";
// the read/eval/write loop
}
int main()
}
{
parser evalreturn 0;
}
std::string line;
while (std::cout << "Expression: "
&& std::getline(std::cin, line)
&& !line.empty())
{
typedef boost::spirit::node_val_data_factory<double> factory_t;
boost::spirit::tree_parse_info<std::string::iterator, factory_t> info =
boost::spirit::ast_parse<factory_t>(line.begin(), line.end(),
eval, boost::spirit::space_p);
if (info.full)
{
std::cout << "Result: " << evaluate(info.trees.begin()) << std::endl;
}
else
{
std::cout << "Error in expression." << std::endl;
}
}
};
</cpp>
 
Anonymous user
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/50502"