Calling Function

I have been having some problems with an object im trying to make. I need one of the the methods to be able to figure out what function called it so it can associate it with the apropriate function in a list, without the user having to imply what function it is.

I would like an ANSI C solution but realizing that this probably isn't possible anything is good. I have tried utilizing the stack and only can get the current functions address from it, so any help here would be great.

Thanks in advance,
Alex

Well there's no ANSI-C way of doing it.

In C99, there is a predefined symbol (__func__) which is the current function name, so you could contrive something with
foo ( __func__, my, other, parameters );
But that's hardly "user free".

Perhaps you should state what it is you're trying to do.

Actually that may help tremendously.

Sorry for not being clearer, im making an error object and it is utilizing a Singly Linked List with the error messages in a struct with the first member being the address of the function these error messages are for. The end of any function will ret rather than return and rather than having the user of my library having to say ret(retNum,thisFunctions address) which would be INCREDIBLY reduntant, considering it would always be the same. I think that __func__ thing will do the trick though.

Now is __func__ the name of the function or the current functions respective address?

Edit(+):
Just so you know im not posting off topic, I put it in C not C++ even though im working on an object, for native C code, cause I like just using the basics of C for C++, without relying on C++ specific stuff so I can convert it to C later if I need to.

Edit(+):
Just another thing I have wondered for a LONG time, can you imply arguments? Example:

Code:

void fubar(__func__,arg2,arg3,...);

In that case I would want it to insert the address of the current function for the user as argument 1 not having them have to manually specify it. I know that C++ has this ``hidden argument'' thing for Objects(classes), the first argument or something is implied, this is EXACTLY what I need.

Thanks alot,
Alex

Oh and that __func__ thing doesnt work under Turbo C or GCC, what header is it in?

Edit(+):
Is there any way to get a pointer to the current function, even using the stack or such?

Like I said, __func__ is new in C99.
Which means neither C++ compiler will support it, and with dev-c++, you need to make sure you're compiling C, and probably add
-std=c99
to tell the compiler you're using the latest version of C.

> Now is __func__ the name of the function or the current functions respective address?
It's a const char *, containing the name of the function which is being compiled at the moment.

> Just another thing I have wondered for a LONG time, can you imply arguments?
You can probably hack something with macros, but default args are a C++ feature.

> Is there any way to get a pointer to the current function, even using the stack or such?
Yes, but all such things are extremely dependent on your implementation.

Well the macro thing I just found out about, however I need to know how to get the address of the current function, if its using inline ASM I could just rewrite it for other OSs native inline syntax, however I just want to know if there is a way to get the current function's address without using C99 thing. I know they are pushed onto the stack, but I cant seem to get relevant addresses popping such. Any idea how one would get the current function address?

The name of a function is its address. The following example is not guaranteed to work or be portable, but it is a Win32 example built with BC55.

Code:

#include <stdio.h>

void foo(void)
{
   puts("foo");
}

int main(void)
{
   printf("main @ %p\n", (void*)main);
   printf("foo  @ %p\n", (void*)foo);
   return 0;
}

/* my output
main @ 0040108C
foo  @ 0040107C
*/

I know they are pushed onto the stack, but I cant seem to get relevant addresses popping such.

Are you really trying to use assembly calling convention for a C function? Your compiler should document such things.

That works if I know the function im currently in, however that's the problem. I need a way of referencing the current function im in, without knowing its name IE main or foo. I will then dynamically add that to the call with a macro, but I need a way of namelessly sending the current functions address

Basically, you're trying to duplicate the actions of a debugger.
Debuggers work by reading the symbol table information which is typically appended to the end of executable files, which at a minimum is the name and address of all the global functions.

Accessing this information is of course implementation specific, but you may be able to find a library or two to make it less painful.

Well what i'm wanting to do is make an error object that will have a table of errors that are accessed depending on the code returned by the current function, but it cant know what the current function is without an address of some kind (which will also be in the struct of errors and the function name in char* form too)