#include "../main.c"

[Bauform B. (bauformb)]

Guten Morgen!

Nochmal, weil es so schön ist:

#include "../main.c"

Gibt es dafür Schläge oder sogar eine spezielle Hölle? Weil, es ist 
überaus praktisch.

Es gibt ca. 60 Funktionen int foo(const char*); Die werden bisher alle 
in einem einzigen main() benutzt. Jetzt soll jede Funktion ein 
eigenständiges Programm werden und per klassischem CGI vom httpd 
aufgerufen werden. An den Funktionen selbst muss fast nichts geändert 
werden, die brauchen nur ein main() drum herum. Diese ca. 60 main() 
wären alle identisch, nur ist main.c z.Zt. noch ziemlich ausbaufähig:

#include <fcntl.h>

typedef int(*plugin_pt)(const char *);
extern plugin_pt plugin;

int
main (void)
{
   const char  *method, *uri, *query;
   int  fd;

   fd = open ("/var/log/bozo", O_WRONLY | O_APPEND);
   log_init (fd);
   method = getenv ("REQUEST_METHOD");
   uri    = getenv ("REQUEST_URI");
   query  = getenv ("QUERY_STRING");
   log_printf (1, "%s %s", method, uri);
   if (query == NULL) {
      query = "";
   }
   return plugin (query);
}

#include <stdio.h>
#include "foo.h"
//...
#include "../main.c"
plugin_pt plugin = foo;

int foo (const char *query)
{
}

[Jörg W. (dl8dtl) (Moderator)]

Ich würde es "main_impl.c" oder so nennen.

[Daniel A. (daniel-a)]

Sowas würde ich per Linker lösen.

// include/server_framework/plugin.h
typedef void plugin_main_f(void);
extern plugin_main_f plugin_main;

// src/plugin/a/main.c
#include <stdio.h>
#include <server_framework/plugin.h>
void plugin_main(void){ printf("Plugin A\n"); }

// src/plugin/b/main.c
#include <stdio.h>
#include <server_framework/plugin.h>
void plugin_main(void){ printf("Plugin B\n"); }

// src/server_framework/main.c
#include <server_framework/plugin.h>
int main(){ plugin_main(); }

cc -I include/ src/server_framework/main.c -c -o server_framework_main.o
cc -I include/ src/plugin/a/main.c -c -o plugin_a.o
cc -I include/ src/plugin/b/main.c -c -o plugin_b.o
cc server_framework_main.o plugin_a.o -o plugin_a
cc server_framework_main.o plugin_b.o -o plugin_b

src/server_framework/* kann man natürlich auch in eine Library packen, 
statisch oder dynamisch geht beides. (Zumindest unter Linux, unter 
Windows geht vermutlich nur statisch, wenn da die main drin ist).

mkdir lib
cc -fPIC -I include/ src/server_framework/main.c -c -o server_framework_main.o # -fPIC brauchts nur für shared libs
ar r lib/libserver_framework.a server_framework_main.o # Statische lib
cc -shared lib/libserver_framework.a -o lib/libserver_framework.so # Optional, dynamische lib

cc -Llib plugin_a.o -o plugin_a -lserver_framework
cc -Llib plugin_b.o -o plugin_b -lserver_framework

// LD_LIBRARY_PATH falls dynamische Library verwendet wird. Alternativ, in /usr/local/lib installieren und ldconfig aufrufen
LD_LIBRARY_PATH=$PWD/lib/ ./plugin_a

(Unter Windows kann man nicht das selbe Archiv für die Statische lib und 
die DLL nehmen, dort braucht man für die .o / .obj schon andere 
Optionen)

Muss man halt einmal ein Makefile dafür erstellen.

PS: Ich nehme gerne -Wl,--whole-archive libserver_framework.a 
-Wl,--no-whole-archive damit keine undefinierten oder doppelten Symbole 
wegen Linkerreihenfolge rumschwirren

[Oliver S. (oliverso)]

Wenn eine Problem anscheinend eine Lösung erfordert, die signifikant von 
den sonst üblichen Vorgehensweisen abweicht, ists meistens ein 
xy-Problem.

C hat Includefiles üblicherweise als Header, und die toolchain bietet 
einen linker. Das reicht.

C bietet aber auch immer die Möglichkeit, sich sehr effektiv und mit 
Erfolgsgarantie selber in den Fuß zu schiessen.

Oliver

[Cyblord -. (cyblord)]

Bauform B. schrieb:
> Gibt es dafür Schläge oder sogar eine spezielle Hölle?

Dafür gibts nur die Entlassung.

[Niklas G. (erlkoenig)]

Muss es denn unbedingt #include sein? Warum nicht die main.c ganz normal 
kompilieren und dazu linken? Ggf. per "-D" Compiler Option den Namen der 
gewünschten Funktion als Makro definieren.

[Bauform B. (bauformb)]

Ja, ok, überzeugt :)

Daniel A. schrieb:
> src/server_framework/* kann man natürlich auch in eine Library packen,
> statisch oder dynamisch geht beides.

Diese Funktionen benutzen sowieso eine shared library. Ich hab' jetzt 
mal nichts weiter gemacht als main da rein zu packen (die include-Datei 
ist jetzt leer). Das funktioniert ohne weitere Änderung sofort. Das 
Beste: die 60 Programme müssen nach Änderungen an main nicht neu gelinkt 
werden. Allerdings ist main() jetzt wirklich gut versteckt ;)

Die Namen der Funktionen möchte ich nicht ändern, manchmal ist _func_ 
ganz nützlich. Also behalte ich den Funktionspointer; ein Makro 
funktioniert ja nicht, wenn main() in der lib steckt.

Vielen Dank für Trost und Rat!

Oliver S. schrieb:
> C bietet aber auch immer die Möglichkeit, sich sehr effektiv und mit
> Erfolgsgarantie selber in den Fuß zu schiessen.

Deswegen frage ich ja Euch ;)