At last! Expressions are parsed! Currently it doesn't do much with them, but it parses brackets and handles operator precedence correctly.

Here's what I ended up doing:

First, read tokens from the stream until we reach an unmatched bracket or a semicolon. That gives us a stream of tokens like so:
2 + 3 * (5 + 4) / (7 + 6)

Next, search for brackets. If an open bracket is found, recurse to this step again starting from the next token.
When we find a close bracket, evaluate the expression between the brackets (See below), and generate I-code. Return from this function.

When we evaluate expressions, we just go through each operator precedence level and evaluate them.

So, sample:
2 + 3 * (5 + 4) / (7 + 6)

Seek for brackets, find first one so recurse:
5 + 4) / (7 + 6)

Find close bracket, so evaluate and return:
CODE(5, 4, +) / (7 + 6)

Seek for brackets, find first one so recurse:
7 + 6)

Find close bracket, so evaluate and return:
CODE(5, 4, +) / CODE(7, 6, +)

That gives us:
2 + 3 * CODE(5, 4, +) / CODE(7, 6, +)

So, evaluate in precedence order, left to right:
-> 2 + 3 * CODE(5, 4, +) / CODE(7, 6, +)
-> 2 + CODE(3, 5, 4, +, *) / CODE(7, 6, +)
-> 2 + CODE(3, 5, 4, +, *, 7, 6, +, /)
-> CODE(2, 3, 5, 4, +, *, 7, 6, +, /, +)

I think that's right anyway...
That leaves a stack of operands and operators in reverse polish notation, which, evaluates as:
2, 3, [5, 4, +], *, 7, 6, +, /, +
=2, 3, 9, *, 7, 6, +, /, +
2, [3, 9, *], 7, 6, +, /, +
= 2, 27, 7, 6, +, /, +
2, 27, [7, 6, +], /, +
= 2, 27, 13, /, +
2, [27, 13, /], +
= 2, 2.08, +
[2, 2.08, +]
= 4.08
Which is the correct answer. Yay!

I need to add support for finctions, conditionals, etc etc and test it more, but it's looking promising. Wheeeeee...

// rop_n - relational operator node
// sc - the global text scanner class

node *cond(bool get)
{
    node *n=norm(get);

    while(true)
        {
        switch(sc.type)
            {
            case sc.eq: n=new rop_n(rop_n::eq,n,norm(true)); break;
            case sc.neq: n=new rop_n(rop_n::neq,n,norm(true)); break;
            case sc.gt: n=new rop_n(rop_n::gt,n,norm(true)); break;
            case sc.gteq: n=new rop_n(rop_n::gteq,n,norm(true)); break;
            case sc.lt: n=new rop_n(rop_n::lt,n,norm(true)); break;
            case sc.lteq: n=new rop_n(rop_n::lteq,n,norm(true)); break;

            default: return n;
            }
        }
}

node *expr(bool get)
{
    node *n=logi(get); n->check();

    if(sc.type==sc.qust)
        {
        n=new tern_n(n);
        n->ln=expr(true); sc(sc.colon,false); n->rn=expr(true);
        }

    return n;
}