Boolean equation parser library?

        
char *cur;

Expr *parse(char *s)
{
    cur = s;
    return parseE();
}

Expr *parseE()
{
    Expr *temp = parseA();

    while (skipWS() && *cur == '+')
    {
        cur++;
        temp = new ORExpr(temp, parseA());
    }
    
    return temp;
}

Expr *parseA()
{
    Expr *temp = parseN();

    // note, this needs to be checked and maintained carefully,

    // as it's looking for things that indicate that the next

    // character isn't the start of an N expression.  I think I

    // got them both, but I'm not sure.

    while (skipWS() && *cur != '+' && *cur != ')')
    {
        temp = new ANDExpr(temp, parseN());
    }

    return temp;
}

Expr *parseN()
{
    Expr *temp = parseT();

    while (skipWS() && *cur == '\')
    {
        cur++;
        temp = new NOTExpr(temp);
    }

    return temp;
}

Expr *parseT()
{
    // and finally, interesting stuff happens.

    if (!skipWS)
    {
        // reached the end of the string, unexpectedly.

        whatever error-handling code you want.
    }
    else if (*cur == '(')
    {
        cur++;
        Expr * temp = parseE();

        if (!skipWS() || *cur != ')')
        {
            // unbalanced parens.

            whatever error-handling code you want.
        }
        
        cur++;
        return temp;
    }
    else if (isalpha(*cur))
    {
        Expr *temp = new AtomExpr(*cur);
        cur++;
        return temp;
    }
    else
    {
        // unexpected character.

        whatever error-handling code you want.
    }
}

char skipWS()
{
    while (*cur && isspace(*cur)) cur++;
    return *cur;
}
        

  
class BoolExpr
{
public:
    BoolExpr() : _a(0), _b(0) {}
    ~BoolExpr() { if(_a) delete _a; if(_b) delete _b; }
    virtual bool Eval(bool values[]) = 0;
    virtual bool Eval(unsigned long values) = 0;
    virtual void Print(void) = 0;
protected:
    BoolExpr *_a;
    BoolExpr *_b;
};
  

  class BoolExpr_OR : public BoolExpr
{
public:
	BoolExpr_OR(BoolExpr *a, BoolExpr *b) { _a = a; _b = b; }
	bool Eval(bool values[]) { return _a->Eval(values) || _b->Eval(values); }
	bool Eval(unsigned long values) { return _a->Eval(values) || _b->Eval(values); }
	void Print(void) { std::cout << "or("; _a->Print(); std::cout << ", "; _b->Print(); std::cout << ")"; }
};  

  class BoolExpr_AND : public BoolExpr
{
public:
	BoolExpr_AND(BoolExpr *a, BoolExpr *b) { _a = a; _b = b; }
	bool Eval(bool values[]) { return _a->Eval(values) && _b->Eval(values); }
	bool Eval(unsigned long values) { return _a->Eval(values) && _b->Eval(values); }
	void Print(void) { std::cout << "and("; _a->Print(); std::cout << ", "; _b->Print(); std::cout << ")"; }
};  

  class BoolExpr_NOT : public BoolExpr
{
public:
	BoolExpr_NOT(BoolExpr *a) { _a = a; }
	bool Eval(bool values[]) { return !(_a->Eval(values)); }
	bool Eval(unsigned long values) { return !(_a->Eval(values)); }
	void Print(void) { std::cout << "not("; _a->Print(); std::cout << ")"; }
};  

  class BoolExpr_ATOM : public BoolExpr
{
public:
	BoolExpr_ATOM(int index) : _index(index) {}
	bool Eval(bool values[]) { return values[_index]; }
	bool Eval(unsigned long values) { return (values & (1 << _index)) ? true : false; }
	void Print(void) { std::cout << "#" << _index; }
private:
	int _index;
};  

  
BoolExpr * BoolEquation::_CompileE(const char *&expr_string, std::string &var_list)
{
    // E ::= And { + And }*

    BoolExpr *expr = _CompileA(expr_string, var_list);
    while(expr && *expr_string && *expr_string == ''+'')
        expr = new BoolExpr_OR(expr, _CompileA(++expr_string, var_list));
    return expr;
}
 
BoolExpr * BoolEquation::_CompileA(const char *&expr_string, std::string &var_list)
{
    // A ::= N { N }*

    BoolExpr *expr = _CompileN(expr_string, var_list);
    while(expr && *expr_string && *expr_string != ''+'' && *expr_string != '')'')
        expr = new BoolExpr_AND(expr, _CompileN(expr_string, var_list));
    return expr;
}
 
BoolExpr * BoolEquation::_CompileN(const char *&expr_string, std::string &var_list)
{
    // N ::= T { '' }*

    BoolExpr *expr = _CompileT(expr_string, var_list);
    while(expr && *expr_string && *expr_string == ''\'''') {
        expr = new BoolExpr_NOT(expr);
        expr_string++;
    }
    return expr;
}
  
BoolExpr * BoolEquation::_CompileT(const char *&expr_string, std::string &var_list)
{
    // T ::= ( E ) | Atom

    if(!*expr_string) {
        _error = UNEXPECTED_END;
        return 0;
    }
    if(*expr_string == ''('') {
        BoolExpr *expr = _CompileE(++expr_string, var_list);
        if(*expr_string != '')'') {
            _error = UNBALANCED_PARANTHESES;
            if(expr) delete expr;
            return 0;
        }
        expr_string++;
        return expr;
    }
    else {
        int pos = var_list.find(*expr_string++, 0);
        if(pos == std::string::npos) {
            _error = UNKOWN_SYMBOL;
            return 0;
        }
        return new BoolExpr_ATOM(pos);
    }
    _error = ILLEGAL_CHARACTER;
    return 0;
}