nco/nco_lst_utl.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netcdf.h>
#include "nco_netcdf.h"
#include "nco.h"
#include "nco_ctl.h"
#include "nco_mmr.h"

Include dependency graph for nco_lst_utl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	indexx (const int lmn_nbr, const int *const arr_in, int *const idx)
void	indexx_alpha (const int lmn_nbr, char *const *const arr_in, int *const idx)
char **	lst_prs_1D (char *const sng_in, const char *const dlm_sng, int *const nbr_lst)
char **	lst_prs_2D (const char *const sng_in, const char *const dlm_sng, int *const nbr_lst)
nm_id_sct *	lst_heapsort (nm_id_sct *lst, const int nbr_lst, const nco_bool ALPHABETIZE_OUTPUT)
int	nco_cmp_chr (const void *val_1, const void *val_2)
int	nco_cmp_int (const void *val_1, const void *val_2)
int	nco_cmp_sng (const void *val_1, const void *val_2)
int	nco_cmp_nm_id_nm (const void *val_1, const void *val_2)
int	nco_cmp_nm_id_id (const void *val_1, const void *val_2)
int	nco_cmp_ptr_unn (const nc_type type, const ptr_unn op1, const ptr_unn op2)
dmn_sct **	nco_dmn_lst_free (dmn_sct **dmn_lst, const int dmn_nbr)
void	nco_lst_comma2hash (char *const rx_sng)
nm_id_sct *	nco_lst_srt_nm_id (nm_id_sct *const lst, const int nbr_lst, const nco_bool ALPHABETIZE_OUTPUT)
nm_id_sct *	nco_nm_id_lst_free (nm_id_sct *nm_id_lst, const int nm_id_nbr)
char **	nco_sng_lst_free (char **sng_lst, const int sng_nbr)
char *	sng_lst_cat (char **const sng_lst, const long lmn_nbr, const char *const dlm_sng)

---

Function Documentation

void indexx (  const int  lmn_nbr, const int *const   arr_in, int *const   idx )

Definition at line 18 of file nco_lst_utl.c. References EXIT_FAILURE, nco_exit(), and prg_nm_get(). { /* Purpose: Stub for Numerical Recipes-compatible indexx() routine */ long foo=sizeof(lmn_nbr)+sizeof(arr_in)+sizeof(idx); /* CEWI */ foo++; /* CEWI */ (void)fprintf(stdout,"%s: ERROR indexx() routine should not be called\n",prg_nm_get()); nco_exit(EXIT_FAILURE); } /* end indexx() */

void indexx_alpha (  const int  lmn_nbr, char *const *const   arr_in, int *const   idx )

Definition at line 31 of file nco_lst_utl.c. References EXIT_FAILURE, nco_exit(), and prg_nm_get(). { /* Purpose: Stub for Numerical Recipes-compatible indexx_alpha() routine */ long foo=sizeof(lmn_nbr)+sizeof(arr_in)+sizeof(idx); /* CEWI */ foo++; /* CEWI */ (void)fprintf(stdout,"%s: ERROR indexx_alpha() routine should not be called\n",prg_nm_get()); nco_exit(EXIT_FAILURE); } /* end indexx() */

nm_id_sct* lst_heapsort (  nm_id_sct *  lst, const int  nbr_lst, const nco_bool  ALPHABETIZE_OUTPUT )

