Another question: Is it possible to call a function that has already executed and is below a function that is calling it? I get an error when I try to do this:
I'm using Dev C++ compiler.Code:int somefunction() { main(); } int main() { somefunction(); }
I need this for the game I mentoined in my last post.
Last edited by DarkAlex; 11-28-2007 at 10:54 PM.
You might be able to do that in C, but not in C++. Instead you'd use some form of loop:
Or:Code:int main() { for (;;) { somefunction(); } }
Or:Code:int main() { while (true) { somefunction(); } }
You can also add some condition to the loop, which as long as the condition is true, the loop will continue to execute.Code:int main() { do { { somefunction(); } while (true); }
In general you can. In fact it is quite common to have functions call one another in a recursive descent parser.
I'm pretty sure you're not allowed to call 'main' recursively though, which could be the problem you're running into.
My homepage
Advice: Take only as directed - If symptoms persist, please see your debugger
Linus Torvalds: "But it clearly is the only right way. The fact that everybody else does it some other way only means that they are wrong"
That being the case, maybe instead of calling main(), do this instead:Originally Posted by iMalc
Code:int somefunction(); int someotherfunction(); int main() { somefunction(); } int somefunction() { someotherfunction(); } int someotherfunction() { somefunction(); }
The compiler will only know functions that are above your current function, unless you add declarations that say "these functions do exist," as swoopy shows you. It's common and good practice to add declarations for all your functions.
That's actually something I've wondered for a while... Is there any easy way (portable or not) to see the call stack, kind of like the BT command in gdb? Java can do it, which I find very nice in debugging, but it would be nice if I could print the call stack in C or C++ along with an error message.
Not portably. You have to walk the stack yourself, often relying on accompanying debug information to do so. And due to inlining, that stack may not be what you'd expect from the code.
All the buzzt!
CornedBee
"There is not now, nor has there ever been, nor will there ever be, any programming language in which it is the least bit difficult to write bad code."
- Flon's Law
Yes, as CornedBee says, it's unportable and depends on debug info.
You can quite easily write a function that dumps the stack in hex, and, if you can get a machine-readable form of the symbol table, can give you the function names from this.
--
Mats
Compilers can produce warnings - make the compiler programmers happy: Use them!
Please don't PM me for help - and no, I don't do help over instant messengers.
Yeah, that's pretty much what I figured.
Thank you, swoopy. That really helps. The game invoves rooms that might need to be revisited.
The following should work on Intel-type architectures where the calling convention is "Push Args, Push Return, Push Base Pointer." The recur() and recur2() functions are just for demonstration. main() is proxied to trace(), in order to avoid any weirdness caused by main() not being a "normal" function. Calling backtrace(0) at any point will dump a raw trace, which you can fairly easily match up with function names by referring to a link map:
Downside: Not portable, and liable to crash if the stack is not in pristine condition. Compiler optimizations may obscure your trace or cause it to explode. I provide no warrantyCode:#include <stdio.h> void recur(int n); void recur2(int n); unsigned int *base_top; void backtrace(unsigned int dummy) { unsigned int *base = &dummy - 2; unsigned int *ret = base + 1; printf("0x%08x\n", *ret); while(*base != (unsigned int)base_top) { base = (unsigned int *)*base; ret = base + 1; printf("0x%08x\n", *ret); } } void recur(int n) { if(!n) { backtrace(0); } else { recur2(n); } } void recur2(int n) { recur(n - 1); } int trace(int argc, char **argv) { base_top = (unsigned int *)&argc - 2; recur(10); } int main(int argc, char **argv) { return trace(argc, argv); }
Um, I was just using main() as an example, sorry for confusion.
