URL
https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk
Subversion Repositories openrisc_2011-10-31
[/] [openrisc/] [tags/] [or1ksim/] [or1ksim-0.5.0rc1/] [argtable2/] [argtable2.c] - Rev 355
Go to most recent revision | Compare with Previous | Blame | View Log
/********************************************************************* This file is part of the argtable2 library. Copyright (C) 1998-2001,2003-2008 Stewart Heitmann sheitmann@users.sourceforge.net The argtable2 library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. **********************************************************************/ /* config.h must be included before anything else */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include <stdlib.h> #include <string.h> #include <stdlib.h> #include <ctype.h> #ifdef HAVE_STRINGS_H #include <strings.h> #endif #ifdef HAVE_GETOPT_H #include <getopt.h> #else #include "./getopt.h" #endif #ifdef HAVE_UNISTD_H #include <unistd.h> #endif #include "argtable2.h" #include "./getopt.h" static void arg_register_error(struct arg_end *end, void *parent, int error, const char *argval) { /* printf("arg_register_error(%p,%p,%d,%s)\n",end,parent,error,argval); */ if (end->count < end->hdr.maxcount) { end->error[end->count] = error; end->parent[end->count] = parent; end->argval[end->count] = argval; end->count++; } else { end->error[end->hdr.maxcount-1] = ARG_ELIMIT; end->parent[end->hdr.maxcount-1] = end; end->argval[end->hdr.maxcount-1] = NULL; } } /* * Return index of first table entry with a matching short option * or -1 if no match was found. */ static int find_shortoption(struct arg_hdr **table, char shortopt) { int tabindex; for(tabindex=0; !(table[tabindex]->flag&ARG_TERMINATOR); tabindex++) { if (table[tabindex]->shortopts && strchr(table[tabindex]->shortopts,shortopt)) return tabindex; } return -1; } struct longoptions { int getoptval; int noptions; struct option *options; }; #ifndef NDEBUG /* Commented out by JPB for GCC compliance static void dump_longoptions(struct longoptions* longoptions) { int i; printf("getoptval = %d\n", longoptions->getoptval); printf("noptions = %d\n", longoptions->noptions); for (i=0; i<longoptions->noptions; i++) { printf("options[%d].name = \"%s\"\n", i, longoptions->options[i].name); printf("options[%d].has_arg = %d\n", i, longoptions->options[i].has_arg); printf("options[%d].flag = %p\n", i, longoptions->options[i].flag); printf("options[%d].val = %d\n", i, longoptions->options[i].val); } } */ #endif static struct longoptions* alloc_longoptions(struct arg_hdr **table) { struct longoptions *result; size_t nbytes; int noptions = 1; size_t longoptlen = 0; int tabindex; /* * Determine the total number of option structs required * by counting the number of comma separated long options * in all table entries and return the count in noptions. * note: noptions starts at 1 not 0 because we getoptlong * requires a NULL option entry to terminate the option array. * While we are at it, count the number of chars required * to store private copies of all the longoption strings * and return that count in logoptlen. */ tabindex=0; do { const char *longopts = table[tabindex]->longopts; longoptlen += (longopts?strlen(longopts):0) + 1; while (longopts) { noptions++; longopts = strchr(longopts+1,','); } }while(!(table[tabindex++]->flag&ARG_TERMINATOR)); /*printf("%d long options consuming %d chars in total\n",noptions,longoptlen);*/ /* allocate storage for return data structure as: */ /* (struct longoptions) + (struct options)[noptions] + char[longoptlen] */ nbytes = sizeof(struct longoptions) + sizeof(struct option)*noptions + longoptlen; result = (struct longoptions*)malloc(nbytes); if (result) { int option_index=0; char *store; result->getoptval=0; result->noptions = noptions; result->options = (struct option*)(result + 1); store = (char*)(result->options + noptions); for(tabindex=0; !(table[tabindex]->flag&ARG_TERMINATOR); tabindex++) { const char *longopts = table[tabindex]->longopts; while(longopts && *longopts) { char *storestart = store; /* copy progressive longopt strings into the store */ while (*longopts!=0 && *longopts!=',') *store++ = *longopts++; *store++ = 0; if (*longopts==',') longopts++; /*fprintf(stderr,"storestart=\"%s\"\n",storestart);*/ result->options[option_index].name = storestart; result->options[option_index].flag = &(result->getoptval); result->options[option_index].val = tabindex; if (table[tabindex]->flag & ARG_HASOPTVALUE) result->options[option_index].has_arg = 2; else if (table[tabindex]->flag & ARG_HASVALUE) result->options[option_index].has_arg = 1; else result->options[option_index].has_arg = 0; option_index++; } } /* terminate the options array with a zero-filled entry */ result->options[option_index].name = 0; result->options[option_index].has_arg = 0; result->options[option_index].flag = 0; result->options[option_index].val = 0; } /*dump_longoptions(result);*/ return result; } static char* alloc_shortoptions(struct arg_hdr **table) { char *result; size_t len = 2; int tabindex; /* determine the total number of option chars required */ for(tabindex=0; !(table[tabindex]->flag&ARG_TERMINATOR); tabindex++) { struct arg_hdr *hdr = table[tabindex]; len += 3 * (hdr->shortopts?strlen(hdr->shortopts):0); } result = malloc(len); if (result) { char *res = result; /* add a leading ':' so getopt return codes distinguish */ /* unrecognised option and options missing argument values */ *res++=':'; for(tabindex=0; !(table[tabindex]->flag&ARG_TERMINATOR); tabindex++) { struct arg_hdr *hdr = table[tabindex]; const char *shortopts = hdr->shortopts; while(shortopts && *shortopts) { *res++ = *shortopts++; if (hdr->flag & ARG_HASVALUE) *res++=':'; if (hdr->flag & ARG_HASOPTVALUE) *res++=':'; } } /* null terminate the string */ *res=0; } /*printf("alloc_shortoptions() returns \"%s\"\n",(result?result:"NULL"));*/ return result; } /* return index of the table terminator entry */ static int arg_endindex(struct arg_hdr **table) { int tabindex=0; while (!(table[tabindex]->flag&ARG_TERMINATOR)) tabindex++; return tabindex; } static void arg_parse_tagged(int argc, char **argv, struct arg_hdr **table, struct arg_end *endtable) { struct longoptions *longoptions; char *shortoptions; int copt; /*printf("arg_parse_tagged(%d,%p,%p,%p)\n",argc,argv,table,endtable);*/ /* allocate short and long option arrays for the given opttable[]. */ /* if the allocs fail then put an error msg in the last table entry. */ longoptions = alloc_longoptions(table); shortoptions = alloc_shortoptions(table); if (!longoptions || !shortoptions) { /* one or both memory allocs failed */ arg_register_error(endtable,endtable,ARG_EMALLOC,NULL); /* free anything that was allocated (this is null safe) */ free(shortoptions); free(longoptions); return; } /*dump_longoptions(longoptions);*/ /* reset getopts internal option-index to zero, and disable error reporting */ optind = 0; opterr = 0; /* fetch and process args using getopt_long */ while( (copt=getopt_long(argc,argv,shortoptions,longoptions->options,NULL)) != -1) { /* printf("optarg='%s'\n",optarg); printf("optind=%d\n",optind); printf("copt=%c\n",(char)copt); printf("optopt=%c (%d)\n",optopt, (int)(optopt)); */ switch(copt) { case 0: { int tabindex = longoptions->getoptval; void *parent = table[tabindex]->parent; /*printf("long option detected from argtable[%d]\n", tabindex);*/ if (optarg && optarg[0]==0 && (table[tabindex]->flag & ARG_HASVALUE)) { /* printf(": long option %s requires an argument\n",argv[optind-1]); */ arg_register_error(endtable,endtable,ARG_EMISSARG,argv[optind-1]); /* continue to scan the (empty) argument value to enforce argument count checking */ } if (table[tabindex]->scanfn) { int errorcode = table[tabindex]->scanfn(parent,optarg); if (errorcode!=0) arg_register_error(endtable,parent,errorcode,optarg); } } break; case '?': /* * getopt_long() found an unrecognised short option. * if it was a short option its value is in optopt * if it was a long option then optopt=0 */ switch (optopt) { case 0: /*printf("?0 unrecognised long option %s\n",argv[optind-1]);*/ arg_register_error(endtable,endtable,ARG_ELONGOPT,argv[optind-1]); break; default: /*printf("?* unrecognised short option '%c'\n",optopt);*/ arg_register_error(endtable,endtable,optopt,NULL); break; } break; case':': /* * getopt_long() found an option with its argument missing. */ /*printf(": option %s requires an argument\n",argv[optind-1]); */ arg_register_error(endtable,endtable,ARG_EMISSARG,argv[optind-1]); break; default: { /* getopt_long() found a valid short option */ int tabindex = find_shortoption(table,(char)copt); /*printf("short option detected from argtable[%d]\n", tabindex);*/ if (tabindex==-1) { /* should never get here - but handle it just in case */ /*printf("unrecognised short option %d\n",copt);*/ arg_register_error(endtable,endtable,copt,NULL); } else { if (table[tabindex]->scanfn) { void *parent = table[tabindex]->parent; int errorcode = table[tabindex]->scanfn(parent,optarg); if (errorcode!=0) arg_register_error(endtable,parent,errorcode,optarg); } } break; } } } free(shortoptions); free(longoptions); } static void arg_parse_untagged(int argc, char **argv, struct arg_hdr **table, struct arg_end *endtable) { int tabindex=0; int errorlast=0; const char *optarglast = NULL; void *parentlast = NULL; /*printf("arg_parse_untagged(%d,%p,%p,%p)\n",argc,argv,table,endtable);*/ while (!(table[tabindex]->flag&ARG_TERMINATOR)) { void *parent; int errorcode; /* if we have exhausted our argv[optind] entries then we have finished */ if (optind>=argc) { /*printf("arg_parse_untagged(): argv[] exhausted\n");*/ return; } /* skip table entries with non-null long or short options (they are not untagged entries) */ if (table[tabindex]->longopts || table[tabindex]->shortopts) { /*printf("arg_parse_untagged(): skipping argtable[%d] (tagged argument)\n",tabindex);*/ tabindex++; continue; } /* skip table entries with NULL scanfn */ if (!(table[tabindex]->scanfn)) { /*printf("arg_parse_untagged(): skipping argtable[%d] (NULL scanfn)\n",tabindex);*/ tabindex++; continue; } /* attempt to scan the current argv[optind] with the current */ /* table[tabindex] entry. If it succeeds then keep it, otherwise */ /* try again with the next table[] entry. */ parent = table[tabindex]->parent; errorcode = table[tabindex]->scanfn(parent,argv[optind]); if (errorcode==0) { /* success, move onto next argv[optind] but stay with same table[tabindex] */ /*printf("arg_parse_untagged(): argtable[%d] successfully matched\n",tabindex);*/ optind++; /* clear the last tentative error */ errorlast = 0; } else { /* failure, try same argv[optind] with next table[tabindex] entry */ /*printf("arg_parse_untagged(): argtable[%d] failed match\n",tabindex);*/ tabindex++; /* remember this as a tentative error we may wish to reinstate later */ errorlast = errorcode; optarglast = argv[optind]; parentlast = parent; } } /* if a tenative error still remains at this point then register it as a proper error */ if (errorlast) { arg_register_error(endtable,parentlast,errorlast,optarglast); optind++; } /* only get here when not all argv[] entries were consumed */ /* register an error for each unused argv[] entry */ while (optind<argc) { /*printf("arg_parse_untagged(): argv[%d]=\"%s\" not consumed\n",optind,argv[optind]);*/ arg_register_error(endtable,endtable,ARG_ENOMATCH,argv[optind++]); } return; } static void arg_parse_check(struct arg_hdr **table, struct arg_end *endtable) { int tabindex=0; /* printf("arg_parse_check()\n"); */ do { if (table[tabindex]->checkfn) { void *parent = table[tabindex]->parent; int errorcode = table[tabindex]->checkfn(parent); if (errorcode!=0) arg_register_error(endtable,parent,errorcode,NULL); } }while(!(table[tabindex++]->flag&ARG_TERMINATOR)); } static void arg_reset(void **argtable) { struct arg_hdr **table=(struct arg_hdr**)argtable; int tabindex=0; /*printf("arg_reset(%p)\n",argtable);*/ do { if (table[tabindex]->resetfn) table[tabindex]->resetfn(table[tabindex]->parent); } while(!(table[tabindex++]->flag&ARG_TERMINATOR)); } int arg_parse(int argc, char **argv, void **argtable) { struct arg_hdr **table = (struct arg_hdr **)argtable; struct arg_end *endtable; int endindex; char **argvcopy = NULL; /*printf("arg_parse(%d,%p,%p)\n",argc,argv,argtable);*/ /* reset any argtable data from previous invocations */ arg_reset(argtable); /* locate the first end-of-table marker within the array */ endindex = arg_endindex(table); endtable = (struct arg_end*)table[endindex]; /* Special case of argc==0. This can occur on Texas Instruments DSP. */ /* Failure to trap this case results in an unwanted NULL result from */ /* the malloc for argvcopy (next code block). */ if (argc==0) { /* We must still perform post-parse checks despite the absence of command line arguments */ arg_parse_check(table,endtable); /* Now we are finished */ return endtable->count; } argvcopy = malloc(sizeof(char *) * argc); if (argvcopy) { int i; /* Fill in the local copy of argv[]. We need a local copy because getopt rearranges argv[] which adversely affects susbsequent parsing attempts. */ for (i=0; i<argc; i++) argvcopy[i] = argv[i]; /* parse the command line (local copy) for tagged options */ arg_parse_tagged(argc,argvcopy,table,endtable); /* parse the command line (local copy) for untagged options */ arg_parse_untagged(argc,argvcopy,table,endtable); /* if no errors so far then perform post-parse checks otherwise dont bother */ if (endtable->count==0) arg_parse_check(table,endtable); /* release the local copt of argv[] */ free(argvcopy); } else { /* memory alloc failed */ arg_register_error(endtable,endtable,ARG_EMALLOC,NULL); } return endtable->count; } /* * Concatenate contents of src[] string onto *pdest[] string. * The *pdest pointer is altered to point to the end of the * target string and *pndest is decremented by the same number * of chars. * Does not append more than *pndest chars into *pdest[] * so as to prevent buffer overruns. * Its something like strncat() but more efficient for repeated * calls on the same destination string. * Example of use: * char dest[30] = "good" * size_t ndest = sizeof(dest); * char *pdest = dest; * arg_char(&pdest,"bye ",&ndest); * arg_char(&pdest,"cruel ",&ndest); * arg_char(&pdest,"world!",&ndest); * Results in: * dest[] == "goodbye cruel world!" * ndest == 10 */ static void arg_cat(char **pdest, const char *src, size_t *pndest) { char *dest = *pdest; char *end = dest + *pndest; /*locate null terminator of dest string */ while(dest<end && *dest!=0) dest++; /* concat src string to dest string */ while(dest<end && *src!=0) *dest++ = *src++; /* null terminate dest string */ *dest=0; /* update *pdest and *pndest */ *pndest = end - dest; *pdest = dest; } static void arg_cat_option(char *dest, size_t ndest, const char *shortopts, const char *longopts, const char *datatype, int optvalue) { if (shortopts) { char option[3]; /* note: option array[] is initialiazed dynamically here to satisfy */ /* a deficiency in the watcom compiler wrt static array initializers. */ option[0] = '-'; option[1] = shortopts[0]; option[2] = 0; arg_cat(&dest,option,&ndest); if (datatype) { arg_cat(&dest," ",&ndest); if (optvalue) { arg_cat(&dest,"[",&ndest); arg_cat(&dest,datatype,&ndest); arg_cat(&dest,"]",&ndest); } else arg_cat(&dest,datatype,&ndest); } } else if (longopts) { size_t ncspn; /* add "--" tag prefix */ arg_cat(&dest,"--",&ndest); /* add comma separated option tag */ ncspn = strcspn(longopts,","); strncat(dest,longopts,(ncspn<ndest)?ncspn:ndest); if (datatype) { arg_cat(&dest,"=",&ndest); if (optvalue) { arg_cat(&dest,"[",&ndest); arg_cat(&dest,datatype,&ndest); arg_cat(&dest,"]",&ndest); } else arg_cat(&dest,datatype,&ndest); } } else if (datatype) { if (optvalue) { arg_cat(&dest,"[",&ndest); arg_cat(&dest,datatype,&ndest); arg_cat(&dest,"]",&ndest); } else arg_cat(&dest,datatype,&ndest); } } static void arg_cat_optionv(char *dest, size_t ndest, const char *shortopts, const char *longopts, const char *datatype, int optvalue, const char *separator) { separator = separator ? separator : ""; if (shortopts) { const char *c = shortopts; while(*c) { /* "-a|-b|-c" */ char shortopt[3]; /* note: shortopt array[] is initialiazed dynamically here to satisfy */ /* a deficiency in the watcom compiler wrt static array initializers. */ shortopt[0]='-'; shortopt[1]=*c; shortopt[2]=0; arg_cat(&dest,shortopt,&ndest); if (*++c) arg_cat(&dest,separator,&ndest); } } /* put separator between long opts and short opts */ if (shortopts && longopts) arg_cat(&dest,separator,&ndest); if (longopts) { const char *c = longopts; while(*c) { size_t ncspn; /* add "--" tag prefix */ arg_cat(&dest,"--",&ndest); /* add comma separated option tag */ ncspn = strcspn(c,","); strncat(dest,c,(ncspn<ndest)?ncspn:ndest); c+=ncspn; /* add given separator in place of comma */ if (*c==',') { arg_cat(&dest,separator,&ndest); c++; } } } if (datatype) { if (longopts) arg_cat(&dest,"=",&ndest); else if (shortopts) arg_cat(&dest," ",&ndest); if (optvalue) { arg_cat(&dest,"[",&ndest); arg_cat(&dest,datatype,&ndest); arg_cat(&dest,"]",&ndest); } else arg_cat(&dest,datatype,&ndest); } } /* this function should be deprecated because it doesnt consider optional argument values (ARG_HASOPTVALUE) */ void arg_print_option(FILE *fp, const char *shortopts, const char *longopts, const char *datatype, const char *suffix) { char syntax[200]=""; suffix = suffix ? suffix : ""; /* there is no way of passing the proper optvalue for optional argument values here, so we must ignore it */ arg_cat_optionv(syntax,sizeof(syntax),shortopts,longopts,datatype,0,"|"); fputs(syntax,fp); fputs(suffix,fp); } /* * Print a GNU style [OPTION] string in which all short options that * do not take argument values are presented in abbreviated form, as * in: -xvfsd, or -xvf[sd], or [-xvsfd] */ static void arg_print_gnuswitch(FILE *fp, struct arg_hdr **table) { int tabindex; char *format1=" -%c"; char *format2=" [-%c"; int need_suffix=0; /* JPB mod */ /* print all mandatory switches that are without argument values */ for(tabindex=0; table[tabindex] && !(table[tabindex]->flag&ARG_TERMINATOR); tabindex++) { /* skip optional options */ if (table[tabindex]->mincount<1) continue; /* skip non-short options */ if (table[tabindex]->shortopts==NULL) continue; /* skip options that take argument values */ if (table[tabindex]->flag&ARG_HASVALUE) continue; /* print the short option (only the first short option char, ignore multiple choices)*/ fprintf(fp,format1,table[tabindex]->shortopts[0]); format1="%c"; format2="[%c"; } /* print all optional switches that are without argument values */ for(tabindex=0; table[tabindex] && !(table[tabindex]->flag&ARG_TERMINATOR); tabindex++) { /* skip mandatory args */ if (table[tabindex]->mincount>0) continue; /* skip args without short options */ if (table[tabindex]->shortopts==NULL) continue; /* skip args with values */ if (table[tabindex]->flag&ARG_HASVALUE) continue; /* print first short option */ fprintf(fp,format2,table[tabindex]->shortopts[0]); format2="%c"; need_suffix=1; } fprintf(fp,need_suffix ? "]" : ""); } void arg_print_syntax(FILE *fp, void **argtable, const char *suffix) { struct arg_hdr **table = (struct arg_hdr**)argtable; int i,tabindex; /* print GNU style [OPTION] string */ arg_print_gnuswitch(fp, table); /* print remaining options in abbreviated style */ for(tabindex=0; table[tabindex] && !(table[tabindex]->flag&ARG_TERMINATOR); tabindex++) { char syntax[200]=""; const char *shortopts, *longopts, *datatype; /* skip short options without arg values (they were printed by arg_print_gnu_switch) */ if (table[tabindex]->shortopts && !(table[tabindex]->flag&ARG_HASVALUE)) continue; shortopts = table[tabindex]->shortopts; longopts = table[tabindex]->longopts; datatype = table[tabindex]->datatype; arg_cat_option(syntax,sizeof(syntax),shortopts,longopts,datatype, table[tabindex]->flag&ARG_HASOPTVALUE); if (strlen(syntax)>0) { /* print mandatory instances of this option */ for (i=0; i<table[tabindex]->mincount; i++) fprintf(fp, " %s",syntax); /* print optional instances enclosed in "[..]" */ switch ( table[tabindex]->maxcount - table[tabindex]->mincount ) { case 0: break; case 1: fprintf(fp, " [%s]",syntax); break; case 2: fprintf(fp, " [%s] [%s]",syntax,syntax); break; default: fprintf(fp, " [%s]...",syntax); break; } } } if (suffix) fprintf(fp, "%s",suffix); } void arg_print_syntaxv(FILE *fp, void **argtable, const char *suffix) { struct arg_hdr **table = (struct arg_hdr**)argtable; int i,tabindex; /* print remaining options in abbreviated style */ for(tabindex=0; table[tabindex] && !(table[tabindex]->flag&ARG_TERMINATOR); tabindex++) { char syntax[200]=""; const char *shortopts, *longopts, *datatype; shortopts = table[tabindex]->shortopts; longopts = table[tabindex]->longopts; datatype = table[tabindex]->datatype; arg_cat_optionv(syntax,sizeof(syntax),shortopts,longopts,datatype,table[tabindex]->flag&ARG_HASOPTVALUE, "|"); /* print mandatory options */ for (i=0; i<table[tabindex]->mincount; i++) fprintf(fp," %s",syntax); /* print optional args enclosed in "[..]" */ switch ( table[tabindex]->maxcount - table[tabindex]->mincount ) { case 0: break; case 1: fprintf(fp, " [%s]",syntax); break; case 2: fprintf(fp, " [%s] [%s]",syntax,syntax); break; default: fprintf(fp, " [%s]...",syntax); break; } } if (suffix) fprintf(fp,"%s",suffix); } void arg_print_glossary(FILE *fp, void **argtable, const char *format) { struct arg_hdr **table = (struct arg_hdr**)argtable; int tabindex; format = format ? format : " %-20s %s\n"; for(tabindex=0; !(table[tabindex]->flag&ARG_TERMINATOR); tabindex++) { if (table[tabindex]->glossary) { char syntax[200]=""; const char *shortopts = table[tabindex]->shortopts; const char *longopts = table[tabindex]->longopts; const char *datatype = table[tabindex]->datatype; const char *glossary = table[tabindex]->glossary; arg_cat_optionv(syntax,sizeof(syntax),shortopts,longopts,datatype,table[tabindex]->flag&ARG_HASOPTVALUE,", "); fprintf(fp,format,syntax,glossary); } } } /** * Print a piece of text formatted, which means in a column with a * left and a right margin. The lines are wrapped at whitspaces next * to right margin. The function does not indent the first line, but * only the following ones. * * Example: * arg_print_formatted( fp, 0, 5, "Some text that doesn't fit." ) * will result in the following output: * * Some * text * that * doesn' * t fit. * * Too long lines will be wrapped in the middle of a word. * * arg_print_formatted( fp, 2, 7, "Some text that doesn't fit." ) * will result in the following output: * * Some * text * that * doesn' * t fit. * * As you see, the first line is not indented. This enables output of * lines, which start in a line where output already happened. * * Author: Uli Fouquet */ static void arg_print_formatted( FILE *fp, const unsigned lmargin, const unsigned rmargin, const char *text ) { const unsigned textlen = strlen( text ); unsigned line_start = 0; unsigned line_end = textlen + 1; const unsigned colwidth = (rmargin - lmargin) + 1; /* Someone doesn't like us... */ if ( line_end < line_start ) { fprintf( fp, "%s\n", text ); } while (line_end-1 > line_start ) { /* Eat leading whitespaces. This is essential because while wrapping lines, there will often be a whitespace at beginning of line */ /* JPB patch to cast argument */ while (isspace ((int) (*(text+line_start))) ) { line_start++; } if ((line_end - line_start) > colwidth ) { line_end = line_start + colwidth; } /* Find last whitespace, that fits into line */ /* JPB patch to cast argument */ while ( ( line_end > line_start ) && ( line_end - line_start > colwidth ) && !isspace ((int) (*(text+line_end)))) { line_end--; } /* Do not print trailing whitespace. If this text has got only one line, line_end now points to the last char due to initialization. */ line_end--; /* Output line of text */ while ( line_start < line_end ) { fputc(*(text+line_start), fp ); line_start++; } fputc( '\n', fp ); /* Initialize another line */ if ( line_end+1 < textlen ) { unsigned i; for (i=0; i < lmargin; i++ ) { fputc( ' ', fp ); } line_end = textlen; } /* If we have to print another line, get also the last char. */ line_end++; } /* lines of text */ } /** * Prints the glossary in strict GNU format. * Differences to arg_print_glossary() are: * - wraps lines after 80 chars * - indents lines without shortops * - does not accept formatstrings * * Contributed by Uli Fouquet */ void arg_print_glossary_gnu(FILE *fp, void **argtable ) { struct arg_hdr **table = (struct arg_hdr**)argtable; int tabindex; for(tabindex=0; !(table[tabindex]->flag&ARG_TERMINATOR); tabindex++) { if (table[tabindex]->glossary) { char syntax[200]=""; const char *shortopts = table[tabindex]->shortopts; const char *longopts = table[tabindex]->longopts; const char *datatype = table[tabindex]->datatype; const char *glossary = table[tabindex]->glossary; if ( !shortopts && longopts ) { /* Indent trailing line by 4 spaces... */ memset( syntax, ' ', 4 ); *(syntax+4) = '\0'; } arg_cat_optionv(syntax,sizeof(syntax),shortopts,longopts,datatype,table[tabindex]->flag&ARG_HASOPTVALUE,", "); /* If syntax fits not into column, print glossary in new line... */ if ( strlen(syntax) > 25 ) { fprintf( fp, " %-25s %s\n", syntax, "" ); *syntax = '\0'; } fprintf( fp, " %-25s ", syntax ); arg_print_formatted( fp, 28, 79, glossary ); } } /* for each table entry */ fputc( '\n', fp ); } /** * Checks the argtable[] array for NULL entries and returns 1 * if any are found, zero otherwise. */ int arg_nullcheck(void **argtable) { struct arg_hdr **table = (struct arg_hdr **)argtable; int tabindex; /*printf("arg_nullcheck(%p)\n",argtable);*/ if (!table) return 1; tabindex=0; do { /*printf("argtable[%d]=%p\n",tabindex,argtable[tabindex]);*/ if (!table[tabindex]) return 1; } while(!(table[tabindex++]->flag&ARG_TERMINATOR)); return 0; } /* * arg_free() is deprecated in favour of arg_freetable() due to a flaw in its design. * The flaw results in memory leak in the (very rare) case that an intermediate * entry in the argtable array failed its memory allocation while others following * that entry were still allocated ok. Those subsequent allocations will not be * deallocated by arg_free(). * Despite the unlikeliness of the problem occurring, and the even unlikelier event * that it has any deliterious effect, it is fixed regardless by replacing arg_free() * with the newer arg_freetable() function. * We still keep arg_free() for backwards compatibility. */ void arg_free(void **argtable) { struct arg_hdr **table=(struct arg_hdr**)argtable; int tabindex=0; int flag; /*printf("arg_free(%p)\n",argtable);*/ do { /* if we encounter a NULL entry then somewhat incorrectly we presume we have come to the end of the array. It isnt strictly true because an intermediate entry could be NULL with other non-NULL entries to follow. The subsequent argtable entries would then not be freed as they should. */ if (table[tabindex]==NULL) break; flag = table[tabindex]->flag; free(table[tabindex]); table[tabindex++]=NULL; } while(!(flag&ARG_TERMINATOR)); } /* frees each non-NULL element of argtable[], where n is the size of the number of entries in the array */ void arg_freetable(void **argtable, size_t n) { struct arg_hdr **table=(struct arg_hdr**)argtable; int tabindex=0; /*printf("arg_freetable(%p)\n",argtable);*/ for (tabindex=0; tabindex<n; tabindex++) { if (table[tabindex]==NULL) continue; free(table[tabindex]); table[tabindex]=NULL; }; }
Go to most recent revision | Compare with Previous | Blame | View Log