Thread: Can it be detected if stack space is about to expire?

I already have a structure (A std::vector of std::map `s encapsulated into a 'scope' class ....(..than may translate into a dynamic array of binary trees..AFAIK)) in which all variables are stored.
A new map is pushed back each time a new scope appears...and is popped when the scope exits.
The relevant portion of the code is...

Code:

    std::string function::operator()(list& l)
    {
        std::string result;
        if(l.size()!=arg_list.size())throw(exception("Wrong no. of Args."));

        std::map<std::string,std::string> scope_map;
        auto x=arg_list.begin(); auto y = l.begin();
        for(;x!=arg_list.end();x++,y++)  //<--This loop makes the map relating the values of the variable to their name
        {
            std::string foo(*x),bar(*y);
            scope_map[foo]=bar;
        }
        var_scope.new_local(scope_map);  //var_scope is declared in "env.h"
        
        if(compiled)
        {
            result = (*body_c)(arg_list);
        }
        else
        {
            result = body_l.eval();
        }
                
        var_scope.exit_scope(); //Pops the variable map of the current scope.
        return result;
    }

The scope class can be found here (..but it is fairly obvious what it does.) : Confusing Template error

This is my usage of the 'virtual' stack represented with the scope class.
I'd try both approaches(linking this somehow to the machine stack... and detecting if the function will be 'bad' before executing it).
For the later, I have a good idea how to implement it so that catches most problems.
But I've no idea how to use this data structure to establish a relation to the machine stack.

mana! Don't use manual popping! This isn't exception safe!
I suggest you model your program by using a "scope" class for each scope. That way you will make your code exception safe.

Currently, you have some parent object, so you do

parent.enter_scope(...);
parent.leave_scope(...);

Instead of that, a better way to do it is

Scope new_scope;
// Nothing. Object will go out of scope when we leave scope.

Originally Posted by manasij7479

But that doesn't give me a centralized way of finding values.
(Not applicable for functions) .. but some MACROs in lisp allow setting a local variable which can be accessed from all 'child' scopes.
Handling that would become problematic with your way... while in what I have, I can just call the find() method of the global scope object .

You just need to make sure that whenever you would do a manual pop, you would force some object to go our of scope.
I urge you to think about that design a little. Nothing is more painful than code that fails when a certain path in your code is taken.

Originally Posted by whiteflags

How do you know?

By definition.
Whether it works or not is another matter.

Make sure you use a deque for the stack instead of a vector, to allow a larger size.

You should make it so that an interpreted function call does not add to the program stack at all. So an interpreted recursive loop should result in running out of memory, never stack space.

I think stack or vector or dequeue are all inferior to a linked list of scopes.

Originally Posted by Elysia

mana! Don't use manual popping! This isn't exception safe!
I suggest you model your program by using a "scope" class for each scope. That way you will make your code exception safe.

You don't necessarily want to pop something off on an exception. An exception would mean something is wrong with the interpreter. The state of the interpreted program stack should probably be left alone, to allow backtracing and better logging.

An exception in user code is a different story, but that shouldn't trigger an actual exception.

Originally Posted by brewbuck

I think stack or vector or dequeue are all inferior to a linked list of scopes.

Why? You're only ever popping or pushing, so you don't need insertion in the middle. Using a linked list would just add memory overhead. Deque (not vector) will instead allocate large chunks of memory that only contain stored data, without any additional usage per stored object (only per chunk).

Deque is perfect for stacks and queues.

Originally Posted by King Mir

An exception in user code is a different story, but that shouldn't trigger an actual exception.

Why ? IMHO, that is the point of using exceptions here...and the best way to refuse acknowledging syntactically wrong input...and showing the corresponding error message within the exception object.

(Well, I'm going to just replace the internal storage of the scope class to deque and list successively just to see what happens ..This is why I like C++! )

The way I've seen it done, specifically in Bison, which is a parser generator, is to have a state for each position in the grammar, and a switch on which token could come next. An improper token would generate an error, but no stack unwinding is needed to handle it. It then jumps to a state in which the error can be handled, first eating additional faulty input by a specified rule (for instance until newline).

EDIT:But that's not actually what I meant my a user exception.
I mean that if there is an exception in the code (if your language allows for it), then you want to manually pop elements off the stack until you get to the error handler.