Definition at line 44 of file nco_lst_utl.c. References nco_free(), and nco_malloc(). { /* Purpose: Sort extraction lists numerically or alphabetically Routine is deprecated in favor of nco_lst_srt_nm_id() which uses system qsort() lst_heapsort drives Numerical Recipes indexx-style routines Advantage of indexx* routines is they return list of sorted indices, allowing original list to be untouched and sorted indices to be used. Disadvantage of indexx* routines is they employ 1-based indexing, and are non-free. This driver routine IS free, and maintained for future reference Main purpose of routine is to handle bookkeeping of copying structure elements to be sorted and rearranging original list on basis of sorted indices */ int *srt_idx; /* List to store sorted key map */ int idx; /* Counting index */ nm_id_sct *lst_tmp; /* Temporary copy of original extraction list */ srt_idx=(int *)nco_malloc(nbr_lst*sizeof(int)); lst_tmp=(nm_id_sct *)nco_malloc(nbr_lst*sizeof(nm_id_sct)); (void)memcpy((void *)lst_tmp,(void *)lst,nbr_lst*sizeof(nm_id_sct)); /* indexx() and relatives assume "one-based" arrays Use pointer arithmetic to spoof zero-based arrays, i.e., xtr_nm[0] in calling routine becomes xtr_nm[1] in sorting routine */ if(ALPHABETIZE_OUTPUT){ /* Alphabetize list by variable name This produces easy-to-read screen output with ncks */ char **xtr_nm; xtr_nm=(char **)nco_malloc(nbr_lst*sizeof(char *)); for(idx=0;idx<nbr_lst;idx++) xtr_nm[idx]=lst[idx].nm; /* Replace with free (speech) index_alpha() replacement */ /*(void)index_alpha(nbr_lst,xtr_nm-1,srt_idx-1);*/ xtr_nm=(char **)nco_free(xtr_nm); }else{ /* Heapsort list by variable ID This theoretically allows fastest I/O when creating output file */ int *xtr_id; xtr_id=(int *)nco_malloc(nbr_lst*sizeof(int)); for(idx=0;idx<nbr_lst;idx++) xtr_id[idx]=lst[idx].id; /* Replace with free (speech) indexx() replacement */ /* (void)indexx(nbr_lst,xtr_id-1,srt_idx-1);*/ xtr_id=(int *)nco_free(xtr_id); } /* end else */ /* indexx and relatives employ "one-based" arrays Thus min(srt_idx) == 1 and max(srt_idx) == nbr_lst */ for(idx=0;idx<nbr_lst;idx++){ lst[idx].id=lst_tmp[srt_idx[idx]-1].id; lst[idx].nm=lst_tmp[srt_idx[idx]-1].nm; } /* end loop over idx */ lst_tmp=(nm_id_sct *)nco_free(lst_tmp); srt_idx=(int *)nco_free(srt_idx); return lst; } /* end lst_heapsort() */

char** lst_prs_1D (  char *const   sng_in, const char *const   dlm_sng, int *const   nbr_lst )

Definition at line 106 of file nco_lst_utl.c. References dbg_lvl_get(), and nco_malloc(). { /* Purpose: Create list of strings from given string and arbitrary delimiter Routine is often called with system memory, e.g., with strings from command line arguments whose memory was allocated by shell or by getopt(). Conservative policy would be, therefore, to never modify input string However, we are safe if any modifications do not extend input string Thus this routine is allowed to replace delimiter strings by NULs NB: Function takes single string as input and returns "list of strings" However, this list of strings was not obtained by malloc'ing each string It was obtained by inserting delimiters in a single string Hence do not try to separately free() each member of list of strings Contrasting lst_prs_1D() to successor lst_prs_2D(): lst_prs_2D() creates two-dimensional output string list, i.e., list of pointers to separately malloc()'d buffers lst_prs_2D() does not modify input lst_prs_2D() output list should be free'd by nco_sng_lst_free() lst_prs_1D() creates one-dimensional string list by inserting NULs into single buffer lst_prs_1D() modifies input (by inserting NULs) lst_prs_1D() output list may be free'd by nco_free() */ /* Number of list members is always one more than number of delimiters, e.g., foo,,3, has 4 arguments: "foo", "", "3" and "". A delimiter without an argument is valid syntax to indicate default argument Therefore a storage convention is necessary to indicate default argument was selected Either NULL or '\0' can be used without requiring additional flag NULL is not printable, but is useful as a logical flag since its value is False On the other hand, '\0', the empty string, can be printed but is not as useful as a flag Currently, NCO implements former convention, where default selections are set to NULL */ char **lst; /* O [sng] Array of list elements */ char *sng_in_ptr; int dlm_lng; int idx; /* Delimiter must be NUL-terminated (a string) so we may find its length */ dlm_lng=strlen(dlm_sng); /* Increment dummy pointer instead of actual sng_in pointer while searching for delimiters */ sng_in_ptr=sng_in; /* First element does not require preceding delimiter */ *nbr_lst=1; /* Count list members */ while((sng_in_ptr=strstr(sng_in_ptr,dlm_sng))){ sng_in_ptr+=dlm_lng; (*nbr_lst)++; } /* end while */ lst=(char **)nco_malloc(*nbr_lst*sizeof(char *)); sng_in_ptr=sng_in; lst[0]=sng_in; idx=0; while((sng_in_ptr=strstr(sng_in_ptr,dlm_sng))){ /* NUL-terminate previous arg */ *sng_in_ptr='\0'; sng_in_ptr+=dlm_lng; lst[++idx]=sng_in_ptr; } /* end while */ /* Default list member is assumed when two delimiters are adjacent to eachother, i.e., when length of string between delimiters is 0. If list ends with delimiter, last element of list is also assumed to be default list member */ /* This loop sets default list members to NULL */ for(idx=0;idx<*nbr_lst;idx++) if(strlen(lst[idx]) == 0) lst[idx]=NULL; if(dbg_lvl_get() == 5){ (void)fprintf(stderr,"lst_prs_1d() reports %d elements in list delimited by \"%s\"\n",*nbr_lst,dlm_sng); for(idx=0;idx<*nbr_lst;idx++) (void)fprintf(stderr,"lst[%d] = %s\n",idx,(lst[idx] == NULL) ? "NULL" : lst[idx]); (void)fprintf(stderr,"\n"); (void)fflush(stderr); } /* end debug */ return lst; } /* end lst_prs_1D() */

