Solution for undefined Sym when compiling multiple files

Question

Hi, I'd like to suggest a solution for the common 'undefined sym' problem.
Combining all the source files into one file solves the problem quite effectively.
I'm not sure if this is due to gcc, or some name mangling scheme that's throwing
the avm2 off but in any case, when I compile multiple c++ files 'separately', ie
g++ (or gcc) A.c B.c C.c -O3 -DOSX -DRT_AS3 -swc -o library.swc
results in
1) undefined _main if main() is not in C.c (but in another file which is not last in the list),
and
2) calling ANY function in A.c or B.c from C.c results in an "undefined sym" runtime error.
When combining the files into one unit however, and then compiling that unit works fine:
on linux/darwin:
cat A.c B.c C.c > unit.c
g++ (or gcc) unit.c -O3 -DOSX -DRT_AS3 -swc -o library.swc
hope this helps someone.
J

Answer 1

Perhaps I didn't explain my question well enough. We already are using a dependency management system (based on jam - blows the doors off of make). However, some of our libraries that we build consist of many ( 100+ ) individual .cpp files, and there are many of these libraries in a dependency hierarchy. Invoking the compiler once per file seems to be a source of considerable overhead. I want to invoke the compiler only twice per library, no matter how many individual .o files need to be rebuilt - once to rebuild the out of date subset of .c files (one "-c" style invocation, no link step, generate object files only), and once to link the rebuilt .o files and the unchanged .o files into the target shared object.
However, the compiler will not accept multiple "-o" flags, forcing us to invoke it once per file if we want to specify an output name. I want an option (or a workaround) that will allow us to specify multiple source files, and the output name for each in one compiler invocation. One approach could be a flag that could be used repeatedly to specify source file name / object file name pairs on the command line. Another would be a flag that set a derivation rule by which the output object file name would be generated from the input source file name.
Repeatedly invoking the entire toolchain to compile one file of many, when the include dependency graphs, symbol tables, template instantations, etc. of each of those files are certain to overlap to a great degree, seems to me like a huge waste. Why must we reparse std::basic_string for each source file if we know the build environment is the same, just because we want to specify the output filename?