multiple compilation and main() function in c - gcc

Question

I have a problem related to the functioning of gcc for the compilation of different files.
My goal would be to have a program (see script1.c) that would load (compile?) The functions from the script2.c and script3.c file on each run.
This is what my scripts should look like (the names (2 main() and 1 init()) of the functions in the script2.c and script3.c files must not be changed).
script1.c:
int main(int argc, char *argv[]){
printf("loaded main() in script1.c\n");
int ret = main(argc, argv); // main() script2.c
if(ret == 0){
init(argc, argv); // init() script3.c
ret = main(argc, argv); // main() script3.c
if(ret == 0){
ret = main(argc, argv); // main() script3.c
}
}
return(ret);
}
script2.c:
int main(int argc, char *argv[]){
printf("loaded main() in script2.c\n");
return(0);
}
script3.c:
void init(int argc, char *argv[]){
...
argv[0] = (char*)strdup("OK");
printf("loaded init() in script3.c\n");
}
int main(int argc, char *argv[]){
...
if(strcmp(argv[0], "OK") == 0){
printf("loaded init() in script3.c\n");
}
return(0);
}
I would like to return :
loaded main() in script1.c
loaded main() in script2.c
loaded init() in script3.c
loaded main() in script3.c
loaded main() in script3.c
I logically have loops on the main() function.
Here are the different methods I was able to try:
Change the name of the main() function of script1.c to _start(), and use the "-Wl,--allow-multiple-definition -nostartfiles" option during compilation.
Result: Error with the main() function of script2.c is logically initialized 2 times.
Use the system() and exec functions in script1.c to compile/run scripts2.c and script3.c.
Result: Error with script3.c which executes the main() function, before the init() function. I would need, I think, a working equivalent of the "-Wl, -init, init" option for this to work.
Add attribute((constructor)) in the init() function so that it is started before the main() of script3.c. The problem, is that in my example, the init() function will be launched 2 times :

Answer 1

Here is an example of something that may resemble what you are trying to do. I have one main function as well as three helper functions, aptly named func1, func2 and func3. They all reside in the same directory. Each function is in their own source file, named after the function for clarity (but the source file name is arbitrary). main(), the program's "entry point", calls func1, then func2; func2, in turn, calls func3. The parameters to main() are faithfully passed on each time, and output.
In a typical program one would also have a header file that contains the function declarations for all three helper functions; but in this small example one can simply write them manually.
func1.c:
#include <stdio.h>
void func1(int argc, char **argv)
{
printf("func1: Called with the following arguments:\n");
for(int i = 0; i<argc; i++)
{
printf("func1, arg. %d (index %d): ->%s<-\n", i+1, i, argv[i]);
}
printf("func1: Returning\n");
}
func2.c:
#include <stdio.h>
extern void func3(int, char **);
void func2(int argc, char **argv)
{
printf("func2: Calling func3\n");
func3(argc, argv);
printf("func2: returning\n");
}
func3.c
#include <stdio.h>
void func3(int argc, char **argv)
{
printf("func3: Called with the following arguments:\n");
for(int i = 0; i<argc; i++)
{
printf("func3, Arg. %d (index %d): ->%s<-\n", i+1, i, argv[i]);
}
printf("func3: Returning\n");
}
And main.c:
#include <stdio.h>
extern void func1(int, char **);
extern void func2(int, char **);
int main(int argc, char **argv)
{
printf("main(): Called with the following arguments:\n");
for(int i = 0; i<argc; i++)
{
printf("Arg. %d (index %d): ->%s<-\n", i+1, i, argv[i]);
}
printf("********* main(): Calling func1 *********\n");
func1(argc, argv);
printf("********* main(): Calling func2 *********\n");
func2(argc, argv);
}
Sample session: Compile with
$ gcc -Wall -o main main.c func1.c func2.c func3.c
and then execute with e.g.
$ ./main 1 2 3
Output:
Arg. 1 (index 0): ->./main<-
Arg. 2 (index 1): ->1<-
Arg. 3 (index 2): ->2<-
Arg. 4 (index 3): ->3<-
********* main(): Calling func1 *********
func1: Called with the following arguments:
func1, arg. 1 (index 0): ->./main<-
func1, arg. 2 (index 1): ->1<-
func1, arg. 3 (index 2): ->2<-
func1, arg. 4 (index 3): ->3<-
func1: Returning
********* main(): Calling func2 *********
func2: Calling func3
func3: Called with the following arguments:
func3, Arg. 1 (index 0): ->./main<-
func3, Arg. 2 (index 1): ->1<-
func3, Arg. 3 (index 2): ->2<-
func3, Arg. 4 (index 3): ->3<-
func3: Returning
func2: returning
You can see that the first argument to the program is put in their by the command shell and C runtime library: It's the string with which the program was called, which is customary, here "./main". Only after that come the explicit command line arguments "1", "2" and "3".