standard way to determine depth in stack

[softwaredoug]

I can't see to easily find this on google or in a newsgroup

Is there a standard function/macro/whatever you can call and determine
the distance in a C program how deep one is in the C call stack from
main.

Something along the lines:

int main()
{
int i = stackdepth();
f2()
}

here i == 0.

void f2()
{
int i = stackdepth();
}

here i == 1

and so on.

I'm interested in nonstandard ways (if a standard way does not
suffice), or any crazy ideas.

[Ian Collins]

Jacob navia wrote:

>
You can do it as follows:
2)
Now, you can write

long long stackdepth(void )
{
int dummy;
long long top = (long long)stacktop;
long long bottom = (long long)&dummy;

Ignoring the unnecessary conversion, this will give weird results on a
64 bit system if any of the pointer bit patterns represent negative long
longs.

long long result = top - bottom;
if (result < 0)
result = -result;
return result;
}

One other thing I missed the first time: this will go horribly wrong in
a threaded application where each thread uses its own stack - a classic
case of subtracting two unrelated pointers giving undefined behaviour.

--
Ian Collins.

[swengineer001]

You can do it as follows:
1) In the main function, get the address of the first local variable:

void *stacktop;

int main(void)
{
int dummy;

stacktop = (void *)&dummy;
.....

}

2)
Now, you can write

long long stackdepth(void )
{
int dummy;
long long top = (long long)stacktop;
long long bottom = (long long)&dummy;

long long result = top - bottom;
if (result < 0)
result = -result;
return result;

}

Why would an implementation that does use a stack need to store the
first local variable of the current function on the top of that stack?
That seems to me to be a pretty big assumption in your code that you
failed to mention to the OP. While that may be the case in your
environment there is certainly no reason that it has to be implemented
in such a way as long as I can access the variable while it is in
scope I could just as easily put it last, or anywhere else I want for
that matter.

>
3)
Please ignore all stupid remarks like "this is not portable".
This is obviously not portable to any machine. It requires a
stack, and it supposes that an address fits in a long long.

....and that long long exists

4) Please ignore all stupid remarks like " this is undefined behavior
since you can't take the difference of two pointers that do not point to
the same object"

While he is at it why doesn't he ignore stupid responses to his
question that don't even answer what he was asking. While, in some
cases, this may give you the depth in bytes (or even possibly some
other unknown unit) it does not tell him in the units he asked about
pretty unabiguously when he stated "here i == 1."

[Old Wolf]

On Feb 22, 11:48 am, "softwared...@g mail.com" <softwared...@g mail.com>
wrote:

>
Is there a standard function/macro/whatever you can call and determine
the distance in a C program how deep one is in the C call stack from
main.

You could put:

#define ENTERING_FUNCTI ON() (++depth)
#define RETURN(x) do { --depth; return x; } while(0)

size_t depth = 0;

and then write all your functions like:

void func()
{
ENTERING_FUNCTI ON();
foo, bar;
RETURN();
}

and then inspect the 'depth' variable when you need to.
This has added benefits, eg. you could define the macros
to write a complete call trace to a log file when needed,
etc. (Obviously it has some down-sides).

[CBFalconer]

"so**********@g mail.com" wrote:

>
I can't see to easily find this on google or in a newsgroup

Is there a standard function/macro/whatever you can call and
determine the distance in a C program how deep one is in the C
call stack from main.

Certainly, and you can do it within purely standard C.

/* main.h */
extrn int stackdepth;
/* end main.h */

/* main.c */
#includes /* as needed */
#include main.h

int stackdepth;

int main(void) {
...
stackdepth++;
functioncall(pa rams);
stackdepth--
...
return 0;
}

Now if you use the above paradigm for all function calls, in all
modules, stackdepth will keeptrack of the nesting level. All
modules need to include main.h. Don't use longjump.

You might want to macroize the stackdepth++ and stackdepth--
operations, so you can easily eliminate them later without editing.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net>