Re: bool equation

* thomas:


This is a mix of boolean operators (&& and ||) and bitwise operators (~). You
probably meant "!", the boolean "not".


It seems like you're asking for evaluating a boolean expression given in text
form at run-time, e.g. entered by the user.

No, the standard library does not contain any parser functionality.

However, you might find the Spirit library (part of Boost library) helpful, e.g.
the following implements your syntax except that it uses "!" instead of "~":

<code comment="unbreak those broken lines">
// Adapted from
//
[http://spirit.sourceforge.net/distrib/spirit_1_8_5/libs/spirit/example/fundamental/calc_plain.cpp]
// by Alf P. Steinbach, as an "off the cuff" (almost) example for clc++
newsgroup article.

#ifdef _MSC_VER
# pragma warning( disable: 4512 ) // Can't gen. assignment operator.
#endif

#include <assert.h>
#include <boost/bind.hpp>
#include <boost/spirit/core.hpp>
#include <iostream>
#include <memory> // std::auto_ptr
#include <stack> // std::stack
#include <string> // std::string

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

class BoolRpnCalc
{
private:
     stack<bool> myStack;

     bool popValue()
     {
         bool const result = myStack.top();
         myStack.pop();
         return result;
     }

     void push( bool v ) { myStack.push( v ); }

     static bool fullOr( bool a, bool b ) { return (a || b); }
     static bool fullAnd( bool a, bool b ) { return (a && b); }

public:
     void doValue( bool aValue ) { push( aValue ); }
     void doOr() { push( fullOr( popValue(), popValue() ) ); }
     void doAnd() { push( fullAnd( popValue(), popValue() ) ); }
     void doNegation() { push( !popValue() ); }

     bool value() const { return myStack.top(); }
};

class ParseActions: public BoolRpnCalc
{
public:
     typedef BoolRpnCalc Base;

     void onValue( char const* str, char const* /*end*/ )
     {
         assert( str[0] == '0' || str[0] == '1' );
         doValue( str[0] != '0' );
     }
     void onOr( char const*, char const* ) { doOr(); }
     void onAnd( char const*, char const* ) { doAnd(); }
     void onNegation( char const*, char const* ) { doNegation(); }
};

#define PARSEACTION( p, method ) \
     bind( &ParseActions::method, p, _1, _2 ) // "Delegate" 2-arg functor.

class BoolExpression: public grammar<BoolExpression>
{
private:
     BoolExpression( BoolExpression const& );
     BoolExpression& operator=( BoolExpression const& );

     std::auto_ptr<ParseActions> myActions;

     ParseActions* pActions() const { return &*myActions; }

public:
     BoolExpression(): myActions( new ParseActions ) {}

     bool value() const { return myActions->value(); }

     template< typename ScannerT > struct definition;
     template< typename ScannerT > friend struct definition;

     template< typename ScannerT >
     struct definition
     {
         definition( BoolExpression const& c )
         {
             expression =
                 term >> *( ("||" >> term)[PARSEACTION( c.pActions(), onOr )] );

             term =
                 factor >> *( ("&&" >> factor)[PARSEACTION( c.pActions(), onAnd
)] );

             factor =
                 lexeme_d[(ch_p( '0' ) | ch_p( '1' ))[PARSEACTION( c.pActions(),
onValue )]]
                 | '(' >> expression >> ')'
                 | ('!' >> factor)[PARSEACTION( c.pActions(), onNegation )]
                 ;
         }

         rule<ScannerT> expression, term, factor;

         rule<ScannerT> const& start() const { return expression; }
     };
};

int main()
{
     cout << "Type a bool expression (0, 1, ||, &&, !), or [q or Q] to quit" <<
endl;

     for( ;; )
     {
         string str;

         cout << endl;
         if( !getline( cin, str ) ) { break; }
         if( str.empty() || str[0] == 'q' || str[0] == 'Q' ) { break; }

         BoolExpression calc; // Our parser
         parse_info<> info = parse( str.c_str(), calc, space_p );

         if( info.full )
         {
             cout << str << " = " << calc.value() << endl;
         }
         else
         {
             cout << "Parsing failed\n";
             cout << "stopped at: \": " << info.stop << "\"" << endl;
         }
     }

     cout << "Bye... :-)" << endl;
}
</code>

Cheers, & hth.,

- Alf

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?