char** lst_prs_2D (  const char *const   sng_in, const char *const   dlm_sng, int *const   nbr_lst )

Definition at line 192 of file nco_lst_utl.c. References dbg_lvl_get(), nco_free(), and nco_malloc(). Referenced by main(), nco_lmt_prs(), nco_lmt_udu_cnv(), and nco_prs_aed_lst(). { /* Purpose: Create list of strings from given string and arbitrary delimiter Algorithm recursively copies all text up to delimiter into new string and then appends new string to output list Output list has no delimiter strings Contrasting lst_prs_2D() to predecessor lst_prs_1D(): lst_prs_2D() creates two-dimensional output string list, i.e., list of pointers to separately malloc()'d buffers lst_prs_2D() does not modify input lst_prs_2D() output list should be free'd by nco_sng_lst_free() lst_prs_1D() creates one-dimensional string list by inserting NULs into single buffer lst_prs_1D() modifies input (by inserting NULs) lst_prs_1D() output list may be free'd by nco_free() */ /* Number of list members is always one more than number of delimiters, e.g., foo,,3, has 4 arguments: "foo", "", "3" and "". A delimiter without an argument is valid syntax to indicate default argument Therefore a storage convention is necessary to indicate default argument was selected Either NULL or '\0' can be used without requiring additional flag NULL is not printable, but is useful as a logical flag since its value is False On the other hand, '\0', the empty string, can be printed but is not as useful as a flag Currently, NCO implements former convention, where default selections are set to NULL */ char **sng_lst_out; /* O [sng] Array of list elements */ char *sng_in_cpy; char *dlm_ptr_crr; char *sng_out_srt; int dlm_lng; int idx; /* Delimiter must be NUL-terminated (a string) so we may find its length */ dlm_lng=strlen(dlm_sng); /* Create duplicate to search, modify, copy, and free */ sng_in_cpy=(char *)strdup(sng_in); /* Increment temporary dummy pointer dlm_ptr_crr in strstr() search loops */ dlm_ptr_crr=sng_in_cpy; /* First element does not require preceding delimiter */ *nbr_lst=1; /* Count list members */ while((dlm_ptr_crr=strstr(dlm_ptr_crr,dlm_sng))){ dlm_ptr_crr+=dlm_lng; (*nbr_lst)++; } /* end while */ /* Calling routine has responsibility to free this memory */ sng_lst_out=(char **)nco_malloc(*nbr_lst*sizeof(char *)); dlm_ptr_crr=sng_in_cpy; sng_out_srt=sng_in_cpy; idx=0; while((dlm_ptr_crr=strstr(sng_out_srt,dlm_sng))){ /* This loop brackets and grabs "previous" arguments Grab final argument after loop */ /* NUL-terminate previous arg */ *dlm_ptr_crr='\0'; /* Calling routine has responsibility to free this memory */ sng_lst_out[idx++]=(char *)strdup(sng_out_srt); sng_out_srt=dlm_ptr_crr+dlm_lng; } /* end while */ /* Grab final argument after last delimiter This also handles case of string with no delimiters */ sng_lst_out[idx++]=(char *)strdup(sng_out_srt); /* Assume default list member when two delimiters are adjacent to eachother, i.e., when length of string between delimiters is 0. If list ends with delimiter, last element of list is also assumed to be default list member */ /* This loop sets default list members to NULL */ for(idx=0;idx<*nbr_lst;idx++) if(strlen(sng_lst_out[idx]) == 0) sng_lst_out[idx]=NULL; if(dbg_lvl_get() == 5){ (void)fprintf(stderr,"lst_prs_2D() reports %d elements in list delimited by \"%s\"\n",*nbr_lst,dlm_sng); for(idx=0;idx<*nbr_lst;idx++) (void)fprintf(stderr,"sng_lst_out[%d] = %s\n",idx,(sng_lst_out[idx] == NULL) ? "NULL" : sng_lst_out[idx]); (void)fprintf(stderr,"\n"); (void)fflush(stderr); } /* end debug */ /* Free duplicate of sng_in */ sng_in_cpy=(char *)nco_free(sng_in_cpy); return sng_lst_out; } /* end lst_prs_2D() */

