Question

I want to create a kind of parser of the form:

#include <iostream>
#include <string>
#include <sstream>
#include <cctype>

using namespace std;

bool isValid(istringstream& is)
{
  char ch;
  is.get(ch); //I know get(ch) is a good start but this is as for as I got :)
  .......
  ....
}

int main()
{
  string s;
  while(getline(cin,s))
  {
    istringstream is(s);
    cout<<(isValid(is)? "Expression OK" : "Not OK")<<endl;
  }
}

A boolean function that returns TRUE if the sequence of char is of the form “5” or “(5+3)” or “((5+3)+6)” or “(((4+2)+1)+6)” …etc and FALSE for any other case

Basically, an expression will be considered as valid if it is either a single digit or of the form “open parenthesis-single digit-plus sign-single digit-close parenthesis”

• Valid Expression = single digit

  and

• Valid Expression = (Valid Expression + Valid Expression)

Given that there is no limit to the size of the above form (number of opening and closing parenthesis..etc.) I’d like to do that using recursion

Being the newbie that I am.. Thank you for any helpful input!

Answer 1

To do a recursive solution you’re gonna want to read the string into a buffer first, then do something like this:

int expression(char* str) {
    if (*str == '(') {
        int e1 = expression(str + 1);
        if (e1 == -1 || *(str + 1 + e) != '+') {
            return -1;
        }
        int e2 = expression(str + 1 + e + 1);
        if (e2 == -1 || *(str + 1 + e + 1 + e2) != ')') {
            return -1;
        }
        return 1 + e1 + 1 + e2 + 1;
    }

    if (*str >= '0' || *str <= '9') {
        return 1;
    }

    return -1;
}

bool isvalid(char* str) {
    int e1 = expression(str);
    if (e1 < 0) {
        return false;
    }
    if (e1 == strlen(str)) {
        return true;
    }
    if (*(str + e1) != '+') {
        return false;
    }
    int e2 = expression(str + e1 + 1);
    if (e2 < 0) {
        return false;
    }
    return (e1 + 1 + e2 == strlen(str));
}

Basically, the expression function returns the length of the valid expression at it’s argument. If it’s argument begins with a parenthesis, it gets the length of the expression after that, verifies the plus after that, then verifies the closing parenthesis after the next expression. If the argument begins with a number, return 1. If something is messed up, return -1. Then using that function we can figure out whether or not the string is valid by some sums and the length of the string.

I haven’t tested the function at all, but the only case this might fail in that I can think of would be excessive parenthesis: ((5)) for example.

An alternative to recursion could be some sort of lexical parsing such as this:

enum {
    ExpectingLeftExpression,
    ExpectingRightExpression,
    ExpectingPlus,
    ExpectingEnd,
} ParseState;

// returns true if str is valid
bool check(char* str) {
    ParseState state = ExpectingLeftExpression;

    do {
        switch (state) {
            case ExpectingLeftExpression:
                if (*str == '(') {
                } else if (*str >= '0' && *str <= '9') {
                    state = ExpectingPlus;
                } else {
                    printf("Error: Expected left hand expression.");
                    return false;
                }
            break;
            case ExpectingPlus:
                if (*str == '+') {
                    state = ExpectingRightExpression;
                } else {
                    printf("Error: Expected plus.");
                    return false;
                }
            break;
            case ExpectingRightExpression:
                if (*str == '(') {
                    state = ExpectingLeftExpression;
                } else if (*str >= '0' && *str <= '9') {
                    state = ExpectingEnd;
                } else {
                    printf("Error: Expected right hand expression.");
                    return false;
                }
            break;
        }
    } while (*(++str));

    return true;
}

That function’s not complete at all, but you should be able to see where it’s going. I think the recursion works better in this case anyways.