Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

getutil.c

Go to the documentation of this file.
00001 
00002 /*
00003  *   THIS FILE IS UNDER RCS - DO NOT MODIFY UNLESS YOU HAVE
00004  *   CHECKED IT OUT USING THE COMMAND CHECKOUT.
00005  *
00006  *    $Id: getutil_8c-source.html 2161 2006-05-19 16:55:03Z paulf $
00007  *
00008  *    Revision history:
00009  *     $Log$
00009  *     Revision 1.1  2006/05/19 16:55:02  paulf
00009  *     first inclusion
00009  *
00010  *     Revision 1.3  2000/07/27 16:23:31  lucky
00011  *     Implemented global limits, from earthworm.h, in the sizes of installation ids,
00012  *     message types, ring names, and module names.
00013  *
00014  *     Revision 1.2  2000/07/08 19:49:11  lombard
00015  *     fprintf statment had extra %s format
00016  *
00017  *     Revision 1.1  2000/02/14 18:51:48  lucky
00018  *     Initial revision
00019  *
00020  *
00021  */
00022 
00023 /*
00024  *  getutil.c  functions for looking up shared memory rings,
00025  *             installations, modules, and message types in
00026  *             Earthworm tables.  Given a character-string name,
00027  *             these functions return a numerical value.
00028  *
00029  *             The installation table is set up in the include-file
00030  *             earthworm.h; it is global to all Earthworm installations.
00031  *             Changes to this table require a recompilation of the
00032  *             whole Earthworm tree.
00033  *  
00034  *             The shared memory ring, module, and message type tables
00035  *             are set up in the ascii table file (whose name is stored 
00036  *             in the global variable, TableFile) which resides in the 
00037  *             EW_PARAMS directory.  Changes to this file do not require
00038  *             recompilation.
00039  * 
00040  *  990603:LDD Modified GetUtil_LoadTable to read in installation ids
00041  *             from an ascii file (instead of being defined in earthworm.h)
00042  *             so that installations can be added without recompiling!  LDD
00043  *             
00044  */
00045 
00046 #include <stdio.h>
00047 #include <stdlib.h>
00048 #include <string.h>
00049 #include <earthworm.h>
00050 #include <kom.h>
00051 
00052 /* Table of shared memory ring names & their keys
00053  ************************************************/
00054 #define MAXRING 20
00055 #define RINGLEN MAX_RING_STR
00056 static struct {
00057   long   key;
00058   char   name[RINGLEN+1];
00059 } EW_Ring[MAXRING];
00060 static int Max_Ring = 0;      /* # ring/keys currently in table */
00061 
00062 /* Table of module names and their module_ids
00063  ********************************************/
00064 #define MAXMODID 256
00065 #define MODLEN  MAX_MOD_STR
00066 static struct {
00067   unsigned char id;
00068   char          name[MODLEN+1];
00069 } EW_Module[MAXMODID];
00070 static int Max_ModuleId = 0;  /* # modules currently in table */
00071 
00072 /* Table of message names and their type-values
00073  **********************************************/
00074 #define MAXMSGTYPE 256 
00075 #define MSGLEN     MAX_TYPE_STR 
00076 static struct {
00077   unsigned char type;
00078   char          name[MSGLEN+1];
00079 } EW_Message[MAXMSGTYPE];
00080 static int Max_MessageType = 0;  /* # msg types currently in table */
00081 
00082 /* Table of Installation names and their instids
00083  ***********************************************/
00084 #define MAXINSTID 256
00085 #define INSTLEN   MAX_INST_STR 
00086 static struct {
00087   unsigned char id;
00088   char          name[INSTLEN+1];
00089 } EW_Installation[MAXINSTID];
00090 static int Max_Installation = 0;  /* # installations currently in table */
00091 
00092 #define MAXLEN 255
00093 static char  FullTablePath[MAXLEN+1];
00094 static char *TableFile[] = {"earthworm_global.d","earthworm.d"}; 
00095 static char  nTableFile  = 2;
00096 static int   LoadTables  = 1;   /* Do tables need to be loaded from */
00097                                 /* the TableFile?    1=yes 0=no     */
00098  
00099          /*******************************************************
00100           *                      GetKey                         *
00101           *                                                     *
00102           *  Convert ring name to key number using table        *
00103           *  in TableFile                                       *
00104           *  Return <key number> on success;                    *
00105           *          -1 if the specified ring name is unknown.  *
00106           *******************************************************/
00107 long GetKey( char *ringName )
00108 {
00109    int i;
00110 
00111    if( LoadTables ) {
00112        GetUtil_LoadTable();
00113        LoadTables = 0;
00114    }
00115 
00116 /* Find transport ring name in earthworm.d table
00117  ***********************************************/
00118    for ( i = 0; i < Max_Ring; i++ )
00119       if ( strcmp( EW_Ring[i].name, ringName ) == 0 )
00120          break;
00121 
00122 /* Didn't find ring name in table
00123  ********************************/
00124    if ( i == Max_Ring )
00125    {
00126       fprintf( stderr, "GetKey: Invalid ring name <%s>\n", ringName );
00127       return( -1 );
00128    }
00129 
00130 /* Found it!
00131  ***********/
00132    return( EW_Ring[i].key );
00133 }
00134 
00135 
00136          /*******************************************************
00137           *                   GetLocalInst                      *
00138           *                                                     *
00139           *  Convert the local installation name, set by the    *
00140           *  environment variable EW_INSTALLATION, to a number  *
00141           *  using the table in earthworm.h                     *
00142           *  Return  0 on success;                              *
00143           *         -1 if the environment variable is not       *
00144           *            defined;                                 *
00145           *         -2 if the env. variable has no value        *
00146           *         -3 if the specified installation name is    *
00147           *            not listed in earthworm.h                *
00148           *******************************************************/
00149 int GetLocalInst( unsigned char *localId )
00150 {
00151    char *envInst;
00152 
00153    *localId = 0;
00154 
00155 /* Get the installation name from environment variable EW_INSTALLATION
00156    *******************************************************************/
00157    envInst = getenv( "EW_INSTALLATION" );
00158 
00159    if ( envInst == (char *) NULL )
00160    {
00161       fprintf( stderr,
00162               "GetLocalInst: Environment variable EW_INSTALLATION not defined.\n" );
00163       return( -1 );
00164    }
00165 
00166    if ( *envInst == '\0' )
00167    {
00168       fprintf( stderr, "GetLocalInst: Environment variable EW_INSTALLATION" );
00169       fprintf( stderr, " defined, but has no value.\n" );
00170       return( -2 );
00171    }
00172 
00173    if( LoadTables ) {
00174        GetUtil_LoadTable();
00175        LoadTables = 0;
00176    }
00177 
00178 /* Find the id-value in the table
00179  ********************************/
00180    if ( GetInst( envInst, localId ) < 0 )
00181    {
00182       fprintf( stderr,
00183               "GetLocalInst: Environment variable EW_INSTALLATION" );
00184       fprintf( stderr, " has invalid value <%s>\n", envInst );
00185       return( -3 );
00186    }
00187 
00188    return( 0 );
00189 }
00190 
00191 
00192          /*******************************************************
00193           *                      GetInst                        *
00194           *                                                     *
00195           *  Convert installation name to number using table    *
00196           *  in earthworm.h                                     *
00197           *  Return  0 on success;                              *
00198           *         -1 if the specified installation name is    *
00199           *            unknown.                                 *
00200           *******************************************************/
00201 int GetInst( char *instName, unsigned char *instId )
00202 {
00203    int i;
00204 
00205    if( LoadTables ) {
00206        GetUtil_LoadTable();
00207        LoadTables = 0;
00208    }
00209 
00210 /* Find installation name in earthworm.h table
00211  *********************************************/
00212    for ( i = 0; i < Max_Installation; i++ )
00213       if ( strcmp( EW_Installation[i].name, instName ) == 0 )
00214          break;
00215 
00216 /* Didn't find installation name in table
00217  ****************************************/
00218    if ( i == Max_Installation )
00219    {
00220       fprintf( stderr,
00221               "GetInst: Invalid installation name <%s>\n", instName );
00222      *instId = 0;
00223       return( -1 );
00224    }
00225 
00226 /* Found it!
00227  ***********/
00228   *instId = EW_Installation[i].id;
00229    return( 0 );
00230 }
00231 
00232          /*******************************************************
00233           *                      GetModId                       *
00234           *                                                     *
00235           *  Convert module name to modid number using table    *
00236           *  defined in TableFile                               *
00237           *  Return  0 on success;                              *
00238           *         -1 if the specified module name is unknown. *
00239           *******************************************************/
00240 int GetModId( char *modName, unsigned char *modId )
00241 {
00242    int i;
00243 
00244    if( LoadTables ) {
00245        GetUtil_LoadTable();
00246        LoadTables = 0;
00247    }
00248 
00249 /* Find module name in earthworm.h table
00250  ***************************************/
00251    for ( i = 0; i < Max_ModuleId; i++ )
00252       if ( strcmp( EW_Module[i].name, modName ) == 0 )
00253          break;
00254 
00255 /* Didn't find module name in table
00256  **********************************/
00257    if ( i == Max_ModuleId )
00258    {
00259       fprintf( stderr, "GetModId: Invalid module name <%s>\n", modName );
00260      *modId = 0;
00261       return( -1 );
00262    }
00263 
00264 /* Found it!
00265  ***********/
00266   *modId = EW_Module[i].id;
00267    return( 0 );
00268 }
00269 
00270          /*******************************************************
00271           *                      GetType                        *
00272           *                                                     *
00273           * Convert message-type name to number using table     *
00274           * defined in TableFile                                *
00275           * Return  0 on success;                               *
00276           *        -1 if specified message-type name is unknown *
00277           *******************************************************/
00278 int GetType( char *msgName, unsigned char *msgType )
00279 {
00280    int i;
00281 
00282    if( LoadTables ) {
00283        GetUtil_LoadTable();
00284        LoadTables = 0;
00285    }
00286 
00287 /* Find message-type name in earthworm.h table
00288  *********************************************/
00289    for ( i = 0; i < Max_MessageType; i++ )
00290       if ( strcmp( EW_Message[i].name, msgName ) == 0 )
00291          break;
00292 
00293 /* Didn't find message-type name in table
00294  ****************************************/
00295    if ( i == Max_MessageType )
00296    {
00297       fprintf( stderr,
00298               "GetType: Invalid message-type name <%s>\n", msgName );
00299      *msgType = 0;
00300       return( -1 );
00301    }
00302 
00303 /* Found it!
00304  ***********/
00305   *msgType = EW_Message[i].type;
00306    return( 0 );
00307 }
00308 
00309   /********************************************************************
00310    * GetUtil_LoadTable  loads the ring, module, and message tables    *
00311    *            from ascii files (TableFile) using kom.c functions.   *
00312    *            Exits if any errors are encountered.                  *
00313    ********************************************************************/
00314 void GetUtil_LoadTable( void )
00315 {
00316    int      ncommand;     /* # of required commands you expect to process   */
00317    char     init[10];     /* init flags, one byte for each required command */
00318    int      nmiss;        /* number of required commands that were missed   */
00319    char    *paramdir;    /* points to environment variable, EW_PARAMS      */
00320    char    *com;
00321    char    *str;
00322    int      nfiles, nopen;
00323    int      success;
00324    long     tmpkey;
00325    int      tmp;
00326    int      conflict;
00327    int      i,it;
00328    size_t   len;
00329 
00330 /* Set to zero one init flag for each required command
00331  *****************************************************/
00332    ncommand = 4;
00333    for( i=0; i<ncommand; i++ )  init[i] = 0;
00334 
00335 /* Get the environment variable, EW_PARAMS
00336  *****************************************/
00337    paramdir = getenv( "EW_PARAMS" ); 
00338 
00339    if ( paramdir == (char *)NULL )   
00340    {
00341       printf( "GetUtil_LoadTable: Environment variable EW_PARAMS not defined!" );
00342       printf( " exiting!\n" );
00343       exit(-1);
00344    }
00345    if ( *paramdir == '\0' )
00346    {
00347       printf( "GetUtil_LoadTable: Environment variable EW_PARAMS " );
00348       printf( "defined, but has no value; exiting!\n" );
00349       exit( -1 );
00350    }
00351 
00352 /* Loop thru all interesting Table files
00353  ***************************************/
00354    for( it=0; it<nTableFile; it++ )
00355    {
00356 
00357    /* Build full path to table file
00358     *******************************/
00359       if( strlen(paramdir)+strlen(TableFile[it])+1 > (size_t)MAXLEN )
00360       {
00361          printf("GetUtil_LoadTable: length of EW_PARAMS+TableFile[%d] ",it);
00362          printf("exceeds FullTablePath, MAXLEN=%d; exiting!\n", MAXLEN );
00363          exit( -1 );
00364       }
00365       strcpy( FullTablePath, paramdir  );
00366       len = strlen( FullTablePath );
00367    #ifdef _SOLARIS
00368       if( FullTablePath[len-1] != '/' )   strcat( FullTablePath, "/" );
00369    #else  /* OS/2 or NT */
00370       if( FullTablePath[len-1] != '\\' )  strcat( FullTablePath, "\\" );
00371    #endif
00372       strcat( FullTablePath, TableFile[it] );
00373       /*printf( "path to modid/msgtype table: <%s>\n", FullTablePath );*//*DEBUG*/
00374 
00375    /* Open the main table file
00376     **************************/
00377       nfiles = k_open( FullTablePath );
00378       if( nfiles == 0 ) {
00379            fprintf( stderr,
00380                    "GetUtil_LoadTable: Error opening file <%s>; exiting!\n",
00381                     FullTablePath );
00382            exit( -1 );
00383       }
00384       nopen = nfiles-1;  /* keep track of # open files before TableFile */
00385    
00386    /* Process all command files
00387     ***************************/
00388       while( nfiles > nopen ) /* While there are getutil-files open */
00389       {
00390            while(k_rd())        /* Read next line from active file  */
00391            {
00392                com = k_str();         /* Get the first token from line */
00393 
00394            /* Ignore blank lines & comments
00395             *******************************/
00396                if( !com )           continue;
00397                if( com[0] == '#' )  continue;
00398    
00399            /* Open a nested configuration file
00400             **********************************/
00401                if( com[0] == '@' ) {
00402                   success = nfiles+1;
00403                   nfiles  = k_open(&com[1]);
00404                   if ( nfiles != success ) {
00405                      fprintf( stderr,
00406                              "GetUtil_LoadTable: Error opening file <%s>; exiting!\n",
00407                               &com[1] );
00408                      exit( -1 );
00409                   }
00410                   continue;
00411                }
00412 
00413             /* Process anything else as a command:
00414              *************************************/
00415    
00416             /* Load shared memory ring name/key table
00417              ****************************************/
00418   /*0*/        if( k_its("Ring") ) 
00419                {
00420                 /* see if there's more room in the table */
00421                    if ( Max_Ring+1 >= MAXRING ) {
00422                        fprintf( stderr,
00423                                "GetUtil_LoadTable: Too many <Ring> lines in <%s>",
00424                                 FullTablePath );
00425                        fprintf( stderr, "; max=%d; exiting!\n", (int) MAXRING );
00426                        exit( -1 );
00427                    }
00428                    str    = k_str();    /* get ring name from line */
00429                    tmpkey = k_long();   /* get ring key from line  */
00430 
00431                 /* check the length of the ringname */
00432                    if ( strlen(str) > RINGLEN )
00433                    {
00434                        fprintf( stderr,
00435                                "GetUtil_LoadTable: Ring name <%s> too long in <%s>;"
00436                                " max=%d chars; exiting!\n", str, FullTablePath, RINGLEN );
00437                        exit( -1 );
00438                    }
00439 
00440                 /* look thru current table for duplicate key or name */
00441                    conflict = 0;
00442                    for( i=0; i<Max_Ring; i++ ) {
00443                         if( tmpkey == EW_Ring[i].key ) {
00444                            if( strcmp( EW_Ring[i].name, str ) != 0 ) conflict=1;
00445                            break;
00446                         }
00447                         if( strcmp( EW_Ring[i].name, str ) == 0 ) {
00448                            if( tmpkey != EW_Ring[i].key ) conflict=1;
00449                            break;
00450                         }
00451                    }
00452    
00453                 /* complain if there was a conflict with a previous setting */
00454                    if( conflict ) {
00455                         fprintf( stderr, 
00456                                 "GetUtil_LoadTable: conflict in <%s>, new setting ignored\n", 
00457                                  FullTablePath );
00458                         fprintf( stderr, 
00459                                 "                   original: <Ring %s %ld>\n", 
00460                                  EW_Ring[i].name, EW_Ring[i].key );
00461                         fprintf( stderr, 
00462                                 "                        new: <Ring %s %ld>\n", 
00463                                  str, tmpkey);
00464                    }
00465 
00466                 /* add new entry to table */
00467                    if( i==Max_Ring ) {
00468                       strcpy( EW_Ring[Max_Ring].name, str );
00469                       EW_Ring[Max_Ring].key = tmpkey;
00470                       Max_Ring++;
00471                    }
00472                    init[0] = 1;
00473                }
00474 
00475             /* Enter module name/id table
00476              ****************************/
00477   /*1*/        else if( k_its("Module") ) 
00478                {
00479                 /* see if there's more room in the table */
00480                    if ( Max_ModuleId+1 >= MAXMODID ) {
00481                        fprintf( stderr,
00482                                "GetUtil_LoadTable: Too many <Module> lines in <%s>",
00483                                 FullTablePath );
00484                        fprintf( stderr, "; max=%d; exiting!\n", (int) MAXMODID );
00485                        exit( -1 );
00486                    }
00487                    str = k_str();    /* get module name from line */
00488                    tmp = k_int();    /* get module id from line   */
00489 
00490                 /* check validity of module id */
00491                    if( tmp<0 || tmp>255 ) {
00492                         fprintf( stderr,
00493                                 "GetUtil_LoadTable: Invalid module id <%d> in <%s>",
00494                                  tmp, FullTablePath );
00495                         fprintf( stderr, " (0-255 are valid); exiting!\n" );
00496                         exit( -1 );
00497                    }     
00498 
00499                 /* check the length of the module name */
00500                    if ( strlen(str) > MODLEN )
00501                    {
00502                        fprintf( stderr,
00503                                "GetUtil_LoadTable: Module name <%s> too long in <%s>;"
00504                                " max=%d chars; exiting!\n", str, FullTablePath, MODLEN );
00505                        exit( -1 );
00506                    }
00507 
00508                 /* look thru current table for duplicate key or name */
00509                    conflict = 0;
00510                    for( i=0; i<Max_ModuleId; i++ ) {
00511                         if( tmp == (int)EW_Module[i].id ) {
00512                            if( strcmp( EW_Module[i].name, str ) != 0 ) conflict=1;
00513                            break;
00514                         }
00515                         if( strcmp( EW_Module[i].name, str ) == 0 ) {
00516                            if( tmp != (int)EW_Module[i].id ) conflict=1;
00517                            break;
00518                         }
00519                    }
00520    
00521                 /* complain if there was a conflict with a previous setting */
00522                    if( conflict ) {
00523                         fprintf( stderr, 
00524                                 "GetUtil_LoadTable: conflict in <%s>, new setting ignored\n", 
00525                                  FullTablePath );
00526                         fprintf( stderr, 
00527                                 "                   original: <Module %s %d>\n", 
00528                                  EW_Module[i].name, (int) EW_Module[i].id );
00529                         fprintf( stderr, 
00530                                 "                        new: <Module %s %d>\n", 
00531                                  str, tmp );
00532                    }
00533 
00534                 /* add new entry to table */
00535                    if( i==Max_ModuleId ) {
00536                        strcpy( EW_Module[Max_ModuleId].name, str );
00537                        EW_Module[Max_ModuleId].id = (unsigned char) tmp;
00538                        Max_ModuleId++;
00539                    }
00540                    init[1] = 1;
00541                }
00542 
00543             /* Enter message name/type table
00544              *******************************/
00545   /*2*/        else if( k_its("Message") ) 
00546                {
00547                 /* see if there's more room in the table */
00548                    if ( Max_MessageType+1 >= MAXMSGTYPE ) {
00549                        fprintf( stderr,
00550                                "GetUtil_LoadTable: Too many <Message> lines in <%s>",
00551                                 FullTablePath );
00552                        fprintf( stderr, "; max=%d; exiting!\n", (int) MAXMSGTYPE );
00553                        exit( -1 );
00554                    }
00555                    str = k_str();    /* get message name from line */
00556                    tmp = k_int();    /* get message type from line */
00557    
00558                 /* check validity of module id */
00559                    if( tmp<0 || tmp>255 ) {
00560                         fprintf( stderr,
00561                                 "GetUtil_LoadTable: Invalid message type <%d> in <%s>",
00562                                  tmp, FullTablePath );
00563                         fprintf( stderr, " (0-255 are valid); exiting!\n" );
00564                         exit( -1 );
00565                    }     
00566                    
00567                 /* check the length of the message */
00568                    if ( strlen(str) > MSGLEN )
00569                    {
00570                        fprintf( stderr,
00571                                "GetUtil_LoadTable: Message name <%s> too long in <%s>;"
00572                                " max=%d chars; exiting!\n", str, FullTablePath, MSGLEN );
00573                        exit( -1 );
00574                    }
00575 
00576                 /* look thru current table for duplicate type or name */
00577                    conflict = 0;
00578                    for( i=0; i<Max_MessageType; i++ ) {
00579                         if( tmp == (int)EW_Message[i].type ) {
00580                            if( strcmp( EW_Message[i].name, str ) != 0 ) conflict=1;
00581                            break;
00582                         }
00583                         if( strcmp( EW_Message[i].name, str ) == 0 ) {
00584                            if( tmp != (int)EW_Message[i].type ) conflict=1;
00585                            break;
00586                         }
00587                    }
00588    
00589                 /* complain if there was a conflict with a previous setting */
00590                    if( conflict ) {
00591                         fprintf( stderr, 
00592                                 "GetUtil_LoadTable: conflict in <%s>, new setting ignored\n", 
00593                                  FullTablePath );
00594                         fprintf( stderr, 
00595                                 "                   original: <Message %s %d>\n", 
00596                                  EW_Message[i].name, (int) EW_Message[i].type );
00597                         fprintf( stderr, 
00598                                 "                        new: <Message %s %d>\n", 
00599                                  str, tmp );
00600                    }
00601 
00602                 /* add new entry to table */
00603                    if( i==Max_MessageType ) {
00604                        strcpy( EW_Message[Max_MessageType].name, str );
00605                        EW_Message[Max_MessageType].type = (unsigned char) tmp;
00606                        Max_MessageType++;
00607                    }
00608                    init[2] = 1;
00609                }
00610 
00611             /* Enter installation name/type table
00612              ************************************/
00613   /*3*/        else if( k_its("Installation") ) 
00614                {
00615                 /* see if there's more room in the table */
00616                    if ( Max_Installation+1 >= MAXINSTID ) {
00617                        fprintf( stderr,
00618                                "GetUtil_LoadTable: Too many <Installation> lines in <%s>"
00619                                "; max=%d; exiting!\n", FullTablePath, (int) MAXINSTID );
00620                        exit( -1 );
00621                    }
00622                    str = k_str();    /* get installation name from line */
00623                    tmp = k_int();    /* get instid from line */
00624    
00625                 /* check validity of instid */
00626                    if( tmp<0 || tmp>255 ) {
00627                         fprintf( stderr,
00628                                 "GetUtil_LoadTable: Invalid installation id <%d> in <%s>"
00629                                 " (0-255 are valid); exiting!\n", tmp, FullTablePath );
00630                         exit( -1 );
00631                    }     
00632                    
00633                 /* check the length of the installation name */
00634                    if ( strlen(str) > INSTLEN )
00635                    {
00636                        fprintf( stderr,
00637                                "GetUtil_LoadTable: Installation name <%s> too long in <%s>;"
00638                                " max=%d chars; exiting!\n", str, FullTablePath, INSTLEN );
00639                        exit( -1 );
00640                    }
00641 
00642                 /* look thru current table for duplicate instid or name */
00643                    conflict = 0;
00644                    for( i=0; i<Max_Installation; i++ ) {
00645                         if( tmp == (int)EW_Installation[i].id ) {
00646                            if( strcmp( EW_Installation[i].name, str ) != 0 ) conflict=1;
00647                            break;
00648                         }
00649                         if( strcmp( EW_Installation[i].name, str ) == 0 ) {
00650                            if( tmp != (int)EW_Installation[i].id ) conflict=1;
00651                            break;
00652                         }
00653                    }
00654    
00655                 /* complain if there was a conflict with a previous setting */
00656                    if( conflict ) {
00657                         fprintf( stderr, 
00658                                 "GetUtil_LoadTable: conflict in <%s>, new setting ignored\n", 
00659                                  FullTablePath );
00660                         fprintf( stderr, 
00661                                 "                   original: <Installation %s %d>\n", 
00662                                  EW_Installation[i].name, (int) EW_Installation[i].id );
00663                         fprintf( stderr, 
00664                                 "                        new: <Installation %s %d>\n", 
00665                                  str, tmp );
00666                    }
00667 
00668                 /* add new entry to table */
00669                    if( i==Max_Installation ) {
00670                        strcpy( EW_Installation[Max_Installation].name, str );
00671                        EW_Installation[Max_Installation].id = (unsigned char) tmp;
00672                        Max_Installation++;
00673                    }
00674                    init[3] = 1;
00675                }
00676 
00677             /* Otherwise, it's unknown
00678              *************************/
00679                else  
00680                {
00681                    fprintf( stderr, "GetUtil_LoadTable: <%s> Unknown command in <%s>.\n",
00682                             com, FullTablePath );
00683                    continue;
00684                }
00685 
00686            /* See if there were any errors processing the command
00687             *****************************************************/
00688                if( k_err() ) 
00689                {
00690                   fprintf( stderr,
00691                           "GetUtil_LoadTable: Bad <%s> line in <%s>; exiting!\n",
00692                            com, FullTablePath );
00693                   exit( -1 );
00694                }
00695            }
00696            nfiles = k_close();
00697       }
00698    } /* end-for over all table files */
00699 
00700 /* After all files are closed, check init flags for missed commands
00701  ******************************************************************/
00702    nmiss = 0;
00703    for ( i=0; i<ncommand; i++ )  if( !init[i] ) nmiss++;
00704    if ( nmiss ) {
00705        fprintf( stderr, "GetUtil_LoadTable: ERROR, no "    );
00706        if ( !init[0] )  fprintf( stderr, "<Ring> "         );
00707        if ( !init[1] )  fprintf( stderr, "<Module> "       );
00708        if ( !init[2] )  fprintf( stderr, "<Message> "      );
00709        if ( !init[3] )  fprintf( stderr, "<Installation> " );
00710        fprintf( stderr, "line(s) in file(s) " );
00711        for( it=0; it<nTableFile; it++ ) fprintf( stderr, "<%s> ", TableFile[it] );
00712        fprintf( stderr, "exiting!\n" );
00713        exit( -1 );
00714    }
00715 
00716    return;
00717 }

Generated on Tue May 6 09:16:02 2003 for Earthworm Libs by doxygen1.3-rc3