handling the tail part of a non-tail recursive function when converting it to an iterative function
===

When converting a non-tail recursive function to an iterative function using your own made stack what is the general approach to take care of the part of the code that comes after the recursion call aka the tail?

The following function is supposed to explore all the possible paths in a maze, revisiting a previsited path in order to visit other paths in the stack:

    struct node{
        int id;
        bool free;
        int neighborNode[4];
        int toProcess;
    } nodeMap[100];

    void findPath(int current){
        visited[current] = true;
        int i;
        for (i=0; i < 4; i++){
           if(nodeMap[nodeMap[current].neighborNode[i]].free == true && visited[nodeMap[current].neighborNode[i]] == false && nodeMap[current].neighborNode[i] != -1){
            path[cc] = nodeMap[nodeMap[current].neighborNode[i]].id;
            cc++;
            findPath(nodeMap[current].neighborNode[i]);
            path[cc] = nodeMap[current].id;
            cc++;
            }
        }
    }

The recursive part of the code is easily convertible to an iteration:

    void findPath(){
        if (isEmpty())
            return;
        else {
            node temp = pop();
            visited[temp.id] = true;
            if (temp.toProcess < 3) {
                temp.toProcess++;
                push(temp);
                temp.toProcess--;
            }
            if(nodeMap[temp.neighborNode[temp.toProcess]].free == true && visited[temp.neighborNode[temp.toProcess]] == false && temp.neighborNode[temp.toProcess] != -1){
                path[cc] = nodeMap[temp.neighborNode[temp.toProcess]].id;
                cc++;
                push(nodeMap[temp.neighborNode[temp.toProcess]]);
            }
        }
    }

But the part where the algorithm moves backwards to revisit previously seen nodes to explore other possible paths (the tail) i.e. path[cc] = nodeMap[current].id; cc++; does not seem to fit in the iterative version of the method!
Is there a general approach to this? Or every case is different? In anyways, do you have any suggestion how to implement the tail part in this case?