Newsgroup: it.comp.os.linux.development
Titolo: versione programma

Salve
Qual'e' il modo migliore per definire all'interno del codice (scritto in 
C) la versione del programma ?
Al momento ho impostato una costante VERSION:
#define VERSION "0.2.1"
Ma c'e' forse una qualche covenzione in merito ?
Grazie
Ciao
	MaX

YattaMaX wrote:

Le "convenzioni" sono tante:
1) come la tua: #define VERSION "numero.numero.numero-extra"
2) una costante numerica o stringa per ogni numero:
        #define VERSION_MAJOR   numero
        #define VERSION_MINOR   numero
        #define VERSION_MICRO   numero
        #define VERSION_EXTRA   "extra"
3) se usi gli autotools c'e` la possibilita di creare un config.h da un
config.h.in
 dove ci sono le definizioni del pacchetto: PACKAGE,
PACKAGE_TARNAME, PACKAGE_TITLE, VERSION, tutte quante #define utili per il
tuo programma....
ciao!
-- 
daniele_athome

 
config.h.in
 dove ci sono le definizioni del pacchetto: PACKAGE,
]zac[
Il modo corretto è usare le macro che gli autotools rendono disponibili, per
esempio:
cat 
configure.ac
# Process this file with autoconf to produce a configure script.
AC_INIT(gesconf, 0.3.7, 
be...@adria.it
 
be...@libero.it
)
AC_CONFIG_SRCDIR([src/GesConf.h])
#AC_CONFIG_HEADER([config.h])
#AM_CONFIG_HEADER([config.h])
AM_INIT_AUTOMAKE(gesconf, 0.3.7)
.....
In modo che ogni file di configurazione possa essere ''compilato/impostato''
con i valori richiesti (ad esempio la directory ' po ' per le traduzioni)
con il solo lancio di autoconf/automake/.configure .

 con il solo lancio di autoconf/automake/.configure .
Per le librerie (aggiungo come riferimento per chi cercasse con Google
;-)), poi, vale la pena definire macro per ogni singola parte della
versione:
m4_define([mylib_major_version], [0])
m4_define([mylib_minor_version], [0])
m4_define([mylib_micro_version], [1])
m4_define([mylib_version],
	  [mylib_major_version().mylib_minor_version().mylib_micro_version()])
# define in config.h
AC_DEFINE([MYLIB_MAJOR_VERSION], [mylib_major_version()], [Major version])
AC_DEFINE([MYLIB_MINOR_VERSION], [mylib_minor_version()], [Minor version])
AC_DEFINE([MYLIB_MICRO_VERSION], [mylib_micro_version()], [Micro version])
AC_DEFINE([MYLIB_VERSION], [mylib_version()], [MyLib version])
e usarla per scrivere macro come:
#include "config.h"
#define MYLIB_CHECK_VERSION(_major,_minor,_micro) \
	(((_major) >= MYLIB_MAJOR_VERSION) || \
	 (((_major) == MYLIB_MAJOR_VERSION) && \
	  ((_minor) >= MYLIB_MINOR_VERSION)) || \
	 (((_major) == MYLIB_MAJOR_VERSION) && \
	  ((_minor) == MYLIB_MAJOR_VERSION) && \
	  ((_micro) >= MYLIB_MICRO_VERSION)))
cosi' da poter scrivere:
#if MYLIB_CHECK_VERSION(1,0,0)
	do_something_new (data);
#else
	do_something_old (data);
#endif
+++
Ovviamente, invece di usare AC_DEFINE e poter accedere alle macro solo
all'interno del sorgente, l'altra opzione e' di usare AC_SUBST per
poter creare le macro:
MYLIB_MAJOR_VERSION=mylib_major_version()
AC_SUBST(MYLIB_MAJOR_VERSION, mylib_major_version())
...
AC_OUTPUT([
	...
	version.h
	...
])
E creare un template in cui fare, ad esempio:
#define MYLIB_MAJOR_VERSION	@MYLIB_MAJOR_VERSION@
...
+++
Ci sono vari modi per fare queste cose, basta cercare nei progetti
esistenti; in realta`, come mi e` stato detto qualche tempo fa, ci sono
solo quattro persone al mondo in grado di usare gli auto-tools: il resto
di noi, copia e incolla. :-)
Ciao,
 Emmanuele.

 tuo programma....
