/****************************************************************************/ /* argv.h: a thread-safe argument vector parser and usage screen generator */ /* Copyright (C) 2015--2016 Z. Gilboa */ /* Released under the Standard MIT License; see COPYING.SOFORT. */ /* This file is (also) part of sofort: portable software project template. */ /****************************************************************************/ #ifndef ARGV_H #define ARGV_H #include <stdbool.h> #include <stdint.h> #include <stddef.h> #include <errno.h> #include <string.h> #include <stdlib.h> #include <stdio.h> #define ARGV_VERBOSITY_NONE 0x00 #define ARGV_VERBOSITY_ERRORS 0x01 #define ARGV_VERBOSITY_STATUS 0x02 #define ARGV_CLONE_VECTOR 0x80 #ifndef ARGV_TAB_WIDTH #define ARGV_TAB_WIDTH 8 #endif /*******************************************/ /* */ /* support of hybrid options */ /* ------------------------- */ /* hybrid options are very similar to */ /* long options, yet are prefixed by */ /* a single dash rather than two */ /* (i.e. -std, -isystem). */ /* hybrid options are supported by this */ /* driver for compatibility with legacy */ /* tools; note, however, that the use */ /* of hybrid options should be strongly */ /* discouraged due to the limitations */ /* they impose on short options (for */ /* example, a driver implementing -std */ /* may not provide -s as a short option */ /* that takes an arbitrary value). */ /* */ /* SPACE: -hybrid VALUE (i.e. -MF file) */ /* EQUAL: -hybrid=VALUE (i.e. -std=c99) */ /* COMMA: -hybrid,VALUE (i.e. -Wl,<arg>) */ /* ONLY: -opt accepted, --opt rejected */ /* JOINED: -optVALUE */ /* */ /*******************************************/ #define ARGV_OPTION_HYBRID_NONE 0x00 #define ARGV_OPTION_HYBRID_ONLY 0x01 #define ARGV_OPTION_HYBRID_SPACE 0x02 #define ARGV_OPTION_HYBRID_EQUAL 0x04 #define ARGV_OPTION_HYBRID_COMMA 0x08 #define ARGV_OPTION_HYBRID_JOINED 0x10 #define ARGV_OPTION_HYBRID_CIRCUS (ARGV_OPTION_HYBRID_SPACE \ | ARGV_OPTION_HYBRID_JOINED) #define ARGV_OPTION_HYBRID_DUAL (ARGV_OPTION_HYBRID_SPACE \ | ARGV_OPTION_HYBRID_EQUAL) #define ARGV_OPTION_HYBRID_SWITCH (ARGV_OPTION_HYBRID_ONLY \ | ARGV_OPTION_HYBRID_SPACE \ | ARGV_OPTION_HYBRID_EQUAL \ | ARGV_OPTION_HYBRID_COMMA \ | ARGV_OPTION_HYBRID_JOINED) enum argv_optarg { ARGV_OPTARG_NONE, ARGV_OPTARG_REQUIRED, ARGV_OPTARG_OPTIONAL, }; enum argv_mode { ARGV_MODE_SCAN, ARGV_MODE_COPY, }; enum argv_error { ARGV_ERROR_OK, ARGV_ERROR_INTERNAL, ARGV_ERROR_SHORT_OPTION, ARGV_ERROR_LONG_OPTION, ARGV_ERROR_OPTARG_NONE, ARGV_ERROR_OPTARG_REQUIRED, ARGV_ERROR_OPTARG_PARADIGM, ARGV_ERROR_HYBRID_NONE, ARGV_ERROR_HYBRID_ONLY, ARGV_ERROR_HYBRID_SPACE, ARGV_ERROR_HYBRID_EQUAL, ARGV_ERROR_HYBRID_COMMA, }; struct argv_option { const char * long_name; const char short_name; int tag; enum argv_optarg optarg; int flags; const char * paradigm; const char * argname; const char * description; }; struct argv_entry { const char * arg; int tag; bool fopt; bool fval; bool fnoscan; enum argv_error errcode; }; struct argv_meta { char ** argv; struct argv_entry * entries; }; struct argv_meta_impl { char ** argv; char * strbuf; struct argv_meta meta; }; struct argv_ctx { int flags; int mode; int nentries; int unitidx; int erridx; enum argv_error errcode; const char * errch; const struct argv_option * erropt; const char * program; }; #ifdef ARGV_DRIVER static const char * argv_program_name(const char *); static void argv_usage( FILE *, const char * header, const struct argv_option[], const char * mode); static struct argv_meta * argv_get( char **, const struct argv_option[], int flags); static void argv_free(struct argv_meta *); /*------------------------------------*/ /* implementation of static functions */ /*------------------------------------*/ static const struct argv_option * argv_short_option( const char * ch, const struct argv_option options[], struct argv_entry * entry) { const struct argv_option * option; for (option=options; option->long_name || option->short_name; option++) { if (option->short_name == *ch) { entry->tag = option->tag; entry->fopt = true; return option; } } return 0; } static const struct argv_option * argv_long_option( const char * ch, const struct argv_option options[], struct argv_entry * entry) { const struct argv_option * option; const char * arg; size_t len; for (option=options; option->long_name || option->short_name; option++) { len = option->long_name ? strlen(option->long_name) : 0; if (len && !(strncmp(option->long_name,ch,len))) { arg = ch + len; if (!*arg || (*arg == '=') || (option->flags & ARGV_OPTION_HYBRID_JOINED) || ((option->flags & ARGV_OPTION_HYBRID_COMMA) && (*arg == ','))) { entry->tag = option->tag; entry->fopt = true; return option; } } } return 0; } static inline bool is_short_option(const char * arg) { return (arg[0]=='-') && arg[1] && (arg[1]!='-'); } static inline bool is_long_option(const char * arg) { return (arg[0]=='-') && (arg[1]=='-') && arg[2]; } static inline bool is_last_option(const char * arg) { return (arg[0]=='-') && (arg[1]=='-') && !arg[2]; } static inline bool is_hybrid_option( const char * arg, const struct argv_option options[]) { const struct argv_option * option; struct argv_entry entry; if (!is_short_option(arg)) return false; if (!(option = argv_long_option(++arg,options,&entry))) return false; if (!(option->flags & ARGV_OPTION_HYBRID_SWITCH)) if (argv_short_option(arg,options,&entry)) return false; return true; } static inline bool is_arg_in_paradigm(const char * arg, const char * paradigm) { size_t len; const char * ch; for (ch=paradigm,len=strlen(arg); ch; ) { if (!strncmp(arg,ch,len)) { if (!*(ch += len)) return true; else if (*ch == '|') return true; } if ((ch = strchr(ch,'|'))) ch++; } return false; } static inline const struct argv_option * option_from_tag( const struct argv_option options[], int tag) { const struct argv_option * option; for (option=options; option->short_name || option->long_name; option++) if (option->tag == tag) return option; return 0; } static void argv_scan( char ** argv, const struct argv_option options[], struct argv_ctx * ctx, struct argv_meta * meta) { char ** parg; const char * ch; const char * val; const struct argv_option * option; struct argv_entry entry; struct argv_entry * mentry; enum argv_error ferr; bool fval; bool fnext; bool fshort; bool fhybrid; bool fnoscan; parg = &argv[1]; ch = *parg; ferr = ARGV_ERROR_OK; fshort = false; fnoscan = false; fval = false; mentry = meta ? meta->entries : 0; ctx->unitidx = 0; ctx->erridx = 0; while (ch && (ferr == ARGV_ERROR_OK)) { option = 0; fhybrid = false; if (fnoscan) fval = true; else if (is_last_option(ch)) fnoscan = true; else if (!fshort && is_hybrid_option(ch,options)) fhybrid = true; if (!fnoscan && !fhybrid && (fshort || is_short_option(ch))) { if (!fshort) ch++; if ((option = argv_short_option(ch,options,&entry))) { if (ch[1]) { ch++; fnext = false; fshort = (option->optarg == ARGV_OPTARG_NONE); } else { parg++; ch = *parg; fnext = true; fshort = false; } if (option->optarg == ARGV_OPTARG_NONE) { if (!fnext && ch && (*ch == '-')) ferr = ARGV_ERROR_OPTARG_NONE; else fval = false; } else if (!fnext) fval = true; else if (option->optarg == ARGV_OPTARG_REQUIRED) { if (ch && is_short_option(ch)) ferr = ARGV_ERROR_OPTARG_REQUIRED; else if (ch && is_long_option(ch)) ferr = ARGV_ERROR_OPTARG_REQUIRED; else if (ch && is_last_option(ch)) ferr = ARGV_ERROR_OPTARG_REQUIRED; else if (ch) fval = true; else ferr = ARGV_ERROR_OPTARG_REQUIRED; } else { /* ARGV_OPTARG_OPTIONAL */ if (ch && is_short_option(ch)) fval = false; else if (ch && is_long_option(ch)) fval = false; else if (ch && is_last_option(ch)) fval = false; else fval = ch; } } else ferr = ARGV_ERROR_SHORT_OPTION; } else if (!fnoscan && (fhybrid || is_long_option(ch))) { ch += (fhybrid ? 1 : 2); if ((option = argv_long_option(ch,options,&entry))) { val = ch + strlen(option->long_name); /* val[0] is either '=' (or ',') or '\0' */ if (!val[0]) { parg++; ch = *parg; } if (fhybrid && !(option->flags & ARGV_OPTION_HYBRID_SWITCH)) ferr = ARGV_ERROR_HYBRID_NONE; else if (!fhybrid && (option->flags & ARGV_OPTION_HYBRID_ONLY)) ferr = ARGV_ERROR_HYBRID_ONLY; else if (option->optarg == ARGV_OPTARG_NONE) { if (val[0]) { ferr = ARGV_ERROR_OPTARG_NONE; ctx->errch = val + 1; } else fval = false; } else if (val[0] && (option->flags & ARGV_OPTION_HYBRID_JOINED)) { fval = true; ch = val; } else if (fhybrid && !val[0] && !(option->flags & ARGV_OPTION_HYBRID_SPACE)) ferr = ARGV_ERROR_HYBRID_SPACE; else if (fhybrid && (val[0]=='=') && !(option->flags & ARGV_OPTION_HYBRID_EQUAL)) ferr = ARGV_ERROR_HYBRID_EQUAL; else if (fhybrid && (val[0]==',') && !(option->flags & ARGV_OPTION_HYBRID_COMMA)) ferr = ARGV_ERROR_HYBRID_COMMA; else if (!fhybrid && (val[0]==',')) ferr = ARGV_ERROR_HYBRID_COMMA; else if (val[0] && !val[1]) ferr = ARGV_ERROR_OPTARG_REQUIRED; else if (val[0] && val[1]) { fval = true; ch = ++val; } else if (option->optarg == ARGV_OPTARG_REQUIRED) { if (!val[0] && !*parg) ferr = ARGV_ERROR_OPTARG_REQUIRED; else if (*parg && is_short_option(*parg)) ferr = ARGV_ERROR_OPTARG_REQUIRED; else if (*parg && is_long_option(*parg)) ferr = ARGV_ERROR_OPTARG_REQUIRED; else if (*parg && is_last_option(*parg)) ferr = ARGV_ERROR_OPTARG_REQUIRED; else fval = true; } else { /* ARGV_OPTARG_OPTIONAL */ fval = val[0]; } } else ferr = ARGV_ERROR_LONG_OPTION; } if (ferr == ARGV_ERROR_OK) if (option && fval && option->paradigm) if (!is_arg_in_paradigm(ch,option->paradigm)) ferr = ARGV_ERROR_OPTARG_PARADIGM; if (ferr == ARGV_ERROR_OK) if (!option && !ctx->unitidx) ctx->unitidx = parg - argv; if (ferr != ARGV_ERROR_OK) { ctx->errcode = ferr; ctx->errch = ctx->errch ? ctx->errch : ch; ctx->erropt = option; ctx->erridx = parg - argv; return; } else if (ctx->mode == ARGV_MODE_SCAN) { if (!fnoscan) ctx->nentries++; else if (fval) ctx->nentries++; if (fval || !option) { parg++; ch = *parg; } } else if (ctx->mode == ARGV_MODE_COPY) { if (fnoscan) { if (fval) { mentry->arg = ch; mentry->fnoscan = true; mentry++; } parg++; ch = *parg; } else if (option) { mentry->arg = fval ? ch : 0; mentry->tag = option->tag; mentry->fopt = true; mentry->fval = fval; mentry++; if (fval) { parg++; ch = *parg; } } else { mentry->arg = ch; mentry++; parg++; ch = *parg; } } } } static const char * argv_program_name(const char * program_path) { const char * ch; if (program_path) { if ((ch = strrchr(program_path,'/'))) return *(++ch) ? ch : 0; if ((ch = strrchr(program_path,'\\'))) return *(++ch) ? ch : 0; } return program_path; } static void argv_show_error(struct argv_ctx * ctx) { fprintf(stderr,"%s: error: ",ctx->program); switch (ctx->errcode) { case ARGV_ERROR_SHORT_OPTION: fprintf(stderr,"'-%c' is not a valid short option\n",*ctx->errch); break; case ARGV_ERROR_LONG_OPTION: fprintf(stderr,"'--%s' is not a valid long option\n",ctx->errch); break; case ARGV_ERROR_OPTARG_NONE: fprintf(stderr,"'%s' is not a valid option value for [%s%c%s%s%s] " "(option values may not be specified)\n", ctx->errch, ctx->erropt->short_name ? "-" : "", ctx->erropt->short_name, ctx->erropt->short_name ? "," : "", ctx->erropt->long_name ? "--" : "", ctx->erropt->long_name); break; case ARGV_ERROR_OPTARG_REQUIRED: fprintf(stderr,"option [%s%c%s%s%s] requires %s %s%s%s\n", ctx->erropt->short_name ? "-" : "", ctx->erropt->short_name, ctx->erropt->short_name ? "," : "", ctx->erropt->long_name ? "--" : "", ctx->erropt->long_name, ctx->erropt->paradigm ? "one of the following values:" : "a value", ctx->erropt->paradigm ? "{" : "", ctx->erropt->paradigm ? ctx->erropt->paradigm : "", ctx->erropt->paradigm ? "}" : ""); break; case ARGV_ERROR_OPTARG_PARADIGM: fprintf(stderr,"'%s' is not a valid option value for [%s%c%s%s%s]={%s}\n", ctx->errch, ctx->erropt->short_name ? "-" : "", ctx->erropt->short_name, ctx->erropt->short_name ? "," : "", ctx->erropt->long_name ? "--" : "", ctx->erropt->long_name, ctx->erropt->paradigm); break; case ARGV_ERROR_HYBRID_NONE: fprintf(stderr,"-%s is not a synonym for --%s\n", ctx->erropt->long_name, ctx->erropt->long_name); break; case ARGV_ERROR_HYBRID_ONLY: fprintf(stderr,"--%s is not a synonym for -%s\n", ctx->erropt->long_name, ctx->erropt->long_name); break; case ARGV_ERROR_HYBRID_SPACE: case ARGV_ERROR_HYBRID_EQUAL: case ARGV_ERROR_HYBRID_COMMA: fprintf(stderr,"-%s: illegal value assignment; valid syntax is " "-%s%sVAL\n", ctx->erropt->long_name, ctx->erropt->long_name, (ctx->erropt->flags & ARGV_OPTION_HYBRID_SPACE) ? " " : (ctx->erropt->flags & ARGV_OPTION_HYBRID_EQUAL) ? "=" : (ctx->erropt->flags & ARGV_OPTION_HYBRID_COMMA) ? "," : ""); break; case ARGV_ERROR_INTERNAL: fputs("internal error",stderr); break; default: break; } } static void argv_show_status( const struct argv_option options[], struct argv_ctx * ctx, struct argv_meta * meta) { int argc; char ** argv; struct argv_entry * entry; const struct argv_option * option; char short_name[2] = {0}; const char * space = ""; fputs("\n\nconcatenated command line:\n",stderr); for (argv=meta->argv; *argv; argv++) { fprintf(stderr,"%s%s",space,*argv); space = " "; } fputs("\n\nargument vector:\n",stderr); for (argc=0,argv=meta->argv; *argv; argc++,argv++) fprintf(stderr,"argv[%d]: %s\n",argc,*argv); fputs("\n\nparsed entries:\n",stderr); for (entry=meta->entries; entry->arg || entry->fopt; entry++) if (entry->fopt) { option = option_from_tag(options,entry->tag); short_name[0] = option->short_name; if (entry->fval) fprintf(stderr,"[-%s,--%s] := %s\n", short_name,option->long_name,entry->arg); else fprintf(stderr,"[-%s,--%s]\n", short_name,option->long_name); } else fprintf(stderr,"<program arg> := %s\n",entry->arg); fputs("\n\n",stderr); } static struct argv_meta * argv_free_impl(struct argv_meta_impl * imeta) { if (imeta->argv) free(imeta->argv); if (imeta->strbuf) free(imeta->strbuf); if (imeta->meta.entries) free(imeta->meta.entries); free(imeta); return 0; } static struct argv_meta * argv_alloc(char ** argv, struct argv_ctx * ctx) { struct argv_meta_impl * imeta; char ** vector; char * dst; size_t size; int argc; int i; if (!(imeta = calloc(1,sizeof(*imeta)))) return 0; if (ctx->flags & ARGV_CLONE_VECTOR) { for (vector=argv,argc=0,size=0; *vector; vector++) { size += strlen(*vector) + 1; argc++; } if (!(imeta->argv = calloc(argc+1,sizeof(char *)))) return argv_free_impl(imeta); else if (!(imeta->strbuf = calloc(1,size+1))) return argv_free_impl(imeta); for (i=0,dst=imeta->strbuf; i<argc; i++) { strcpy(dst,argv[i]); imeta->argv[i] = dst; dst += strlen(dst)+1; } imeta->meta.argv = imeta->argv; } else imeta->meta.argv = argv; if (!(imeta->meta.entries = calloc( ctx->nentries+1, sizeof(struct argv_entry)))) return argv_free_impl(imeta); else return &imeta->meta; } static struct argv_meta * argv_get( char * argv[], const struct argv_option options[], int flags) { struct argv_meta * meta; struct argv_ctx ctx = {flags,ARGV_MODE_SCAN,0,0,0,0,0,0,0}; argv_scan(argv,options,&ctx,0); if (ctx.errcode != ARGV_ERROR_OK) { if (!ctx.program) ctx.program = argv_program_name(argv[0]); if (ctx.flags & ARGV_VERBOSITY_ERRORS) argv_show_error(&ctx); return 0; } if (!(meta = argv_alloc(argv,&ctx))) return 0; ctx.mode = ARGV_MODE_COPY; argv_scan(meta->argv,options,&ctx,meta); if (ctx.errcode != ARGV_ERROR_OK) { if (!ctx.program) ctx.program = argv[0]; ctx.errcode = ARGV_ERROR_INTERNAL; argv_show_error(&ctx); argv_free(meta); return 0; } if (ctx.flags & ARGV_VERBOSITY_STATUS) argv_show_status(options,&ctx,meta); return meta; } static void argv_free(struct argv_meta * xmeta) { struct argv_meta_impl * imeta; uintptr_t addr; if (xmeta) { addr = (uintptr_t)xmeta - offsetof(struct argv_meta_impl,meta); imeta = (struct argv_meta_impl *)addr; argv_free_impl(imeta); } } static void argv_usage( FILE * file, const char * header, const struct argv_option options[], const char * mode) { const struct argv_option * option; bool fshort,flong; bool fnewline; size_t len,optlen; size_t paralen,rparalen,mparalen; size_t desclen,rdesclen; char * para; char * next_para; char * desc; char * next_desc; char * paradigm; char * buf; size_t buflen; const char * sdescription; const char * sargname; const char indent[] = " "; const int rblen = sizeof("}") - sizeof(char); const int rbblen = sizeof("{]") - sizeof(char); const int brcklen= sizeof("[]") - sizeof(char); const int solen = sizeof("-") - sizeof(char); const int lolen = sizeof("--") - sizeof(char); const int slolen = sizeof("-X,--") - sizeof(char); fshort = mode ? !strcmp(mode,"short") : 0; flong = fshort ? 0 : mode && !strcmp(mode,"long"); if (header) fprintf(stdout,"%s",header); optlen = 0; paralen = 0; for (option=options; option->short_name || option->long_name; option++) { if (fshort) len = option->short_name ? sizeof(char) + solen : 0; else if (flong) len = option->long_name ? strlen(option->long_name) + lolen : 0; else len = option->long_name ? strlen(option->long_name) + slolen : 0; if (len) { if (len > optlen) optlen = len; if (option->argname) len = strlen(option->argname); else if (option->paradigm) len = strlen(option->paradigm) + strlen("{}"); else if (option->optarg != ARGV_OPTARG_NONE) len = strlen("<val>"); if (option->optarg == ARGV_OPTARG_OPTIONAL) len += strlen("[]"); if (len > paralen) paralen = len; } } optlen += ARGV_TAB_WIDTH; optlen &= (~(ARGV_TAB_WIDTH-1)); paradigm = next_para = buf = 0; fnewline = false; rparalen = 0; mparalen = 0; if (paralen) { paralen += (ARGV_TAB_WIDTH); paralen &= (~(ARGV_TAB_WIDTH-1)); mparalen = paralen + 2*rbblen; if (optlen + paralen > 64) paralen = 32; } /* account for ' ','\t', try to fit in 80 or 96 columns */ if (optlen+paralen+2+ARGV_TAB_WIDTH < 80-32) desclen = 80 - (optlen+paralen+2+ARGV_TAB_WIDTH); else if (optlen+paralen+2+ARGV_TAB_WIDTH < 96-32) desclen = 96 - (optlen+paralen+2+ARGV_TAB_WIDTH); else desclen = 32; buflen = 0; rdesclen = 1; for (option=options; option->short_name || option->long_name; option++) { if (fshort && !option->short_name) continue; else if (flong && !option->long_name) continue; if (option->paradigm) { if (option->optarg == ARGV_OPTARG_OPTIONAL) rparalen = strlen(option->paradigm) - 2*rbblen; else rparalen = strlen(option->paradigm) - 2*rblen; } sdescription = option->description ? option->description : ""; sargname = option->argname ? option->argname : ""; if (option->paradigm) rdesclen = snprintf(buf,buflen,sdescription,option->paradigm); else rdesclen = snprintf(buf,buflen,sdescription,sargname); if (fnewline) (void)0; if ((rparalen > paralen) || (rdesclen > desclen)) { if (!fnewline) { (void)0; fnewline = true; } } else fnewline = false; if (fshort) fprintf(file,"%s-%-*c",indent,(int)(optlen-solen),option->short_name); else if (flong) fprintf(file, (option->flags & ARGV_OPTION_HYBRID_ONLY) ? "%s -%-*s" : "%s--%-*s", indent,(int)(optlen-lolen),option->long_name); else { if (option->short_name && option->long_name) fprintf(file, (option->flags & ARGV_OPTION_HYBRID_ONLY) ? "%s-%c, -%-*s" : "%s-%c,--%-*s", indent,option->short_name, (int)(optlen-slolen),option->long_name); else if (option->short_name) fprintf(file,"%s-%-*c", indent,(int)(optlen-solen),option->short_name); else fprintf(file, (option->flags & ARGV_OPTION_HYBRID_ONLY) ? "%s%3s -%-*s" : "%s%3s--%-*s", indent,"", (int)(optlen-slolen),option->long_name); } if (rdesclen > buflen) { if (buf) { free(buf); buf = 0; } len = rdesclen + 512; len &= (~511); if ((buf = calloc(1,len))) { buflen = len; if (option->paradigm) rdesclen = snprintf(buf,buflen, option->description, option->paradigm); else rdesclen = snprintf(buf,buflen, option->description, option->argname); } else { buflen = 0; continue; } } if (option->argname) { if (option->optarg == ARGV_OPTARG_OPTIONAL) fprintf(file,"[%s]%-*c", option->argname, (int)(paralen-strlen(option->argname)-brcklen),' '); else fprintf(file,"%s%-*c", option->argname, (int)(paralen-strlen(option->argname)),' '); para = (char *)0; } else if (option->paradigm && (rparalen <= paralen)) { if (option->optarg == ARGV_OPTARG_OPTIONAL) fprintf(file,"[{%s}]%-*c", option->paradigm, (int)(paralen-strlen(option->paradigm)-2*rbblen),' '); else fprintf(file,"{%s}%-*c", option->paradigm, (int)(paralen-strlen(option->paradigm)-rbblen),' '); para = (char *)0; } else if (option->paradigm) { if (!paradigm && !(paradigm = calloc(1,mparalen))) { fputc('\n',file); continue; } else para = strcpy(paradigm,option->paradigm); if (option->optarg == ARGV_OPTARG_OPTIONAL) { fputs("[{",file); rparalen = paralen - rbblen; } else { fputc('{',file); rparalen = paralen - rblen; } } else { fprintf(file,"%-*c",(int)paralen,' '); para = (char *)0; } if (!para && option->description && rdesclen <= desclen) { fputc('\t',file); fputs(buf,file); desc = (char *)0; } else if (option->description) desc = buf; else desc = (char *)0; while (para || desc) { if (para) { next_para = para+rparalen-1; for (; (next_para>para) && (*next_para!='|'); ) next_para--; if (para > paradigm) { if (option->optarg == ARGV_OPTARG_OPTIONAL) fputs(" ",file); else fputc(' ',file); } if (*next_para != '|') { fprintf(file,"%s",para); para = (char *)0; } else if (next_para > para) { *next_para = '\0'; fprintf(file,"%-*s",(int)rparalen,para); *next_para = '|'; para = next_para; rparalen = strlen(para); /* 2*rbblen,2*rblen, etc.: account for indentation */ if (option->optarg == ARGV_OPTARG_OPTIONAL) rparalen = (rparalen+2*rbblen > paralen) ? paralen-rbblen : rparalen; else rparalen = (rparalen+2*rblen > paralen) ? paralen-rblen : rparalen; } else { if (option->optarg == ARGV_OPTARG_OPTIONAL) fprintf(file,"%s}]%-*c",para, (int)(paralen-strlen(para)-rbblen),' '); else fprintf(file,"%s}%-*c",para, (int)(paralen-strlen(para)-rblen),' '); para = (char *)0; } } else if (desc > buf) fprintf(file,"%-*c",(int)paralen,' '); if (desc) { if (desc > buf) fputs("\t ",file); else fputc('\t',file); if ((rdesclen = strlen(desc)+(desc>buf)) <= desclen) { fputs(desc,file); desc = (char *)0; } else { next_desc = desc + desclen - 1; for (; (next_desc > desc) && (*next_desc != ' ') && (*next_desc != '\n'); ) next_desc--; if ((*next_desc != ' ') && (*next_desc!='\n')) { fputs(desc,file); desc = (char *)0; } else if (next_desc > desc) { *next_desc = '\0'; fputs(desc,file); desc = ++next_desc; } else { fputs(desc,file); desc = (char *)0; } } } if (para || desc) fprintf(file,"\n%s%-*c",indent,(int)optlen,' '); } fputc('\n',file); } if (paradigm) free(paradigm); if (buf) free(buf); } #endif #endif