Newsgroup: it.comp.lang.c
Titolo: C - Programmazione modulare

Sera,
attualmente sto sviluppando in C un piccolo server web, poichè voglio
incrementare le mie conoscenze verso la programmazione di socket e la
gestione di file tramite web. In seguito vorrei renderlo adatto a
'girare' su piattaforme poco potenti o con limitazioni particolari (in
genere vps o vecchi pc recuperati a web server con scarse capacità)
attualmente ambiente *nix-like.
Attualmente sto lavorando sulla base (inizializzazione dell'ambiente)
ovvero leggere il primo file di configurazione che definisce la
gerarchia del server (la posizione dei file di log, il loro nome,
l'httproot, la cgiroot). Prima di proseguire oltre (ovvero
l'inizializzazione dei log e della loro formattazione, vorrei fare un
modulo aggiuntivo da inserire solo se espresso nella compilazione
(configure file) per definire dinamicamente la formattazione dei log
(utile per l'analisi dei log automatica), altrimenti si usa quella
standard. In seguito l'implementazione di cgi e fastcgi sempre
condizionali.
Dunque mi chiedevo quale fosse il modo migliore di preparare il codice
alla gestinoe dei moduli (che non saranno caricati dinamicamente come
apache a runtime, ma per semplificare il tutto ogni richiesta di un
modulo richiede la ri-compilazione) in modo che il codice sviluppato
non dipenda troppo dalla verifica di quali moduli sono attivi e quali
no e senza quindi sviluppare eccessivo codice che poi senza modulo non
gira.
Ho pensato in un primo momento di fare inserire dal configure file
delle definizioni di macro con il nome del modulo e quindi sfruttare i
commenti condizionali del pre-compilatore come segue:
common.h
#define MODULE
...
file.c
#include "common.h"
#ifdef MODULE
[do it]
#endif
Ma ho il vago sospetto che possa esistere qualche soluzione migliore
di questa in modo da gestire in futuro nuovi moduli senza dover
rimettere mano ad ogni parte del codice e quindi rendere ogni modulo
perfettamente autonomo.
Grazie a chiunque risponderà,
in caso servano maggiori delucidazioni vi prego di chiedere e
risponderò quanto prima.
Ciao ciao!

 perfettamente autonomo.
A mio parere questa � la soluzione migliore perch� ti permette di 
sfruttare in compile time l'informazione sui moduli presenti, e dunque 
il codice avr� il massimo della performance. L'unico difetto � che per 
inserire un modulo devi ricompilare tutto.
Una soluzione forse pi� elegante � invece quella di scegliere i moduli 
al momento del linking, invece che in compilazione. Questo ti permette 
di inserire un modulo senza ricompilare niente, ma solo rifacendo il 
linking. La cosa viene pi� pulita e in futuro i moduli potrebbero 
diventare librerie dinamiche senza tanti sforzi.
Per ottenere questo il modulo deve poter eseguire del codice 
autonomamente al momento dell'avvio del programma. Questo si pu� 
ottenere (in C++, ora mi viene il dubbio che in C non si possa fare!) 
inizializzando una variabile globale con una chiamata a funzione.
E.

 E.
Innanzitutto intendo ringraziarti per la risposta,
dato che cerco di renderlo il più performante possibile credo proprio
che per ora ripiegherò sulla dichiarazione di macro tanto alla fine i
moduli che intendo sviluppare sono pochi (3 o 4) e quindi mi
converrebbe fare così. Se poi in futuro si amplierà il progetto e
magari avrò più esperienza penserò alle librerie dinamiche. Se
comunque qualcuno dovesse avere della documentazione valida in
merito... il tempo per imparare c'è sempre :D.
Riguardo alla dichiarazione dei moduli durante la fase del linking,
come si potrebbe sfruttare questa situazione?
Magari facendo sempre commenti condizionali e quindi importare gli
header con la definizione di macro contenente il nome del modulo ?
Grazie ancora, ciao ciao.

 header con la definizione di macro contenente il nome del modulo ?
No, questo ti costringerebbe comunque a ricompilare. Poter aggiungere i 
moduli in fase di linking � un procedimento pi� flessibile.
Il modo pi� brutale (per capire il meccanismo) pu� essere questo:
// FILE: common.h
int *hasModulePippo();
// FILE: main.c
#include "common.h"
int *hasModulePippo() {
   static int x=0;
   return &x;
}
main() {
   if (*(hasModulePippo())) {
     printf("il modulo pippo e' abilitato\n");
   }
}
// FILE: pippo.c
// questo file pu� essere linkato o meno nel progetto finale
#include "common.h"
int initPippo() {
   *(hasModulePippo())=1;
   return 1;
}
// questa inizializzazione forse non � valida in C standard... in C++ di 
// sicuro funziona:
static int initializer=initPippo();
// E.

 // E.
Capito, beh sicuramente è un buon metodo,
ti ringrazio della spiegazione, proverò con qualche test e nel caso
replicherò qui :)
Ciao ciao.