int nco_cmp_chr (  const void *  val_1, const void *  val_2 )

Definition at line 285 of file nco_lst_utl.c. { /* Purpose: Compare two characters Function is suitable for argument to ANSI C qsort() routine in stdlib.h Code based on responses to my comp.lang.c thread 20040101 */ const char * const val_1_cp=(char *)val_1; const char * const val_2_cp=(char *)val_2; return *val_1_cp < *val_2_cp ? -1 : (*val_1_cp > *val_2_cp); /* Alternative one-liner: return (*val_1_cp > *val_2_cp) - (*val_1_cp < *val_2_cp); */ } /* end nco_cmp_chr() */

int nco_cmp_int (  const void *  val_1, const void *  val_2 )

Definition at line 300 of file nco_lst_utl.c. Referenced by nco_var_dmn_rdr_mtd(). { /* Purpose: Compare two integers Function is suitable for argument to ANSI C qsort() routine in stdlib.h Code based on responses to my comp.lang.c thread 20040101 */ const int * const val_1_ip=(int *)val_1; const int * const val_2_ip=(int *)val_2; return *val_1_ip < *val_2_ip ? -1 : (*val_1_ip > *val_2_ip); /* Alternative one-liner: return (*val_1_ip > *val_2_ip) - (*val_1_ip < *val_2_ip); */ } /* end nco_cmp_int() */

int nco_cmp_nm_id_id (  const void *  val_1, const void *  val_2 )

Definition at line 340 of file nco_lst_utl.c. Referenced by nco_lst_srt_nm_id(). { /* Purpose: Compare two nm_id_sct's by ID structure member NB: This function uses a method which is, in general, unsafe By performing casts and then subracting, we are subject to overflow conditions should integer values be close to INT_MAX or INT_MIN. However, we know that nm_id_sct.id values are always small Thus we use this slightly unsafe method in order to show that comparison function may be written (albeit unsafely) in one line. */ return (*(nm_id_sct const *)val_1).id-(*(nm_id_sct const *)val_2).id; } /* end nco_cmp_nm_id_nm() */

int nco_cmp_nm_id_nm (  const void *  val_1, const void *  val_2 )

Definition at line 331 of file nco_lst_utl.c. Referenced by nco_lst_srt_nm_id(). { /* Purpose: Compare two nm_id_sct's by name structure member */ return strcmp((*(nm_id_sct const *)val_1).nm,(*(nm_id_sct const *)val_2).nm); } /* end nco_cmp_nm_id_nm() */

int nco_cmp_ptr_unn (  const nc_type  type, const ptr_unn  op1, const ptr_unn  op2 )

