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

So how do you implement a function call? Especially a function call that takes a function?

Originally Posted by King Mir

So how do you implement a function call?

I posted the operator()(...) member function of the function class a few posts ago. That is ...AFAI'm concerned, the function call.
If you mean list evaluation, here it is :

Code:

std::string list::eval()
{
    if(size_val==0)return "nil"; //When an empty list is received

    std::string name = car(),temp;

    std::istringstream is1(name);
    is1>>temp;
    if(temp=="(")
        name = list(name).eval(); //If the name itself is a list

    list args = cdr();
    std::istringstream is(name);
    double d;

    auto v = var_scope.find(name); 
    if(v!=nullptr)return *v; //If the list contains a single variable (This isn't acceptable in the formal lisps)

    auto f = f_scope.find(name); //f_scope relates the function names to the function objects
    if(f!=nullptr)
    {
        for(auto x=args.begin();x!=args.end();x++) //this loop 'simplifies' the arguments to a function...recursively.
        {
            std::string val = *x,temp;
            std::istringstream is2(val);
            is2>>temp;
            if(temp=="(")
            {
                list l(val);
                *x = l.eval();
            }
        }
        return (*f)(args);
    }
    auto m = m_scope.find(name); //Macros
    if(m!=nullptr)return (*m)(args);

    else if(is>>d)return name; //If the list contains a single number..

    else throw(exception(name+" : name not found."));
}

Especially a function call that takes a function?

As an argument ? (...which would be analogous to taking functors or function pointers ?)
I did not do it yet, as it should depend upon lambda functions and some associated macros which I'm yet to implement.

Oh right, cause your treating interpreted functions as actual functions. Which is bad for recursion, because you are limited by the stack. I recommend not doing that.

Wherever you use recursion use a loop: push the arguments to the called function on the stack, and start eval again. Recursive compiled functions should work the same way, unless you can implement them using loops more directly.

Recursion is limited by the program stack unless you don't implement it as actual recursion. Tail recursion can be implemented as a loop with no stack, and other recursive cases can be implemented with a loop and separate stack as I described above.