Evaluate nested statements

Are yu just trying to evaluate the expression, or are you needing it to be stored in a tree (eg for multiple evaluations with variable values).

If you only want to evaluate the expression, you probably don't need to use a tree, you'd be better off just with a recursive function.

I'm assuming there's only one type of value, the integer, and that all sub-expressions and bracketed expressions return an integer.

If all the above is true, you could just use a function like the following (pseudo-code).

int evaluate(string expression) {
    scan(expression) for the highest-order operator.

    if(operator == "?") {
        int res = evaluate(expression before operator)
        scan(expression after operator) for ":"
        if(res) return evaluate(expression after "?" before ":")
        return evaluate(expression after ":")
        // this has the added bonus of not having to calculate the result that won't be returned.

    }

    if(operator == "(") {
        scan_reverse(expression) for ")"
        return evaluate(expression after "(" before ")".
    }
    if(operator == none) return string_to_num(expression)

    return func(operator, evaluate(expression before operator, expression after operator).  
}

int func(operator, int v1, int v2) {
    switch(operator)
        case "+": return v1 + v2.
        case ">": return v1 > v2.
        etc...
    }
}

and have a list of operators according to BEDMAS priority, where brackets are the lowest priority.

or, faster, have each entry in the operator list contain a function pointer

if you need the speed, it you probably don't want to copy the string every time, so simply replace the operator with a null character to break the string into two pieces.

This isn't that pretty (especially the special case for ?), but it should work.
If you want a prettier solution, you might want to consider using a pre-made parser.

(edit) - forgot source tags.

[edited by - Krylloan on August 14, 2003 7:10:32 PM]