Definition at line 355 of file nco_lst_utl.c. References NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, NC_SHORT, nco_dfl_case_nc_type_err(), and type. { /* Purpose: Compare values of two scalar pointer unions of same type Function is almost suitable for argument to ANSI C qsort() routine in stdlib.h Like strcmp(), this routine returns <,=,> zero iff op1 <,=,> op2 Routine based on nco_cmp_int() Note that only first value of pointer unions is compared */ switch(type){ case NC_FLOAT: {const float * const op1_fp=op1.fp; const float * const op2_fp=op2.fp; return *op1_fp < *op2_fp ? -1 : (*op1_fp > *op2_fp);} break; case NC_DOUBLE: break; {const double * const op1_dp=op1.dp; const double * const op2_dp=op2.dp; return *op1_dp < *op2_dp ? -1 : (*op1_dp > *op2_dp);} case NC_SHORT: break; {const short * const op1_sp=op1.sp; const short * const op2_sp=op2.sp; return *op1_sp < *op2_sp ? -1 : (*op1_sp > *op2_sp);} case NC_INT: break; {const nco_int * const op1_lp=op1.lp; const nco_int * const op2_lp=op2.lp; return *op1_lp < *op2_lp ? -1 : (*op1_lp > *op2_lp);} case NC_CHAR: break; {const nco_char * const op1_cp=op1.cp; const nco_char * const op2_cp=op2.cp; return *op1_cp < *op2_cp ? -1 : (*op1_cp > *op2_cp);} case NC_BYTE: break; {const nco_byte * const op1_bp=op1.bp; const nco_byte * const op2_bp=op2.bp; return *op1_bp < *op2_bp ? -1 : (*op1_bp > *op2_bp);} default: nco_dfl_case_nc_type_err(); break; } /* end switch */ /* Some compilers, e.g., SGI cc, need return statement to end non-void functions */ return 0; } /* end nco_cmp_ptr_unn() */

int nco_cmp_sng (  const void *  val_1, const void *  val_2 )

Definition at line 315 of file nco_lst_utl.c. { /* Purpose: Compare two strings Function is suitable for argument to ANSI C qsort() routine in stdlib.h http://www.eskimo.com/~scs/C-faq/q13.8.html describes sorting strings: Arguments to qsort()'s comparison function are pointers to objects being sorted, i.e., pointers to pointers to chars strcmp(), however, accepts simple pointers to char Therefore, strcmp() cannot be used directly as comparison function for qsort() This wrapper casts input values to simple char pointers, calls strcmp(), and feeds results back to qsort() */ return strcmp(*(char * const *)val_1,*(char * const *)val_2); } /* end nco_cmp_sng() */

dmn_sct** nco_dmn_lst_free (  dmn_sct **  dmn_lst, const int  dmn_nbr )

Definition at line 224 of file nco_dmn_utl.c. References nco_dmn_free(), and nco_free(). Referenced by main(). { /* Threads: Routine is thread safe and calls no unsafe routines */ /* Purpose: Free all memory associated with dynamically allocated dimension structure list */ int idx; for(idx=0;idx<dmn_nbr;idx++){ dmn_lst[idx]=nco_dmn_free(dmn_lst[idx]); } /* end loop over idx */ /* Free structure pointer last */ dmn_lst=(dmn_sct **)nco_free(dmn_lst); return dmn_lst; } /* end nco_dmn_lst_free() */

void nco_lst_comma2hash (  char *const   rx_sng  )

Definition at line 400 of file nco_lst_utl.c. References False, and True. Referenced by main(). { /* Purpose: Convert commas within braces to hashes within braces in regular expressions Required for handling corner cases in wildcarding regular expressions NB: Usually this code operates on system memory (e.g., optarg) so be very careful not to overwrite ends of strings */ char *cp; char *cp_cnv=NULL; /* [ptr] Location of comma following open brace */ bool openbrace=False; /* [flg] Open brace has been found */ cp=rx_sng; /* Loop over each character in string until first NUL encountered */ while(*cp){ /* Find open brace */ if(*cp=='{') openbrace=True; if(openbrace && *cp==',') cp_cnv=cp; /* Find close brace */ if(*cp=='}'){ /* Change comma following open brace, if any, to hash */ if(cp_cnv) *cp_cnv='#'; /* Reset comma location following open brace */ openbrace=False; /* Reset indicator and location of comma following open brace */ cp_cnv=NULL; } /* endif */ /* Increment position in regular expression */ cp++; } /* end while character is not NUL */ } /* end nco_lst_comma2hash() */

nm_id_sct* nco_lst_srt_nm_id (  nm_id_sct *const   lst, const int  nbr_lst, const nco_bool  ALPHABETIZE_OUTPUT )

