Main Page | Modules | Alphabetical List | Data Structures | File List | Data Fields | Globals

arg.c

Go to the documentation of this file.
00001 /************************************************************************* 00002 * $Id: arg.c,v 1.1 2005/09/09 08:22:21 bellet Exp $ 00003 ************************************************************************** 00004 This software is governed by the CeCILL license under French law and 00005 abiding by the rules of distribution of free software. You can use, 00006 modify and/ or redistribute the software under the terms of the CeCILL 00007 license as circulated by CEA, CNRS and INRIA at the following URL 00008 "http://www.cecill.info". 00009 00010 As a counterpart to the access to the source code and rights to copy, 00011 modify and redistribute granted by the license, users are provided only 00012 with a limited warranty and the software's author, the holder of the 00013 economic rights, and the successive licensors have only limited 00014 liability. 00015 00016 In this respect, the user's attention is drawn to the risks associated 00017 with loading, using, modifying and/or developing or reproducing the 00018 software by the user in light of its specific status of free software, 00019 that may mean that it is complicated to manipulate, and that also 00020 therefore means that it is reserved for developers and experienced 00021 professionals having in-depth computer knowledge. Users are therefore 00022 encouraged to load and test the software's suitability as regards their 00023 requirements in conditions enabling the security of their systems and/or 00024 data to be ensured and, more generally, to use and operate it in the 00025 same conditions as regards security. 00026 00027 The fact that you are presently reading this means that you have had 00028 knowledge of the CeCILL license and that you accept its terms. 00029 00030 Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de 00031 l'Image). All rights reserved. See License.txt for details. 00032 00033 Version 1.0 05/09/2005 00034 *************************************************************************/ 00035 00036 /************************************************************************* 00037 * 00038 * Description : Gestion simplifiee des arguments passes sur la ligne 00039 * de commande. 00040 * 00041 **************************************************************************/ 00042 #include <stdio.h> 00043 #include <stdlib.h> 00044 #include <ctype.h> 00045 #include <string.h> // For strlen 00046 #include "idarg.h" 00047 #include "iderr.h" 00048 #include "idprint.h" 00049 #include "idio.h" 00050 00051 #define ARG_LONG_MAX 1000 /* JPR, au lieu de 100 */ 00052 00053 /* VERS 1.02 *********************************************************/ 00054 #define ARG_LABEL_LOGFILE "LOG" 00055 #define ARG_LABEL_PARAMOUT "paramout" 00056 static char * ArgParamOut; /* Nom du fichier de sortie param*/ 00057 /* Fin ******************************************************************/ 00058 00059 00060 static char * ArgUsed = 0; /* Arguments utilises */ 00061 static char * ArgLab[ARGMAXCOUNT]; /* Liste des labels d'arguments */ 00062 static char * ArgStr[ARGMAXCOUNT]; /* Liste des chaines d'arguments */ 00063 static int ArgCount = 0; /* Nombre d'arguments passes */ 00064 static char * Appel = 0; /* globale pour liberation par */ 00065 /* argfree */ /* CO 14/4/92 */ 00066 00067 /* Prototypes ***************************************** Version 1.03 CM **/ 00068 00069 static char * Majuscule (char*); 00070 static int FiltreLong (char*); 00071 static char * LoadedParam (char*,FILE*); 00072 static int ArgLoadFromFile (char*); 00073 static void ArgStdArgs (void); 00074 00075 /* Version 1.03 **********************************************************/ 00076 /************************************************************************** 00077 * * 00078 * Nom de la fonction : Majuscule * 00079 * Role ............. : Met une chaine de caracteres en majuscules. * 00080 * Parametres ....... : Pointeur vers la chaine. * 00081 * Valeur retournee . : pointeur vers cette meme chaine en majuscule. * 00082 * * 00083 **************************************************************************/ 00084 static char * 00085 Majuscule (chaine ) 00086 char * chaine; 00087 { 00088 char * ptr, *ptr2, *ptr3; 00089 ptr2 = malloc(strlen(chaine)*sizeof(char)+1);/*bb 30Mai95*/ 00090 ptr3=ptr2; 00091 00092 for ( ptr = chaine ; *ptr!='\0' ; ptr ++ ) 00093 { *ptr3 = toupper ( * ptr ); ptr3++; 00094 } 00095 *ptr3='\0'; 00096 00097 return ptr2; 00098 } 00099 00100 /************************************************************************** 00101 * * 00102 * Nom de la fonction : FiltreLong * 00103 * Role ............. : Arrete le programme si l'argument est trop long. * 00104 * ARG_LONG_MAX definit cette longueur. * 00105 * Parametres ....... : Pointeur vers l'argument. * 00106 * Valeur retournee . : Faux s'il n'y a pas d'erreur. * 00107 * Vrai s'il y a une erreur. * 00108 **************************************************************************/ 00109 static int 00110 FiltreLong (arg ) 00111 char * arg; 00112 { 00113 int n = 0 ; 00114 while ( (n++<ARG_LONG_MAX) && (*(arg++) != '\0') ) ; 00115 return (n>=ARG_LONG_MAX) ; 00116 } 00117 00118 00119 00120 /* VERS 1.02 *********************************************************/ 00121 /*------------------------------------------------------------------------ 00122 | Role : Lit un parametre depuis un fichier 00123 | Retour : Type : char * 00124 | Role : pointeur vers le label 00125 | Parametres : param : char * 00126 | Role : one ou il faut stocker le parametre 00127 | fd : FILE * 00128 | Role : descripteur du fichier (suppose ouvert) 00129 | 00130 +------------------------------------------------------------------------*/ 00131 static char * 00132 LoadedParam ( param, fd ) 00133 char * param; 00134 FILE *fd; 00135 { 00136 int carlu; 00137 char * car = param; 00138 int quote = FALSE; 00139 int nbcar = 0; 00140 00141 /* On supprime les espaces ****/ 00142 /* du debut de chaine *********/ 00143 while ( isspace(carlu=fgetc (fd)) ); 00144 if (carlu==EOF) return 0; 00145 /* On cherche une " eventuelle*/ 00146 if ( carlu=='\"' ) { 00147 carlu=fgetc(fd); 00148 quote=TRUE; 00149 /* On lit tous les caracteres */ 00150 } 00151 while ( (carlu!=EOF) 00152 && ( ( (!quote)&&(!isspace(carlu)) ) 00153 ||( (quote)&& !(carlu=='\"') ) ) ) { 00154 *(car++) = (char) carlu; 00155 nbcar ++; 00156 /* sans depasser la taille max*/ 00157 if ( nbcar >= ARG_LONG_MAX ) { 00158 IdErrPrintf("\nErreur: Argument trop long ( > %d )dans fichier de parametre.",ARG_LONG_MAX); 00159 break; 00160 } 00161 carlu = fgetc(fd); 00162 } 00163 *car = '\0'; 00164 return param; 00165 } 00166 00167 00168 /* VERS 1.02 *********************************************************/ 00169 /*------------------------------------------------------------------------ 00170 | Role : Lecture d'arguments dans un fichier de parametres 00171 | (cette fonction est recursive). 00172 | Retour : Type : int 00173 | Role : retourne le nombre de lettres necessaires 00174 | pour stocker en memoire tous les parametres 00175 | Parametres : filename : char * 00176 | Role : nom du fichier de parametre 00177 | 00178 +------------------------------------------------------------------------*/ 00179 static int 00180 ArgLoadFromFile ( filename ) 00181 char * filename ; 00182 { 00183 int nbl = 0; 00184 char param[ARG_LONG_MAX+1]; 00185 FILE * fch; 00186 00187 fch = fopen ( filename, ID_RFILE_TEXT ); 00188 while ( LoadedParam (param, fch ) ) { 00189 int n = strlen(param); 00190 if ( param[0]=='@' ) { 00191 nbl += ArgLoadFromFile ( &param[1] ); 00192 }else{ 00193 ArgLab [ArgCount] = strcpy ((char *) malloc(n+1), param ) ; 00194 nbl += n + 1 ; 00195 ArgCount++; 00196 if ( ArgCount >= ARGMAXCOUNT ) break; 00197 } 00198 } 00199 fclose ( fch ); 00200 return nbl; 00201 } 00202 00203 /*------------------------------------------------------------------------ 00204 | Role : Gestion des parametres standards de la ligne d'argument. 00205 | Retour : Type : void 00206 | Parametres : aucun 00207 +------------------------------------------------------------------------*/ 00208 static void 00209 ArgStdArgs() 00210 { 00211 char * logfile; 00212 FILE * fd; 00213 00214 if ( (ArgParamOut=IdArgValue(ARG_LABEL_PARAMOUT))==0 ) /* V1.02 */ 00215 ArgParamOut = ARG_DEFAULT_PARAMOUT; /* V1.02 */ 00216 00217 if ( (logfile = IdArgValue(ARG_LABEL_LOGFILE))!=0) 00218 { 00219 if ( *logfile == '\0' ) logfile = ARG_DEFAULT_LOGFILE; 00220 fd = fopen ( logfile, "a+" ); 00221 if ( fd ) 00222 { 00223 fprintf ( fd, "%s\n", Appel ); 00224 fclose ( fd ); 00225 } 00226 } 00227 } 00228 00229 /* FUNCTION DESCRIPTION ************************************************** 00230 * 00231 *IdArgInit (fonction) 00232 * 00233 * RESUME: Initialise le gestionnaire d'arguments des filtres LIBIDO. 00234 * 00235 * DESCRIPTION: Initialise le gestionnaire d'arguments des filtres LIBIDO. 00236 * Pour plus d'informations, se reporter a la description des 00237 * filtres de LIBIDO (manuel de l'utilisateur, et developpement). 00238 * 00239 * SYNTAXE: char * ligneAppel = IdArgInit (int argc, char **argv) ; 00240 * 00241 * RETOUR: type : char * 00242 * role : Pointeur vers une chaine contenant la ligne complete 00243 * d'appel du filtre. Les fichiers de parametres sont 00244 * developpees dans cette lignes. 00245 * PARAMETRES: 00246 * nom : argc 00247 * type : int 00248 * role : Nombre d'arguments passes a la fonction main. 00249 * 00250 * nom : argv 00251 * type : char ** 00252 * role : tableau de pointeur vers les arguments passes a 00253 * la fonction main (cf: Le Langage C-Kernighan & Richie). 00254 * 00255 * FICHIER: arg.c 00256 * 00257 * EXEMPLE: 00258 * #include <idarg.h> 00259 * int 00260 * main ( argc, argv ) 00261 * int argc; 00262 * char * argv[]; 00263 * { 00264 * char * ligne_appel; 00265 * ligne_appel = IdArgInit ( argc, argv ); 00266 * IdPrintf("\nAppel : \n\n%s\n\n", ligne_appel ); 00267 * IdExit(); 00268 * } 00269 * 00270 ******************************************************** END DESCRIPTION */ 00271 00272 /************************************************************************** 00273 * Explication ...... : recopie des arguments de la chaine de commande * 00274 * dans les variables statiques globales de arg.c : * 00275 * ArgCount : nombre de parametres * 00276 * ArgStr[ 0..ArgCount-1] : arguments * 00277 **************************************************************************/ 00278 char * IdArgInit (argc,argv) /* On laisse comme ca JPR */ 00279 int argc; 00280 char * argv[]; 00281 { 00282 int i; 00283 int nblettre; 00284 00285 00286 /* Lecture des parametres de la ligne de commande *************************/ 00287 for ( ArgCount=0, nblettre=1 , i=0; i<argc; i++) { 00288 if ( FiltreLong(argv[i]) ) 00289 { 00290 IdErrPrintf("Argument trop long ( > %d)...\n",ARG_LONG_MAX); 00291 return NULL; 00292 } 00293 if ( argv[i][0] == '@' ){ /* V1.02 */ 00294 nblettre += ArgLoadFromFile ( &argv[i][1] ); /* V1.02 */ 00295 }else{ /* V1.02 */ 00296 ArgLab [ArgCount] = strcpy ( (char *)malloc(strlen(argv[i])+1), argv[i] ) ; 00297 nblettre += 1 + strlen(ArgLab[ArgCount]); /* V1.02 */ 00298 ArgCount++; /* V1.02 */ 00299 } 00300 if (ArgCount >= ARGMAXCOUNT ) /* V1.02 */ 00301 { 00302 IdErrPrintf("Trop d'Arguments ( + de %d)\n", ARGMAXCOUNT ); 00303 return 0; 00304 } 00305 } 00306 00307 /* Initialisation d'un tableau memorisant les parametres deja utilises ****/ 00308 ArgUsed = (char *) calloc ( 1, ArgCount ); 00309 00310 /* Construction de la chaine complete des parametres d'appel **************/ 00311 Appel = (char *) calloc ( 1, nblettre ); 00312 00313 for ( *Appel = '\0', i=0; i<ArgCount; i++) { 00314 strcat ( Appel, ArgLab [i] ) ; 00315 strcat ( Appel, " " ) ; 00316 } 00317 00318 /* Separation du label de leur valeur *************************************/ 00319 for ( i=0; i<ArgCount; i++) { 00320 char * egaloufin = ArgLab[i] ; 00321 while ( (*egaloufin != '\0') && (*egaloufin != '=') ) egaloufin ++ ; 00322 if ( *egaloufin ) *(egaloufin++) = '\0'; 00323 ArgStr[i]= egaloufin; 00324 } 00325 00326 /* Mise en majuscule des labels ( casse non-sensible pour label ) *********/ 00327 for ( i=0; i<ArgCount; i++) 00328 ArgLab[i] = Majuscule ( ArgLab[i] ) ; 00329 00330 /* Les arguments standards sont geres par ArgStdArgs **********************/ 00331 ArgStdArgs(); 00332 00333 return Appel ; 00334 } 00335 00336 /* FUNCTION DESCRIPTION ************************************************** 00337 00338 IdArgDefined (fonction) 00339 00340 RESUME: verifie si un parametre existe dans la ligne de commande 00341 00342 DESCRIPTION: verifie si un parametre existe dans la ligne de commande 00343 00344 SYNTAXE: int retCode = IdArgDefined(char *label); 00345 00346 RETOUR: type : int 00347 role : Vrai si le parametre 'label' existe. 00348 En fait, la valeur retournee est 0 si le 00349 label n'est pas trouve, sinon, c'est le numero 00350 d'emplacement ou il a ete recontre pour la derniere 00351 fois. 00352 00353 PARAMETRES: 00354 nom : label 00355 type : char * 00356 role : Nom du label du parametre recherche. 00357 00358 FICHIER: arg.c 00359 00360 EXEMPLE: if ( !IdArgDefined("FILEIN") ) 00361 IdErrPrintf ("\nErreur: parametre non trouve"); 00362 00363 ******************************************************** END DESCRIPTION */ 00364 int 00365 IdArgDefined(SearchParam ) 00366 char * SearchParam; 00367 { 00368 int i, Trouve ; 00369 char *Temp; 00370 00371 Temp =Majuscule ( SearchParam ) ; 00372 00373 for ( Trouve = FALSE, i = ArgCount-1; i>0; i-- ) { /* V1.04 */ 00374 Trouve = ! strcmp( ArgLab[i], Temp ) ; 00375 if ( Trouve ) { 00376 int j; 00377 ArgUsed[i] = TRUE ; /* V1.04 */ 00378 for ( j=1; j<i; j++) { /* V1.04 */ 00379 if ( (!ArgUsed[j])&&(!strcmp(ArgLab[i],ArgLab[j])) ) /* V1.04 */ 00380 ArgUsed[j] = TRUE ; 00381 } 00382 return i ; 00383 } 00384 } 00385 00386 return FALSE ; 00387 } 00388 00389 /* FUNCTION DESCRIPTION ************************************************** 00390 00391 IdArgValue (fonction) 00392 00393 RESUME: Recupere la valeur du parametre, lue sur la ligne de commande 00394 00395 DESCRIPTION: Recupere la valeur du parametre demande, qui doit etre 00396 lu sur la ligne de commande. 00397 00398 SYNTAXE: char *valeurParam = IdArgValue(char *label); 00399 00400 RETOUR: type : char * 00401 role : Valeur, sous forme de chaine de caractere, du 00402 parametre dont le label est specifie. 00403 La chaine pointee ne doit pas etre modifiee. 00404 Elle doit, si necessaire, etre d'abord recopiee 00405 dans une autre chaine de caractere. 00406 Si le label n'est pas trouve, la fonction retourne 00407 le pointeur NULL. 00408 00409 PARAMETRES: 00410 nom : label 00411 type : char * 00412 role : Nom du label du parametre recherche. 00413 00414 FICHIER: arg.c 00415 00416 EXEMPLE: 00417 { 00418 char * ficsource; 00419 char * ficdestination; 00420 int fic_defaut = 0: 00421 00422 nomfic = IdArgValue("FILEIN"); 00423 00424 if ( (ficdestination = IdArgValue("FILEOUT")==0 ){ 00425 ficdestination = IdStrCreateNewSuffix(ficsource,".out"); 00426 fic_defaut = 1; 00427 } 00428 00429 00430 ... 00431 if (fic_defaut) free( ficdestination ); 00432 } 00433 00434 ******************************************************** END DESCRIPTION */ 00435 char * 00436 IdArgValue ( Param ) 00437 char * Param; 00438 { 00439 int Trouve ; 00440 00441 if ( (Trouve = IdArgDefined ( Param )) != FALSE ) 00442 return ArgStr[Trouve] ; 00443 else { return NULL ;} 00444 } 00445 00446 /* FUNCTION DESCRIPTION ************************************************** 00447 00448 IdArgUnused (fonction) 00449 00450 RESUME: Recherche du premier label encore non utilise. 00451 00452 DESCRIPTION: Recherche du premier label non encore utilise. 00453 Ce label devient alors un label utilise. 00454 Si tous les labels sont deja utilises, retourne NULL. 00455 00456 SYNTAXE: char *label = IdArgUnused(); 00457 00458 RETOUR: type : char * 00459 role : Pointeur vers une chaine de caratere contenant 00460 le premier label non utilise. 00461 retourne NULL si tous les labels ont ete utilises. 00462 00463 FICHIER: arg.c 00464 00465 EXEMPLE: la fonction suivante permetrait d'imprimer tous les labels 00466 de la chaine d'appel. 00467 00468 int imprime_labels () 00469 { 00470 char * label; 00471 int i=0; 00472 while ( (label=IdArgUnused())!=0 ) 00473 IdPrintf ("Label %3d : %s : %s", 00474 ++i, label, IdArgValue(label)); 00475 return i; 00476 } 00477 00478 ******************************************************** END DESCRIPTION */ 00479 char * 00480 IdArgUnused ( ) 00481 { 00482 int i ; 00483 for ( i=ArgCount-1; i>0; i-- ){ /* V1.04 */ 00484 if ( ! ArgUsed[i] ) { 00485 IdArgDefined(ArgLab[i]); /* V1.04 */ 00486 return ArgLab[i] ; 00487 } 00488 } 00489 return NULL ; 00490 } 00491 00492 /* FUNCTION DESCRIPTION ************************************************** 00493 00494 IdArgPrintUnusedLabels (fonction) 00495 00496 RESUME: Imprime la liste des labels non utilises. 00497 00498 DESCRIPTION: Imprime la liste des labels non utilises. 00499 00500 SYNTAXE: int nbLabel = IdArgPrintUnusedLabels(); 00501 00502 RETOUR: type : int 00503 role : nombre de labels non utilises. 00504 00505 FICHIER: arg.c 00506 00507 EXEMPLE: 00508 00509 ******************************************************** END DESCRIPTION */ 00510 int IdArgPrintUnusedLabels () 00511 { 00512 char * label; 00513 int i=0; 00514 while ( (label=IdArgUnused())!=0 ) 00515 { if (i==0) IdPrintf ("\nLabels Inutilises\n================\n"); 00516 IdPrintf ("Label : %s = %s\n", label, IdArgValue(label)); 00517 i++; 00518 } 00519 return i; 00520 } 00521 00522 /* FUNCTION DESCRIPTION ************************************************** 00523 * 00524 * IdArgUsage (fonction) 00525 * 00526 * RESUME: Imprime le mode d'emploi d'un programme, et termine l'exec 00527 * 00528 * DESCRIPTION: Imprime le mode d'emploi d'un programme, et termine 00529 * l'execution, en appelant la fonction IdExit(). 00530 * IdArgUsage peut s'utiliser avec START_USAGE et 00531 * FINISH_USAGE (cf.exemple). 00532 * 00533 * SYNTAXE: int retCode =IdArgUsage(char **usage) 00534 * 00535 * RETOUR: type : int (cf. role) 00536 * role : permettre l'utilisation de IdArgUsage() dans le 00537 * corps meme d'une expression typee: 00538 * Exemple : (a=IdArgValue()?1:IdArgusage(usage)) 00539 * 00540 * PARAMETRES: 00541 * nom : usage 00542 * type : char ** 00543 * role : tableau de pointeur vers les lignes de la 00544 * documentation du filtre. La definition de usage 00545 * est facilitee par les macro-commandes predefinies 00546 * dans idarg.h : START_USAGE() et FINISH_USAGE. 00547 * (cf.exemple) 00548 * 00549 * FICHIER: arg.c 00550 * 00551 * EXEMPLE: 00552 * #include <idarg.h> 00553 * 00554 * START_USAGE(usage) //usage : variable static 00555 * "usage : <nom> ...", 00556 * "\007", // erreur = bip(\007) ! 00557 * "affiche cette aide :", 00558 * " programme exemple", 00559 * FINISH_USAGE // fin definition 'usage' 00560 * 00561 * int main() 00562 * { 00563 * IdArgUsage(usage); // affiche la doc 00564 * } 00565 * 00566 ******************************************************** END DESCRIPTION */ 00567 int IdArgUsage(char ** usage_text ) 00568 { 00569 while ( *usage_text ) 00570 IdPrintf("\n%s", *(usage_text++) ); 00571 IdPrintf ( "\n" ) ; 00572 IdExit (1); 00573 return (0); 00574 } 00575 00576 // liberation de la memoire utilisee par ArgInit 00577 int _IdArgFree() 00578 { 00579 int i; 00580 00581 for(i=0;i<ArgCount;i++) 00582 if(ArgLab[i])free(ArgLab[i]); 00583 if(ArgUsed)free(ArgUsed); 00584 if(Appel)free(Appel); 00585 return 0; 00586 } 00587 00588 /* FUNCTION DESCRIPTION ************************************************** 00589 00590 IdArgSave (fonction) 00591 00592 RESUME: sauvegarde une chaine de caract. dans un fichier de parametres 00593 00594 DESCRIPTION: sauvegarde une chaine de caractere dans un fichier de 00595 parametres. Le nom du fichier est celui specifie sur la ligne 00596 d'appel par : PARAMOUT=??? 00597 ou, par defaut, celui donne par ARG_DEFAULT_PARAMOUT 00598 (chaine de caractere definie dans idarg.h). 00599 00600 SYNTAXE: int retCode = IdArgSave ( char *parametre ); 00601 00602 RETOUR: type : int 00603 role : 0 : echec ; !=0 succes. 00604 En cas d'echec, IdErrno vaut l'un des valeurs 00605 suivantes : 00606 IDERR_POINTER_IS_NULL : Pointeur NULL (parametre) 00607 IDERR_OPEN_FAILED : Echec ouverture fichier 00608 00609 PARAMETRES: 00610 nom : parametre 00611 type : char * 00612 role : Chaine de caractere definissant le parametre: 00613 "label=valeur" 00614 00615 FICHIER: arg.c 00616 00617 EXEMPLE: 00618 IdErrno = 0; 00619 IdArgSave("FILEIN=lena128.img"); 00620 IdArgSave("DIM=128"); 00621 IdArgSave("LOG=mylog.log"); 00622 if (IdErrno) IdErrPrintf ("\nEchec de sauvegarde de parametres"); 00623 00624 ******************************************************** END DESCRIPTION */ 00625 /*------------------------------------------------------------------------ 00626 | Role : Sauvegarde dans un fichier de parametres de sortie 00627 | Retour : Type : int 00628 | Role : Indicateur d'erreur: 1 = OK, 0 = AIE AIE AIE 00629 | Parametres : param : char * 00630 | Role : pointeur vers la chaine a sauvegarder 00631 | 00632 +------------------------------------------------------------------------*/ 00633 int 00634 IdArgSave ( param ) 00635 char * param; 00636 { 00637 static int deja = 0; 00638 FILE * fd; 00639 00640 if ( *ArgParamOut == '\0' ) { 00641 return 0; 00642 } 00643 if(deja) { 00644 fd = fopen ( ArgParamOut, "a+" ); 00645 }else{ 00646 deja = 1; 00647 fd = fopen ( ArgParamOut, "w" ); 00648 } 00649 00650 if ( !fd ) return 0; 00651 00652 fprintf ( fd, "%s\n", param ); 00653 fclose ( fd ); 00654 return 1; 00655 }

Generated on Wed Oct 19 09:28:32 2005 for SIMRI3D by doxygen 1.3.7