Thread: function version info

You could use a static const char *:

Code:

#include <stdio.h>

#define FUNCTION_VERSION "1.1.1"

void function(void) {
    static const char *version = __func__ "() version " FUNCTION_VERSION;

    puts(version);
}

int main(void) {
    function();

    return 0;
}

Output:

Code:

function() version 1.1.1

(__func__ is a C99 macro: a string containing the name of the current function. It's infinitely useful for debugging. Other standard C89 macros are __FILE__, __DATE__, __TIME__, and __LINE__.)

The above program takes advantage of the fact that string will be concatenated together by the preprocessor:

Code:

"Hello, "
"World!\n"

->

Code:

"Hello, World!\n"

Originally Posted by rechmbrs

The link step gripes about multiple instances.

You're not putting source code in a header, are you?

The header has something like this, right?

Code:

extern char doframes_version[];

And only the source code has something like this, right?

Code:

char doframes_version[] = "doframes_v001";

(Although preferably const.)

A hideous example:

Code:

/* foo.h  */
#ifndef FOO_H
#define FOO_H

extern const char foo_version[];
void foo(void);

#endif

Code:

/* foo.c  */
#include "foo.h"

const char foo_version[] = "foo v1.0";
void foo(void)
{
}

Code:

/* bar.h */
#ifndef BAR_H
#define BAR_H

extern const char bar_version[];
void bar(void);

#endif

Code:

/* bar.c  */
#include "bar.h"

const char bar_version[] = "bar v2.2";
void bar(void)
{
}

Code:

/* baz.h  */
#ifndef BAZ_H
#define BAZ_H

extern const char baz_version[];
void baz(void);

#endif

Code:

/* baz.c  */
#include "baz.h"

const char baz_version[] = "baz v2.0";
void baz(void)
{
}

Code:

/* main.c */
#include <stdio.h>
#include "foo.h"
#include "bar.h"
#include "baz.h"

int main ()
{
   puts(foo_version);
   puts(bar_version);
   puts(baz_version);
   getchar();
   return 0;
}

/* my output
foo v1.0
bar v2.2
baz v2.0
*/

Put the extern declaration in the header. Add the definition in one source file.

#include one header in the other?
Use macro trickery in the header?
Provide its definition in its associated module rather than the main?

The best way that I know to do what you're trying to do is to create a variable in each header file of the form

Code:

int VSTRING_headername_version;

and then look at the symbol table for the entries that begin "VSTRING_". Note that you never initialize this variable, and it's not declared extern. The linker should combine all occurrences of one of these into a single storage location. In years past, I've seen this done, but I don't know if it works with VC++ of any flavor. One of the downsides is that you can't get the info from an executable that does not have a symbol table.

I don't recall if the above technique violates anything in the C90 standard, but because the behavior that it depends on was used by so many pre-ANSI C programs, most compilers/linkers did support it (even though it is probably depricated usage).

Some compilers create a symbol in the object file symbol table for each file encountered during compilation, and those symbols may also be stored in the linked images symbol table.

None of these does exactly what you want, however.