Re: Library / header compilation mismatch
On Jan 21, 10:34 pm, "stephen.dive...@gmail.com"
<stephen.dive...@gmail.com> wrote:
This isn't strictly a language issue, but it seems enough of a
cross- IDE and -platform concern to merit asking here.
I'm running into a maintenance issue for a library I've
written. The problem is I have a config.h file that includes
a bunch of #define directives that control the compilation of
the library. Those directives can also be overridden by
options to the compiler. The problem arises when I compile
the library with one set of directives, and then in a project
that links to the library, compiler options override the
library's directives and the headers that are included don't
match the library that was compiled. Strange errors and fun
debugging ensues.
I'd like to find a way to test for this condition
automatically, ideally at compile time without runtime
overhead. One option is to provide something like:
config.h:
#define FLAG_SSE 0x01
#define FLAG_OPENGL 0x02
#define FLAG_WIN32 0x04
bool checkCompilationFlags ( int flags );
config.cpp:
static int COMPILATION_FLAGS = FLAG_SSE | FLAG_OPENGL | FLAG_WIN32;
bool checkCompilationFlags ( int flags ) { return ( flags ==
COMPILATION_FLAGS ); }
Therefore, when the library is compiled, COMPILATION_FLAGS
will store the configuration that was used, and the
application can call checkCompilationFlags with its understood
values for the flags and see if they match. This isn't great
though, as it requires calling the function somewhere in the
application, it adds some (small) runtime overhead, and it
only raises the error at runtime. A perfect solution would
not require anything more than including the headers in the
application, would compile away with optimization, and would
raise a compile-time error in the event of a mismatch.
Has anyone dealt with this issue before? Are there any
standard approaches or clever tricks? Any ideas? Thanks,
I don't do it for options (yet---it's a good idea for options
which affect binary compatibility), but I encode the version in
the namespace name. Something like:
#define PASTE(a,b) a ## b
#define MyNamespace PASTE( MyNamespace_, versionId )
namespace MyNamespace {
// ...
}
If you link against the wrong version, you get all of your
symbols undefined.
As long as the flags you're interested in are hexadecimal
constants, written as above, you could do the same thing---all
of the characters in a hexadecimal literal are legal in an
indentifier.
The only downside might be if clients want to use a debugger;
the debugger isn't going to find the symbol MyNamespace::toto.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34