Definition at line 431 of file nco_lst_utl.c. References nco_cmp_nm_id_id(), and nco_cmp_nm_id_nm(). Referenced by main(). { /* Purpose: Sort extraction lists numerically or alphabetically */ if(ALPHABETIZE_OUTPUT){ /* Alphabetize list by variable name This produces easy-to-read screen output with ncks */ qsort(lst,(size_t)nbr_lst,sizeof(lst[0]),nco_cmp_nm_id_nm); }else{ /* Heapsort list by variable ID This theoretically allows fastest I/O when creating output file */ qsort(lst,(size_t)nbr_lst,sizeof(lst[0]),nco_cmp_nm_id_id); } /* end else */ return lst; } /* end nco_lst_srt_nm_id() */

nm_id_sct* nco_nm_id_lst_free (  nm_id_sct *  nm_id_lst, const int  nm_id_nbr )

Definition at line 450 of file nco_lst_utl.c. References nco_free(), and nm_id_sct::nm. Referenced by main(), and nco_var_lst_sub(). { /* Threads: Routine is thread safe and calls no unsafe routines */ /* Purpose: Free all memory associated with dynamically allocated name-ID structure list */ int idx; for(idx=0;idx<nm_id_nbr;idx++){ nm_id_lst[idx].nm=(char *)nco_free(nm_id_lst[idx].nm); } /* end loop over idx */ /* Free structure pointer last */ nm_id_lst=(nm_id_sct *)nco_free(nm_id_lst); return nm_id_lst; } /* end nco_nm_id_lst_free() */

char** nco_sng_lst_free (  char **  sng_lst, const int  sng_nbr )

Definition at line 519 of file nco_lst_utl.c. References nco_free(). Referenced by main(), and nco_prs_aed_lst(). { /* Threads: Routine is thread safe and calls no unsafe routines */ /* Purpose: Free all memory associated with dynamically allocated string list */ int idx; for(idx=0;idx<sng_nbr;idx++){ sng_lst[idx]=(char *)nco_free(sng_lst[idx]); } /* end loop over idx */ /* Free structure pointer last */ sng_lst=(char **)nco_free(sng_lst); return sng_lst; } /* end nco_sng_lst_free() */

char* sng_lst_cat (  char **const   sng_lst, const long  lmn_nbr, const char *const   dlm_sng )

Definition at line 469 of file nco_lst_utl.c. References EXIT_FAILURE, nco_exit(), nco_free(), nco_malloc(), and prg_nm_get(). Referenced by nco_prs_aed_lst(). { /* Purpose: Join list of strings together into one string Delete original string list Elements of input list should all be NUL-terminated strings Elements with value NUL are interpreted as strings of zero length */ char *sng; /* Output string */ int dlm_lng; long lmn; long sng_sz=0L; /* NB: sng_sz get incremented */ if(lmn_nbr == 1L){ sng=(char *)strdup(sng_lst[0]); goto cln_and_xit; } /* lmn_nbr != 1L */ /* Delimiter must be NUL-terminated (a string) so strlen() works */ if(dlm_sng == NULL){ (void)fprintf(stdout,"%s: ERROR sng_lst_cat() reports delimiter string is NULL\n",prg_nm_get()); nco_exit(EXIT_FAILURE); } /* end if */ dlm_lng=strlen(dlm_sng); /* List elements must be NUL-terminated (strings) so strlen() works */ for(lmn=0L;lmn<lmn_nbr;lmn++) sng_sz+=(sng_lst[lmn] == NULL) ? 0L : strlen(sng_lst[lmn])+dlm_lng; /* Add one for NUL byte */ sng=(char *)nco_malloc(sizeof(char)*(sng_sz+1L)); /* NUL-terminate string for safety */ sng[0]='\0'; for(lmn=0L;lmn<lmn_nbr;lmn++){ /* List elements must be NUL-terminated (strings) so strcat() works */ sng=(sng_lst[lmn] == NULL) ? sng : strcat(sng,sng_lst[lmn]); if(lmn != lmn_nbr-1L && dlm_lng != 0) sng=strcat(sng,dlm_sng); } /* end loop over lmn */ /* Jump here if only one string */ cln_and_xit: for(lmn=0L;lmn<lmn_nbr;lmn++){ if(sng_lst[lmn] != NULL) sng_lst[lmn]=(char *)nco_free(sng_lst[lmn]); } /* end loop over lmn */ return sng; } /* end sng_lst_cat() */

---