void ctb_permccrd ( char *tblnam, char *dirsym, Permclust_t *pc, int *iret ) /************************************************************************ * ctb_permccrd * * * * This routine will read the permanent clustered county table into a * * structure. * * * * ctb_permccrd ( tblnam, dirsym, pc, iret ) * * * * Input parameters: * * *tblnam char Data type table name * * *dirsym char Directory * * * * Output parameters: * * *pc Permclust_t Perm. clustered cnty structure * * *iret int Return code * ** * * Log: * * A. Hardy/NCEP 10/04 copied from ctb_ccrd * * A. Hardy/NCEP 1/05 Added creation of virtual cluster combos* * & added error check on 1st cst_split * ***********************************************************************/ { FILE *ftbl; char buff[256], pcname[32], *next; int ii, jj, ij, in, inx, numclust, fips[50], nfips, len, ier, ierr; int ik, kk, ll, nn, itotal, srchfip, inum, ivfips, cfips[20]; Boolean found, match; static Permclust_t vpc, tpc; /*---------------------------------------------------------------------*/ *iret = 0; /* * Open the table. */ ftbl = cfl_tbop ( tblnam, dirsym, iret ); if ( *iret != 0 ) { tpc.nclust = 0; return; } /* * Get number of valid table entries. */ cfl_tbnr( ftbl, &numclust, &ier ); if ( numclust != 0 ) { /* * Allocate the structure elements. */ tpc.nclust = numclust; tpc.clust = (PCinfo *) malloc( numclust * sizeof(PCinfo) ); } else { /* * Problem opening table file; set error code and return. */ cfl_clos( ftbl, &ier ); *iret = -2; return; } rewind ( ftbl ); /* * For every valid table entry, read in, parse, put in structure */ ii = 0; while ( ii < numclust ) { cfl_trln( ftbl, sizeof(buff), buff, &ier ); if ( ier == 0 ) { next = cst_split ( buff, '|', 4, tpc.clust[ii].pcwfo, &ier ); if ( ier == 0 ) { next = cst_split ( next, '|', 32, pcname, &ier ); tpc.clust[ii].pcname = (char *)malloc( (strlen(pcname)+1) * sizeof(char) ); strcpy ( tpc.clust[ii].pcname, pcname ); cst_rmbl ( next, next, &len, &ier ); cst_ilst ( next, '+', IMISSD, sizeof(fips)/sizeof(fips[0]), fips, &nfips, &ier ); tpc.clust[ii].npc = nfips; tpc.clust[ii].pc = (int *)malloc( nfips * sizeof(int) ); for ( jj = 0; jj < nfips; jj++ ) { tpc.clust[ii].pc[jj] = fips[jj]; } } else { ierr = 3; er_wmsg ( "CTB", &ierr, buff, &ier, 3, strlen (buff) ); } ii++; } } cfl_clos ( ftbl, &ier ); /* * Create virtual clusters. * Allocate the structure elements. */ vpc.nclust = 0; vpc.clust = (PCinfo *) malloc( (numclust*4) * sizeof(PCinfo) ); inum = vpc.nclust; ii = 0; /* * Loop over all perm clusters. */ while ( ii < numclust ) { for ( jj = 1;jj < tpc.clust[ii].npc; jj++ ) { found = False; srchfip = tpc.clust[ii].pc[jj]; /* * Compare search fip value to the other 1st fips codes. * Search permanent table first. */ ij = 0; while ( (!found) && (ij < numclust ) ) { if ( srchfip == tpc.clust[ij].pc[0] ) { found = True; } ij++; } /* * Search virtual cluster table next. */ ij = 0; while ( (!found) && (ij < vpc.nclust ) ) { if ( srchfip == vpc.clust[ij].pc[0] ) { found = True; } ij++; } /* * Didn't find a cluster group with search fip as first key. * Find all cluster groups in perm. table with this key in * the cluster groups. Create a new virtual cluster entry. */ if ( !found ) { cfips[0] = srchfip; ik = 0; /* Loop over rest of current clustered combo fips * and store the codes temporarily. */ for ( ij = 0; ij < tpc.clust[ii].npc;ij++ ) { if ( tpc.clust[ii].pc[ij] != srchfip ) { ik++; cfips[ik] = tpc.clust[ii].pc[ij]; } } /* Set the number of virtual fips codes we have so far*/ ivfips = ik+1; /* * Check rest of perm clusters combox for srchfip. * Start with the next perm cluster combo. */ inx = ii + 1; match = False; /* loop over rest of combo clusters */ for ( kk= inx; kk < numclust; kk++ ) { /* loop over number of counties in each cluster */ for ( ll = 0; ll < tpc.clust[kk].npc; ll++ ) { /* look for a match in a cluster */ if ( tpc.clust[kk].pc[ll] == srchfip ) { /* store all new codes in cfips array */ for ( nn = 0; nn < tpc.clust[kk].npc; nn++ ) { /* loop over current cluster array, store one's we don't have*/ in = 0; while ( (in < ivfips ) && ( !match) ) { if ( tpc.clust[kk].pc[nn] == cfips[in] ) { match = True; } in++; } /* didn't find fips in cfips array, keep it */ if ( !match ) { cfips[ivfips] = tpc.clust[kk].pc[nn]; ivfips++; } match = False; } } } } /* * Put temporary pcname, pcwfo, npc and fips array into * virtual perm clust. combos. * Increment number of virtual fip cluster combos */ strcpy ( vpc.clust[inum].pcwfo, tpc.clust[ii].pcwfo ); vpc.clust[inum].pcname = (char *)malloc( (strlen(pcname)+1) * sizeof(char) ); /* * Store the number of fips codes and the code numbers */ vpc.clust[inum].npc = ivfips; vpc.clust[inum].pc = (int *)malloc( ivfips * sizeof(int) ); for ( ij= 0; ij < ivfips; ij++ ) { vpc.clust[inum].pc[ij] = cfips[ij]; } vpc.nclust++; inum++; } /* (!found) loop */ } /* for jj loop */ ii++; } /* while ii loop */ /* * Fill out output permanent cluster structure. * Allocate the structure elements. */ itotal = numclust + vpc.nclust; pc->nclust = itotal; pc->clust = (PCinfo *) malloc( itotal * sizeof(PCinfo) ); ii = 0; /* * Write out permanent table cluster combos first. */ while ( ii < numclust ) { strcpy (pc->clust[ii].pcwfo, tpc.clust[ii].pcwfo); pc->clust[ii].pcname = (char *)malloc( (strlen(tpc.clust[ii].pcname)+1) * sizeof(char) ); strcpy ( pc->clust[ii].pcname, tpc.clust[ii].pcname ); pc->clust[ii].npc = tpc.clust[ii].npc; pc->clust[ii].pc = (int *)malloc( tpc.clust[ii].npc * sizeof(int) ); for ( jj = 0; jj < pc->clust[ii].npc; jj++ ) { pc->clust[ii].pc[jj] = tpc.clust[ii].pc[jj]; } ii++; } /* * Write out virtual cluster combos next. */ jj = 0; while ( ii < pc->nclust ) { strcpy (pc->clust[ii].pcwfo, vpc.clust[jj].pcwfo); pc->clust[ii].pcname = (char *)malloc( 12 * sizeof(char) ); sprintf ( pc->clust[ii].pcname, "VClust %d", jj+1 ); pc->clust[ii].npc = vpc.clust[jj].npc; pc->clust[ii].pc = (int *)malloc( vpc.clust[jj].npc * sizeof(int) ); for ( ij = 0; ij < pc->clust[ii].npc; ij++ ) { pc->clust[ii].pc[ij] = vpc.clust[jj].pc[ij]; } ii++; jj++; } }
void ctb_g2rdlvl ( char *tbname, G2lvls *lvltbl, int *iret ) /************************************************************************ * ctb_g2rdlvl * * * * This routine will read a GRIB2 vertical coordinate level/layer * * table into an array of structures. * * The table is allocated locally and a pointer to the new table is * * passed back to the user in argument lvltbl. The user is responsible * * for freeing this memory, when the table is no longer needed, by * * free(lvltbl.info) * * * * ctb_g2rdlvl ( tbname, lvltbl, iret ) * * * * Input parameters: * * *tbname char Filename of the table to read * * * * Output parameters: * * *lvltbl G2lvls Pointer to list of table entries * * *iret int Return code * * 0 = Successful * * -1 = Could not open * * -2 = Could not get count of of table entries * * -52 = Memory allocation failure (G_NMEMRY) * ** * * Log: * * S. Gilbert/NCEP 11/04 Modified from ctb_g2rdcntr to read a * * GRIB2 level/layer Table. * * S. Emmerson/Unidata 12/15 Added check for malloc() returning NULL * ***********************************************************************/ { FILE *fp = NULL; int n, blen, id1, id2, scale, nr, ier; char buffer[256]; char name[34], abbrev[5], unit[21]; /*---------------------------------------------------------------------*/ *iret = G_NORMAL; /* * Open the table. If not found return an error. */ fp = cfl_tbop( tbname, "grid", &ier); if ( fp == NULL || ier != 0 ) { if (fp) fclose(fp); *iret = -1; return; } cfl_tbnr(fp, &nr, &ier); if ( ier != 0 || nr == 0 ) { *iret = -2; cfl_clos(fp, &ier); return; } lvltbl->info = (G2level *)malloc((size_t)nr*sizeof(G2level)); if (lvltbl->info == NULL) { *iret = G_NMEMRY; cfl_clos(fp, &ier); return; } lvltbl->nlines = nr; n = 0; while ( n < nr ) { cfl_trln( fp, 256, buffer, &ier ); if ( ier != 0 ) { free(lvltbl->info); break; } cst_lstr ( buffer, &blen, &ier ); sscanf( buffer, "%11d %11d %33c %20c %4s %11d", &id1, &id2, name, unit, abbrev, &scale); name[33] = '\0'; unit[20] = '\0'; abbrev[4] = '\0'; lvltbl->info[n].id1=id1; lvltbl->info[n].id2=id2; strcpy(lvltbl->info[n].name, name); strcpy(lvltbl->info[n].unit, unit); strcpy(lvltbl->info[n].abbrev, abbrev); lvltbl->info[n].scale=scale; n++; } cfl_clos(fp, &ier); }
void ctb_g2read ( int *iret ) /************************************************************************ * ctb_g2read * * * * This routine will read a grib2 table into an array of structures. * * * * ctb_g2read ( iret ) * * * * Input parameters: * * * * Output parameters: * * *iret int Return code * ** * * Log: * * m.gamazaychikov/SAIC 5/03 * * m.gamazaychikov/SAIC 5/03 added parameter pdtnmbr to the table * * M. Li/SAIC 4/04 added hzremap, and direction * ***********************************************************************/ { FILE *fp = NULL; int n, nr, blen, ier; char buffer[256]; int disc, cat, parm, pdtn, scl, ihzrmp, idrct; char name[33], unts[21], gname[13]; float msng; /*---------------------------------------------------------------------*/ *iret = G_NORMAL; if ( Gr2Readin == 1 ) return; /* * Open the table. If not found return an error. */ fp = cfl_tbop( G2VARS_TBL, "grid", &ier); if ( fp == NULL || ier != 0 ) { if (fp) fclose(fp); *iret = -1; return; } cfl_tbnr(fp, &nr, &ier); if ( ier != 0 || nr == 0 ) { *iret = -2; cfl_clos(fp, &ier); return; } Gr2Tbl.info = (G2Vinfo *)malloc((size_t)nr*sizeof(G2Vinfo)); n = 0; while ( n < nr ) { cfl_trln( fp, 256, buffer, &ier ); if ( ier != 0 ) break; cst_lstr ( buffer, &blen, &ier ); if ( blen > NCOLN ) { sscanf( buffer, "%12d %12d %12d %12d %32c %20c %s %12d %f %12d %12d", &disc, &cat, &parm, &pdtn, name, unts, gname, &scl, &msng, &ihzrmp, &idrct ); } else { sscanf( buffer, "%12d %12d %12d %12d %32c %20c %s %12d %20f", &disc, &cat, &parm, &pdtn, name, unts, gname, &scl, &msng); ihzrmp = 0; idrct = 0; } name[32] = '\0'; unts[20] = '\0'; Gr2Tbl.info[n].discpln=disc; Gr2Tbl.info[n].categry=cat; Gr2Tbl.info[n].paramtr=parm; Gr2Tbl.info[n].pdtnmbr=pdtn; strcpy(Gr2Tbl.info[n].name, name); strcpy(Gr2Tbl.info[n].units, unts); strcpy(Gr2Tbl.info[n].gemname, gname); Gr2Tbl.info[n].scale=scl; Gr2Tbl.info[n].missing=msng; Gr2Tbl.info[n].hzremap = ihzrmp; Gr2Tbl.info[n].direction = idrct; n++; } cfl_clos(fp, &ier); Gr2Tbl.nlines = n; Gr2Readin = 1; }
void shp_rdException ( int *iret ) /************************************************************************ * shp_rdException * * * * This function reads the shape exception table. * * * * void shp_rdException ( iret ) * * * * Input parameters: * * * * Output parameters: * * *iret int Return value * * -1 - Unable to open table * * -2 - Information missing * * * ** * * Log: * * H. Zeng/SAIC 07/07 created * ***********************************************************************/ { int num, ilat, ilon, idx, ier; char tagstr1[128], tagstr2[128], tagstr3[128], tagstr4[128]; char tagstr5[128], tagstr6[128], tagstr7[128], buff[256]; FILE *fp; /*---------------------------------------------------------------------*/ *iret = 0; /* * Open the shape exception table. If not found, return an error. */ fp = cfl_tbop("shpexception.tbl", "stns", &ier); if ( fp == NULL || ier != 0 ) { *iret = -1; return; } /* * Count # of records on the table. */ cfl_tbnr (fp, &_numShpException, &ier); /* * Allocate space for _shpException. */ _shpException = (ShpException_t*) malloc( sizeof(ShpException_t) * _numShpException ); /* * Scan table line-by-line. */ idx = 0; rewind (fp); while ( !feof(fp) ) { cfl_trln(fp, sizeof(buff), buff, &ier); if ( ier != 0 ) continue; num = sscanf (buff, "%s %s %s %s %s %s %s", tagstr1, tagstr2, tagstr3, tagstr4, tagstr5, tagstr6, tagstr7); if ( num != 7 ) continue; if ( sscanf (tagstr6, "%d", &ilat) == 1 && sscanf (tagstr7, "%d", &ilon) == 1 ) { strcpy ( _shpException[idx].id, tagstr1); _shpException[idx].fips = 0; sscanf (tagstr2, "%lu", &(_shpException[idx].fips)); _shpException[idx].clat = ilat * 0.01; _shpException[idx].clon = ilon * 0.01; idx++; } } /* the end of while (... */ cfl_clos(fp, &ier); }
void ctb_g2rdvar ( char *tbname, G2vars_t *vartbl, int *iret ) /************************************************************************ * ctb_g2rdvar * * * * This routine will read a GRIB2 Parameter * * table into an array of structures. * * The table is allocated locally and a pointer to the new table is * * passed back to the user in argument vartbl. The user is resposible * * for freeing this memory, when the table is no longer needed, by * * free(vartbl.info) * * * * ctb_g2rdvar ( tbname, vartbl, iret ) * * * * Input parameters: * * *tbname char Filename of the table to read * * * * Output parameters: * * *vartbl G2vars_t Pointer to list of table entries * * *iret int Return code * * 0 = Successful * * -1 = Could not open * * -2 = Could not get count of * * of table entries. * ** * * Log: * * S. Gilbert/NCEP 11/04 Modified from ctb_g2rdcntr to read a * * GRIB2 Parameter Table. * ***********************************************************************/ { FILE *fp = NULL; int n, blen, nr, ier; char buffer[256]; char name[33], gname[13], unts[21]; int disc, cat, parm, pdtn, scl, ihzrmp, idrct; float msng; const int ncoln=110; /*---------------------------------------------------------------------*/ *iret = G_NORMAL; /* * Open the table. If not found return an error. */ fp = cfl_tbop( tbname, "grid", &ier); if ( fp == NULL || ier != 0 ) { if (fp) fclose(fp); *iret = -1; return; } cfl_tbnr(fp, &nr, &ier); if ( ier != 0 || nr == 0 ) { *iret = -2; cfl_clos(fp, &ier); return; } vartbl->info = malloc((size_t)nr*sizeof(G2Vinfo)); if (vartbl->info == NULL) { *iret = -1; cfl_clos(fp, &ier); return; } vartbl->nlines = nr; n = 0; while ( n < nr ) { cfl_trln( fp, 256, buffer, &ier ); if ( ier != 0 ) { free(vartbl->info); break; } cst_lstr ( buffer, &blen, &ier ); if ( blen > ncoln ) { sscanf( buffer, "%12d %12d %12d %12d %32c %20c %12s %12d %20f %12d %12d", &disc, &cat, &parm, &pdtn, name, unts, gname, &scl, &msng, &ihzrmp, &idrct ); } else { sscanf( buffer, "%12d %12d %12d %12d %32c %20c %12s %12d %20f", &disc, &cat, &parm, &pdtn, name, unts, gname, &scl, &msng); ihzrmp = 0; idrct = 0; } name[32] = '\0'; unts[20] = '\0'; gname[12] = '\0'; vartbl->info[n].discpln=disc; vartbl->info[n].categry=cat; vartbl->info[n].paramtr=parm; vartbl->info[n].pdtnmbr=pdtn; strcpy(vartbl->info[n].name, name); strcpy(vartbl->info[n].units, unts); strcpy(vartbl->info[n].gemname, gname); vartbl->info[n].scale=scl; vartbl->info[n].missing=msng; vartbl->info[n].hzremap = ihzrmp; vartbl->info[n].direction = idrct; n++; } cfl_clos(fp, &ier); }
void tb_nidsdb ( char *prdnam, char *res, int *iprod, int *iret ) /************************************************************************ * tb_nidsdb * * * * This subroutine returns information about the radar image from the * * NIDS product table file. * * * * void tb_nidsdb ( prdnam, res, iprod, iret ) * * * * Input parameters: * * *prdnam char Product name * * *res char Data resolution in km * * * * Output parameters: * * *iprod int NIDS product ID * * *iret int Return code * * 0 = normal return * * +3 = No entry found for image * * -7 = Could not open imtyp table* ** * * Log: * * m.gamazaychikov/CWS 01/10 Created * ***********************************************************************/ { int found, ier, ier1, loglev=2; float ares; char *grp="TB", line[128]; size_t ii; static int nr; static FILE *fptr=NULL; static Radtbl_t *radtbl=NULL; /*---------------------------------------------------------------------*/ /* * Initialize output variables. */ *iprod = 0; *iret = 33; /* Not found */ cst_crnm ( res, &ares, &ier ); /* * If table not yet read into memory; open the image type table file. */ if ( fptr == NULL ) { fptr = cfl_tbop ( NIDPRD_TBL, "rad", &ier ); if ( ier != 0 ) { *iret = -7; er_lmsg (&loglev, grp, iret, NIDPRD_TBL, &ier1, strlen(grp), strlen(NIDPRD_TBL)); return; } /* * Load the structure. */ cfl_tbnr (fptr, &nr, &ier ); if ( ier != 0 || nr == 0 ) { *iret = -7; er_lmsg (&loglev, grp, iret, NIDPRD_TBL, &ier1, strlen(grp), strlen(NIDPRD_TBL)); cfl_clos(fptr, &ier); return; } G_MALLOC(radtbl, Radtbl_t, nr, "tb_nidsdb: radtbl"); for (ii = 0; ii < (size_t)nr; ii++ ) { /* * Read the next record. */ cfl_trln ( fptr, 127, line, &ier ); if ( ier == 0 ) { sscanf(line,"%s %s %i %i %s %f %s", radtbl[ii].type, radtbl[ii].name, &radtbl[ii].prod, &radtbl[ii].lvls, radtbl[ii].units, &radtbl[ii].res, radtbl[ii].desc); } } /* end of 'for (ii = 0; ii < nr; ii++ )' */ cfl_clos(fptr, &ier); } /* end of 'if ( *fptr == NULL )' */ ii = 0; found = G_FALSE; /* * Retrieve the product ID for the specified * product name and the resolution. */ while ( !found && ii < (size_t)nr ) { //if ( strstr (radtbl[ii].name, prdnam) != NULL ) { if ( strcmp (prdnam, radtbl[ii].name) == 0 ) { if ( G_DIFF(ares, radtbl[ii].res) ) { found = G_TRUE; *iprod = radtbl[ii].prod; *iret = G_NORMAL; } } ii++; } }
void ctb_g2rdcntr ( char *tbname, G2wmocntrs *cntrtbl, int *iret ) /************************************************************************ * ctb_g2rdcntr * * * * This routine will read a WMO originating Center table into an array * * of structures. * * The table is allocated locally and a pointer to the new table is * * passed back to the user in argument cntrtbl. The user is resposible * * for freeing this memory, when the table is no longer needed, by * * free(cntrtbl.info) * * * * ctb_g2rdcntr ( tbname, cntrtbl, iret ) * * * * Input parameters: * * *tbname char Filename of the table to read * * * * Output parameters: * * *cntrtbl G2wmocenter Pointer to list of table entries* * *iret int Return code * * 0 = Successful * * -1 = Could not open * * -1 = Could not get count of * * of teble entries. * ** * * Log: * * m.gamazaychikov/SAIC 5/03 * * m.gamazaychikov/SAIC 5/03 added parameter pdtnmbr to the table * * M. Li/SAIC 4/04 added hzremap, and direction * * S. Gilbert/NCEP 11/04 Modified from ctb_g2read to read a WMO * * Originating Center Table. * ***********************************************************************/ { FILE *fp; int n, blen, id, nr, ier; char buffer[256]; char name[65], abbrev[9]; /*---------------------------------------------------------------------*/ *iret = G_NORMAL; /* * Open the table. If not found return an error. */ fp = cfl_tbop( tbname, "grid", &ier); if ( fp == NULL || ier != 0 ) { *iret = -1; return; } cfl_tbnr(fp, &nr, &ier); if ( ier != 0 || nr == 0 ) { *iret = -2; cfl_clos(fp, &ier); return; } cntrtbl->info = (G2wmocenter *)malloc((size_t)nr*sizeof(G2wmocenter)); cntrtbl->nlines = nr; n = 0; while ( n < nr ) { cfl_trln( fp, 256, buffer, &ier ); if ( ier != 0 ) break; cst_lstr ( buffer, &blen, &ier ); sscanf( buffer, "%d %64c %s", &id, name, abbrev); name[64] = '\0'; abbrev[8] = '\0'; cntrtbl->info[n].id=id; strcpy(cntrtbl->info[n].name, name); strcpy(cntrtbl->info[n].abbrev, abbrev); n++; } cfl_clos(fp, &ier); }
void NxmCursor_rdTbls ( void ) /************************************************************************ * NxmCursor_rdTbls * * * * This function reads the cursor type table and cursor reference table * * * * void NxmCursor_rdTbls() * * * * Input parameters: * * Output parameters: * * Return parameters: * * NONE * * * ** * * Log: * * H. Zeng/EAI 04/00 initial coding * ***********************************************************************/ { int ii, jj, nr = 0, ignore, iret; char buffer[256]; FILE *fp; /*---------------------------------------------------------------------*/ /* * Read cursorsymb.tbl */ _cursymbTbl.nsymb = 0; fp = cfl_tbop( CURSORSYMB_TBL, "config", &iret ); if ( iret == 0 ) { cfl_tbnr( fp, &nr, &iret); } if ( nr == 0 ) { fclose(fp); } else { _cursymbTbl.nsymb = nr; _cursymbTbl.cursymbs = (cursorsymb_t*) malloc((size_t)_cursymbTbl.nsymb*sizeof(cursorsymb_t)); ii = 0; while (ii < _cursymbTbl.nsymb) { cfl_trln(fp, 256, buffer, &iret); if ( iret == 0 ) { sscanf(buffer, "%s %d", _cursymbTbl.cursymbs[ii].X_name, &(_cursymbTbl.cursymbs[ii].id) ); } ii++; } fclose(fp); } /* * Read cursortyp.tbl */ _curtypTbl.ntyp = 0; fp = cfl_tbop( CURSORTYPE_TBL, "config", &iret ); if ( iret == 0 ) { cfl_tbnr( fp, &nr, &iret); } if ( nr == 0 ) { fclose(fp); } else { _curtypTbl.ntyp = nr; _curtypTbl.curtyps = (cursortyp_t*) malloc((size_t)_curtypTbl.ntyp*sizeof(cursortyp_t)); ii = 0; while (ii < _curtypTbl.ntyp) { cfl_trln(fp, 256, buffer, &iret); if ( iret == 0 ) { sscanf(buffer, "%s %s", _curtypTbl.curtyps[ii].ext_name, _curtypTbl.curtyps[ii].int_name ); /* * By default id value is -1 which means it is a pixmap cursor. */ _curtypTbl.curtyps[ii].id = -1; if( strstr(_curtypTbl.curtyps[ii].int_name, "XC_") != NULL ) { for(jj=0; jj<_cursymbTbl.nsymb; jj++) { if(strcmp(_curtypTbl.curtyps[ii].int_name, _cursymbTbl.cursymbs[jj].X_name)==0 ) { _curtypTbl.curtyps[ii].id = _cursymbTbl.cursymbs[jj].id; break; } } /* the end of for() */ } /* the end of if(strstr...) */ } ii++; } fclose(fp); } /* * Read cursorref.tbl */ _currefTbl.nref = 0; fp = cfl_tbop( CURSORREF_TBL, "config", &iret ); if ( iret == 0 ) { cfl_tbnr( fp, &nr, &iret); } if ( nr == 0 ) { fclose(fp); } else { _currefTbl.nref = nr; _currefTbl.currefs = (cursorref_t*) malloc((size_t)_currefTbl.nref*sizeof(cursorref_t)); ii = 0; while (ii < _currefTbl.nref) { cfl_trln(fp, 256, buffer, &iret); if ( iret == 0 ) { sscanf(buffer, "%d %s %s %s", &ignore, _currefTbl.currefs[ii].ref_name, _currefTbl.currefs[ii].typ_name, _currefTbl.currefs[ii].color ); } ii++; } fclose(fp); } free(_cursymbTbl.cursymbs); }
void ctb_hfread ( int *iret ) /************************************************************************ * ctb_pfread * * * * This function reads the info from the Hershey Fonts tables. * * * * The Hershey Font coordinates are encoded using the ASCII characters. * * Each character pair represents a coordinate in the drawing system * * with 'R,R' as the origin. To get the coordinate values, subtract * * 'R' from the given character. For example, the pair 'SB' corresponds * * to (+1,-16). * * * * ctb_hfread ( iret ) * * * * Input parameters: * * * * Output parameters: * * *iret int Return code * * -1 = cannot open or read table* * -12 = cannot allocate memory * ** * * Log: * * S. Jacobs/NCEP 10/07 Created * * T. Piper/SAIC 03/08 Replaced cmm functions with Macros * ***********************************************************************/ { FILE *fp; char buffer[256], av[6]; int ii, nr, ier, ifont, ier2, jj, kk, nf, one = 1; font_tbl_name_t tbl[] = { {"hfont03.tbl", 3}, {"hfont23.tbl", 23}, {"hfont04.tbl", 4}, {"hfont14.tbl", 14}, {"hfont24.tbl", 24}, {"hfont34.tbl", 34} }; /*---------------------------------------------------------------------*/ *iret = G_NORMAL; /* * Allocate space for all of the font structures. */ nf = sizeof(tbl)/sizeof(tbl[0]); G_MALLOC ( _hfontTbl, HF_font_t, nf, "ctb_hfread - _hfontTbl"); if ( _hfontTbl == NULL ) { *iret = -12; return; } _nhfont = 0; for ( ifont = 0; ifont < nf; ifont++ ) { /* * Read the font table and add entries into the structure. */ nr = 0; fp = cfl_tbop ( tbl[ifont].table_name, "hershey", &ier ); if ( ier == 0 ) { cfl_tbnr ( fp, &nr, &ier); } if ( nr == 0 ) { cfl_clos ( fp, &ier ); *iret = -1; return; } _hfontTbl[ifont].font_code = tbl[ifont].font_num; /* * Allocate space for the characters. */ G_MALLOC ( _hfontTbl[ifont].character, HF_char_t, nr, "ctb_hfread - _hfontTbl[ifont].character"); if ( _hfontTbl[ifont].character == NULL ) { cfl_clos ( fp, &ier ); *iret = -12; return; } /* * Read table entries into the structure. */ ii = 0; /* Read the next line from the file */ cfl_trln ( fp, 256, buffer, &ier ); /* * Process the file while there is no error and * the end of the file has not been reached. */ while ( ier >= 0 && ier != 4 ) { if ( ier == 0 ) { G_MALLOC ( _hfontTbl[ifont].character[ii].point_code, char, strlen(buffer)+1, " ctb_hfread - _hfontTbl[ifont].character[ii].point_code"); if ( _hfontTbl[ifont].character[ii].point_code == NULL ) { cfl_clos ( fp, &ier ); *iret = -12; return; } strcpy ( _hfontTbl[ifont].character[ii].point_code, buffer ); /* Get the character ASCII code */ cst_ncpy ( av, &(buffer[0]), 5, &ier2 ); cst_numb ( av, &(_hfontTbl[ifont].character[ii].ascii_val), &ier2 ); /* * Get the number of points for the character * (The number in the file includes the X min and max, * so subtract one) */ cst_ncpy ( av, &(buffer[5]), 3, &ier2 ); cst_numb ( av, &(_hfontTbl[ifont].character[ii].npts), &ier2 ); (_hfontTbl[ifont].character[ii].npts)--; /* Get the X min and max */ _hfontTbl[ifont].character[ii].xmin = buffer[8] - 'R'; _hfontTbl[ifont].character[ii].xmax = buffer[9] - 'R'; /* Get the coordinates, if the number of points is > 0 */ if ( _hfontTbl[ifont].character[ii].npts > 0 ) { G_MALLOC ( _hfontTbl[ifont].character[ii].point, HF_point_t, _hfontTbl[ifont].character[ii].npts, " ctb_hfread - _hfontTbl[ifont].character[ii].point"); if ( _hfontTbl[ifont].character[ii].point == NULL ) { cfl_clos ( fp, &ier ); *iret = -12; return; } /* * Check for " R", which denotes a "pen up". * If there is a pen up code, set the points to missing. * Otherwise, decode the coordinate values. */ kk = 10; for ( jj = 0; jj < _hfontTbl[ifont].character[ii].npts; jj++ ) { if ( strncmp ( &(buffer[kk]), " R", 2 ) == 0 ) { _hfontTbl[ifont].character[ii].point[jj].x = -99; _hfontTbl[ifont].character[ii].point[jj].y = -99; kk += 2; } else { _hfontTbl[ifont].character[ii].point[jj].x = buffer[kk] - 'R'; kk++; _hfontTbl[ifont].character[ii].point[jj].y = buffer[kk] - 'R'; kk++; } } } /* * If there are no character codes, * set one point at the origin */ else { G_MALLOC ( _hfontTbl[ifont].character[ii].point, HF_point_t, one, " ctb_hfread - _hfontTbl[ifont].character[ii].point"); if ( _hfontTbl[ifont].character[ii].point == NULL ) { cfl_clos ( fp, &ier ); *iret = -12; return; } _hfontTbl[ifont].character[ii].point[0].x = 0; _hfontTbl[ifont].character[ii].point[0].y = 0; } ii++; } /* Read the next line from the file */ cfl_trln ( fp, 256, buffer, &ier ); } /* Set the number of characters for the font */ _hfontTbl[ifont].numchr = ii; /* Close the font table */ cfl_clos ( fp, &ier ); /* Increase the count for the number of fonts */ _nhfont++; }
void clo_rdstn ( Stn_t *stn, char *fnm, char *alias, int *iret ) /************************************************************************ * clo_rdstn * * * * This function loads station table information into the standard * * station information structure. * * * * clo_rdstn ( stn, fnm, alias, iret ) * * * * Input parameters: * * *stn Stn_t station structure to fill * * *fnm char station file name to use * * *alias char alias of table name * * * * Output parameters: * * *iret int Return code * * -1 - Unable to open table * * -2 - No records in table * * -3 - Invalid type of point * ** * * Log: * * D.W.Plummer/NCEP 1/99 From (now replaced) cloancrd.c * * D.W.Plummer/NCEP 3/99 Add sorting index * * T. Piper/GSC 3/99 Corrected prolog * * D.W.Plummer/NCEP 4/99 Updated for MARINE & COASTAL types * * D.W.Plummer/NCEP 7/00 Updated for consolidated CLO structures * * D.W.Plummer/NCEP 8/00 Added conversion to upper case of desc * * T. Piper/GSC 6/01 Initialized c10 * * R. Tian/SAIC 8/03 Increased c10 size. * * B. Yin/SAIC 5/04 Modified code to handle blank id. * * B. Yin/SAIC 7/04 Modified for various break point types * * m.gamazaychikov 01/05 Corrected for proper column reading * ***********************************************************************/ { int counter, ier; char buff[120]; FILE *fp; char id[9], desc[64], state[8], cntry[8], c10[21]="\0", tmpstr[128]; int stnm, lat, lon, numstn, elv, pri; /*---------------------------------------------------------------------*/ *iret = G_NORMAL; /* * Open the table. If not found return an error. */ fp = (FILE *)cfl_tbop(fnm, "stns", &ier); if ( fp == NULL || ier != 0 ) { stn->nstn = 0; *iret = -1; return; } cfl_tbnr( fp, &numstn, &ier ); if ( numstn != 0 ) { /* * Allocate the structure elements. */ stn->nstn = numstn; stn->station = (SInfo_t *) malloc( (size_t)numstn * sizeof(SInfo_t) ); } else { cfl_clos(fp, &ier); *iret = -2; return; } rewind(fp); if ( strncmp( alias, "TCA_BKPTS_", 10 ) == 0 ) { clo_rdtcabkpts( stn, fp, alias, numstn, iret ); cfl_clos(fp, &ier); return; } /* * For every line in the station table list, read in the record, * parse out the fields, and add to the structure. */ counter = 0; while ( counter < numstn ) { cfl_trln(fp, sizeof(buff), buff, &ier); if ( ier == 0 ) { id[ 0 ] = '\0'; desc[ 0 ] = '\0'; state[ 0 ] = '\0'; cntry[ 0 ] = '\0'; c10[ 0 ] = '\0'; stnm = 0; lat = 9999; lon = 9999; elv = 9999; pri = 9999; strncpy( tmpstr, buff, 8 ); tmpstr[8]='\0'; sscanf( tmpstr, "%s", id ); stn->station[counter].id = (char *)malloc(sizeof(char)*strlen(id)+1); strcpy( stn->station[counter].id, id ); strncpy( tmpstr, &buff[9], 6 ); tmpstr[6]='\0'; sscanf( tmpstr, "%d", &stnm ); stn->station[counter].nm = stnm; strncpy( tmpstr, &buff[16], 32 ); tmpstr[32]='\0'; sscanf( tmpstr, "%s", desc ); stn->station[counter].desc = (char *)malloc(sizeof(char)*strlen(desc)+1); cst_lcuc ( desc, stn->station[counter].desc, &ier ); strncpy( tmpstr, &buff[49], 2 ); tmpstr[2]='\0'; sscanf( tmpstr, "%s", state ); stn->station[counter].state=(char *)malloc(sizeof(char)*strlen(state)+1); strcpy( stn->station[counter].state, state ); strncpy( tmpstr, &buff[52], 2 ); tmpstr[2]='\0'; sscanf( tmpstr, "%s", cntry ); stn->station[counter].cntry=(char *)malloc(sizeof(char)*strlen(cntry)+1); strcpy( stn->station[counter].cntry, cntry ); strncpy( tmpstr, &buff[55], 21 ); tmpstr[21]='\0'; sscanf( tmpstr, "%d %d %d %d", &lat, &lon, &elv, &pri ); stn->station[counter].lat = (float)lat / 100.0F; stn->station[counter].lon = (float)lon / 100.0F; stn->station[counter].elv = elv; stn->station[counter].pri = pri; strncpy( tmpstr, &buff[76], 20 ); tmpstr[20]='\0'; sscanf( tmpstr, "%s", c10 ); stn->station[counter].col10 = (char *)malloc(sizeof(char)*strlen(c10)+1); strcpy( stn->station[counter].col10, c10 ); counter++; } } cfl_clos(fp, &ier); }