Thread: Assert/Macro

I'm using assert's in my code and switching the NDEBUG flag to remove them at compile time, but my code is very modular and seperated among many c files. Is there a way to find out where the originating call to a function came from upon failure? Assert fails and reports the file and line, but that isn't entirely useful with generic code. After time, the problem can be found but i'd like a more specific error report.

can I pass the " __FILE__ " etc.. attribute to functions? I guess I would have to not use asserts but develop my own, if I did include the '___FILE__ attribute i would have to macro all my functions so the caller's didn't know this was going on....

Just looking for a good solution that is efficient, thanks.

I have used, use, variadic macros, to just simply print the -to- and -from-, I would believe you can do something similar, this all ties into using printf() for debugging.

Can you be more specific or show me an example? Variodic macros?

no luck, it complains about not having assert.c in the local directory im running the program from....strange it doesn't take me to where to code really is...

What brewbuck suggested would be a more direct detailed approach, for those more lazy, you can simply just print were you left and where your heading by:

[code]

#define debug(args...) if(bug) printf(args)
...
debug ("%s function....%s\n", *Entering-Exiting, *function_call);
...
[/code


http://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html

Seems easy, but what about getting the line and file number from the origin of the function call, as opposed to just inside the function? Is this a variable I'll have to pass to the function that is in some C file?

Well whatever the case, i know what an assert is and how it works. And i am capable of creating my own macro to do the same. My goal is merely to find out the origins of a function call (i.e. if it does not come from the same file which it never does). At the moment the only thing I can think of is passing the __FILE__ and __LINE__ arguments to my function calls which would require me to develop macros and function macros in order to hide this fact from the caller. I was simply asking if I had any other options, which it looks like I do not. This way I can fail inside the function I am calling, but also spit out the the information I need which is the origin file and line the call to my function came from.

For MSVC:
__FUNCTION__ - outputs the current function name
__FILE__ - outputs the current file
__LINE__ - outputs the current line
DebugBreak() - breaks the code on this line

For Windows:
OutputDebugString() - outputs a string to the output window

If you use macros for this the replacement will take place at the point where the error occurred and thus the MSVC macros will have the correct values. You can output these to any output device you need to for debugging.

Using the debugger is a must regardless, I am just trying to make it easier for someone debugging to have a file and line to debug at. A function that is being called is external to the main area where code is running, so knowing where code failed in some random file isn't exactly helpful when you have many lines of code in many other files all calling other files etc... makes it tricky to find the origin of the problem. Thats why I would like a breadcrumb trail printed to the screen on the even of an error to help the person debugging, afterall most of this code is just there for them to use, they don't know the intracate detai;s