Usare template per il config.h e` decisamente deprecato - e se usi
auto-tools successivi alla 1.4, autoconf si lamentera` in maniera
piuttosto vivace.
Le definizioni si fanno usando AC_DEFINE e AC_DEFINE_UNQUOTED.
Ciao,
 Emmanuele.

 AC_DEFINE([MYLIB_VERSION], [mylib_version()], [MyLib version])
Meglio, AC_DEFINE_UNQUOTED, cosi' si possono usare in raffronti numerici
(come quello che ho scritto).
Ciao,
 Emmanuele.

 di noi, copia e incolla. :-)
]zac[
ehehe, molto molto vero.
Senza uno spunto di partenza con gli autotools è un massacro.
Però DOPO è piuttosto utile leggere la documentazione fornita insieme agli
auto-tools, ci sono degli spunti molto interessanti (come aggiungere
l'installazione via make, la traduzione, ecc. anche agli script, la
personalizzazione delle funzioni di installazione e altro).

Giuseppe Della Bianca wrote:

Si in effetti io ho prima visto e provato script gia` scritti da altri
programmi (autoproject per esempio, molto utile...) e poi ho letto la
documentazione e imparato a fare delle modifiche... ma a rifarlo da zero
non sarei capace...
ciao!
-- 
daniele_athome

> Senza uno spunto di partenza con gli autotools è un massacro.
Effettivamente... all'uopo, ho realizzato un bel generatore di progetti
(con tanto di directory per la debianizzazione del pacchetto) per 
automatizzare la creazione di quel po' po' di entropia che sono gli
autotools :-)
Per chi fosse interessato, puo' trovarlo qui:
http://cvs.savannah.nongnu.org/viewcvs/mkprjj/util/?root=mkprjj
il nome "di lavoro" del file e':
genAutoC.pl
Comunque, se aveste da segnalare documentazione in proposito, a 
parte i manuali di Autoconf & Automake...
In particolare, non ho capito bene come funziona Autoheader.
Ad esempio, se io volessi che il mio progetto usi l'include:
#include<mio.h>
e cioe', in poche parole, che il comando
make install
copi mio.h in /usr/include,
che cosa devo dire ad auto{conf/header/make} ?
Grazie,
P.

 che cosa devo dire ad auto{conf/header/make} ?
autoheader non c'entra molto; al contrario, automake e` la risposta:
Makefile.am:
	mylib_includedir = $(includedir)/mylib
	mylib_include_HEADERS = \
		mylib.h		\
		mylib-foo.h	\
		mylib-bar.h	\
		mylib-baz.h
Tra l'altro, consiglio *vivamente* l'utilizzo di pkgconfig per le
librerie o per applicazioni che forniscono shared-libraries e include.
Salva molto tempo, salva da molti errori e salva da molti giramenti di
palle - garantisco.
Ciao,
 Emmanuele.

 In particolare, non ho capito bene come funziona Autoheader.
]zac[
man autoheader
       autoheader - Create a template header for configure
SYNOPSIS
       autoheader [OPTION] ... [TEMPLATE-FILE]
DESCRIPTION
       Create  a template file of C `#define' statements for `configure' to
use.  To this end, scan TEMPLATE-FILE, or `
configure.ac
' if
       present, or else `
configure.in
'.
....
In sintesi fa una scansione del 'configure' e produce un file con una lista
di #define utile per inserire un solo file invece che una lista di file
xyz.h, e dovrebbe essere utilizzabile anche per poter avere una lista di
'sezioni/moduli' attivabili/disattivabili in fase di configure.

 Tra l'altro, consiglio *vivamente* l'utilizzo di pkgconfig per le
parli di pkg-config ?

 parli di pkg-config ?
Dato il contesto, anche se non ho messo il dash tra pkg e config mi
pare si capisse.
Ciao,
 Emmanuele.

 pare si capisse.
Il punto è che... non ho mai avuto occasione di utilizzarlo, per cui
andavo di pkg<TAB> per vedere se lo avevo, non per altro.
Effettivamente, a leggere il man sembra un buon strumento.
Grazie,
P.
-- 
Should I stay or should I go