From: "John Bodfish" <bodfish AT als DOT ameritech DOT com>
Newsgroups: comp.os.msdos.djgpp
Subject: Re: Mysterious C++ STL compiler message
Date: 10 Nov 1997 23:16:53 GMT
Organization: Ameritech Library Services
Lines: 95
Message-ID: <01bcee2e$9117e5a0$b8cde7c0@JOHNB.als.ameritech.com>
References: <19971109182601 DOT NAA28166 AT ladder01 DOT news DOT aol DOT com>
NNTP-Posting-Host: n5184.als.ameritech.com
To: djgpp AT delorie DOT com
DJ-Gateway: from newsgroup comp.os.msdos.djgpp
Precedence: bulk

Charles:
Templates are good. Templates are good. Keep saying this, and the following
will be easier
to live with:

An STL stack<class T> is a "container adapter". What's that? Well, it's a
template class
which adapts a container template class, adding some functionality. In the
case of
stack, the added functionality is largely the push/pop functions. But the
stack template
just ADDS these functions to a container template class like deque, list or
vector.

I think you want a stack<deque<operator> >, not a stack<operator>, since
your operator type
isn't a container template class.

Here's what I did to your example to get it working (My comments identify
the changes):

// Add this:
#include <deque>

#include <stack>
#include <_string.h>

// Change names as yours are used in lang/cxx/function.h
enum operators { leftparen, add, subtract, multiply, divide};

String opString(operators theOp)
{
    switch (theOp) {
// Change names here too, of course.
        case add:         return " + ";
        case subtract:        return " - ";
        case multiply:        return " * ";
        case divide:       return " / ";
        case leftparen:    return " [ ";
        default:           return "\0";
    }
}

// Insert this so gcc instantiates deque<operators>
// (see info gcc, under "Template Instantiation", for details).
template class deque<operators>;

// Change the second parameter to be a stack<deque<operators> >
void processOp
    (operators theOp, stack<deque<operators> > & opStack, String & result)
{
    // pop stack while operators have higher precedence
    while ((! opStack.empty()) && (theOp < opStack.top()))
    {
        result += opString(opStack.top());
        opStack.pop(); // You had opString.
    }
    opStack.push(theOp);
}

// I added this to test:
int main(void)
{
        stack< deque<operators> > myStack;
        String myResult;
        operators myOp(leftparen);

        myStack.push(add);
        myStack.push(leftparen);
        myStack.push(subtract);
        myStack.push(multiply);
        myStack.push(divide);

        processOp(myOp, myStack, myResult);

        cout << myResult;

        return 0;
}

Name this file "stack.cc".
Compile with "gcc -o stack stack.cc -lstdcx -lgpp"

I haven't taken time to consider what you're doing here, so perhaps list or
vector is
better than deque. I didn't know what output to expect so I can't validate
the
myResult value either.

But that should help with the STL.

-- 
John Bodfish
bodfish AT als DOT ameritech DOT com