The help is this :
amalgamate built May 19 2011, 18:01:28 args: amalgamate HELP : usage : amalgamate [-options]
<from1> [from2...] options: -q : quiet -v : verbose -c : add source file's local dir to search paths -p : use pragma once [else treat all as once] -r : recurse from dirs [list but don't recurse] -xS : extension filter for includes S=c;cpp;h;inl or whatever -eS : extension filter for enum of from dir -iS : add S to include path to amalgamate from names can be files or dirs use -i only for include dirs you want amalgamated (not system dirs)
What it does : files that are specified in the list of froms (and match the extension filter for enum of from dir), or are found via #include (and match the extension filter for includes), are concatted in order to the output file. #includes are only taken if they are in one of the -I listed search dirs.
-p (use pragma once) is important for me - some of my #includes I need to occur multiple times, and some not. Amalgamate tells the difference by looking for "pragma once" in the file. eg. stuff like :
#define XX stuff #include "use_XX.inc" #define XX stuff2 #include "use_XX.inc"needs to include the .inc both times. But most headers should only be included once (and those have #pragma once in them).
So for example I made a cblib.h thusly :
amalgamate cblib.h c:\src\cblib c:\src\cblib\LF c:\src\cblib\external -Ic:\src -p -xh;inc;inl -ehwhich seems to work. As another test I made an amalgamated version of the test app for rmse_hvs_t that I gave to Ratcliff. This was made with :
amalgamate amalgamate_rmse_hvs_t.cpp main_rmse_hvs_t.cpp rmse_hvs_t.cpp -I. -v -Ic:\src -pand the output is here : amalgamate_rmse_hvs_t.zip (83k)
But for anything large (like cblib.cpp) this way of sticking files together just doesn't work. It should be obvious why now that we're thinking about it - C definitions last until end of file (or "translation unit" if you like), and many files have definitions or symbols of the same name that are not the same thing - sometimes just by accidental collision, but often quite intentionally!
The accidental ones are things like using "#define XX" in lots of files ; you can fix those by always using your file name in front of definitions that you want to only be in your file scope (or by being careful to #undef) - also local namespacing variables and etc. etc. So you can deal with that.
But non-coincidental collisions are quite common as well. For example I have things like :
replace_malloc.h : #define malloc my_malloc replace_malloc.c : void * my_malloc ( return malloc(); }It's very important that replace_malloc.c doesn't include replace_malloc.h , but when you amalgamate it might (depending on order).
Another nasty one is the common case where you are supposed to do some #define before including something. eg. something like :
#define CB_HUFFMAN_UNROLL_COUNT 16 #include "Huffman.h"that kind of thing is destroyed by amalgamate (only the first include will have effect, and later people who wanted different numbers don't get what they expected). Even windows.h with the WINNT_VER and LEAN_AND_MEAN gets hosed by this.
You can also get very nasty bugs just by tacking C files together. For example in plain C you could have :
file1 : static int x; file 2 : int x = 7;and in C that is not an error, but now two separate variables have become one when amalgamated. I'm sure there are tons of other evil hidden ways this can fuck you.
So I think it's basically a no-go for anything but tiny code bases, or if you very carefully write your code for amalgamation from the beginning (and always test the amalgamated build, since it can pick up hidden bugs).