home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / compsrcs / misc / volume10 / parsergs.p1 < prev    next >
Encoding:
Internet Message Format  |  1991-08-27  |  15.2 KB
  1. From decwrl!ucbvax!tut.cis.ohio-state.edu!zaphod.mps.ohio-state.edu!usc!cs.utexas.edu!uunet!allbery Sat Mar  3 18:24:39 PST 1990
  2. Article 1346 of comp.sources.misc:
  3. Path: decwrl!ucbvax!tut.cis.ohio-state.edu!zaphod.mps.ohio-state.edu!usc!cs.utexas.edu!uunet!allbery
  4. From: peter@ficc.uu.net (Peter da Silva)
  5. Newsgroups: comp.sources.misc
  6. Subject: v10i075: Patches to parseargs posting
  7. Message-ID: <79684@uunet.UU.NET>
  8. Date: 21 Feb 90 02:11:01 GMT
  9. Sender: allbery@uunet.UU.NET
  10. Organization: Xenix Support, FICC
  11. Lines: 608
  12. Approved: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  13.  
  14. Posting-number: Volume 10, Issue 75
  15. Submitted-by: peter@ficc.uu.net (Peter da Silva)
  16. Archive-name: parseargs.p1
  17.  
  18. [A short pause while a large submission accretes... not this one.  ++bsa]
  19.  
  20. This set of patches covers the two complaints with the parseargs version
  21. I sent out a few days ago. First, lists are reversed before returning: I
  22. thought this would be easier on users than going to a doubly-linked list
  23. or circular list. Second, ARGLIST is now a *flag* instead of a type, so
  24. new list arguments can be implemented. I also fixed a potential bug in
  25. unix_args.c.
  26.  
  27. *** post/Makefile
  28. --- Makefile
  29. ***************
  30. *** 15,20 ****
  31. --- 15,21 ----
  32.   
  33.   OFILES=        ckalloc.o \
  34.           argtype.o \
  35. +         arglist.o \
  36.           fp_argtype.o \
  37.           funclist.o \
  38.           openpath.o \
  39. ***************
  40. *** 29,34 ****
  41. --- 30,36 ----
  42.   
  43.   CFILES=        ckalloc.c \
  44.           argtype.c \
  45. +         arglist.c \
  46.           fp_argtype.c \
  47.           funclist.c \
  48.           openpath.c \
  49. *** post/README.PDS
  50. --- README.PDS
  51. ***************
  52. *** 20,54 ****
  53.   The second change was to allow for a trailing list of arguments. I
  54.   originally implemented this by changing the calling sequence to parseargs.
  55.   On reflection this would just produce incompatibilities, so I added a
  56. ! new "type", argList. This handles a pointer to a list of names:
  57.   
  58. ! struct namelist {
  59. !     struct namelist *nl_next;
  60. !     char *nl_name;
  61. ! };
  62.   
  63. ! This is implemented with some "magic" in parseargs, and perhaps it would
  64. ! do better as an additional flag, ARGLIST, and a set of listType routines
  65. ! to handle them. Also, it currently keeps the list in LIFO order. It would
  66. ! be more convenient in FIFO order, though this would take a little more
  67. ! work to implement (basically just stepping through the list in argList to
  68. ! find the tail, instead of inserting at the head), and can be fixed in a
  69. ! single pass after parseargs returns with (say) !argv = reverselist(argv)!:
  70.   
  71. ! struct namelist *reverselist(from)
  72. ! struct namelist *from;
  73. ! {
  74. !     struct namelist *to, *tmp;
  75. ! 
  76. !     to = NULL;
  77. !     while(from) {
  78. !         tmp = from->nl_next; /* remove top from old list */
  79. !         from = from->nl_next;
  80. !         tmp->nl_next = to; /* insert top in new list */
  81. !         to = tmp;
  82. !     }
  83. !     return to;
  84. ! }
  85.   
  86.   The final change is the addition of a 'argChar' type. This parses character
  87.   arguments (such as the '-T' option to 'awk'), accepting single characters,
  88. --- 20,36 ----
  89.   The second change was to allow for a trailing list of arguments. I
  90.   originally implemented this by changing the calling sequence to parseargs.
  91.   On reflection this would just produce incompatibilities, so I added a
  92. ! new flag, ARGLIST, and a new type, listStr. Later, other kinds of lists
  93. ! can presumably be added. A list handles a pointer to a list of objects:
  94.   
  95. !     struct arglist *fred;
  96.   
  97. ! Operations are defined on arglists, L_NEXT(fred) produces the next element
  98. ! in fred. L_STRING(fred) produces the value of fred cast to "char *".
  99.   
  100. ! During evaluation the list is kept in LIFO order, and it's reversed just
  101. ! before returning to parseargs. This simplifies the coding of the list
  102. ! routines, but still lets you step through the list in a reasonable order.
  103.   
  104.   The final change is the addition of a 'argChar' type. This parses character
  105.   arguments (such as the '-T' option to 'awk'), accepting single characters,
  106. *** post/amiga_args.c
  107. --- amiga_args.c
  108. ***************
  109. *** 35,42 ****
  110.   #define ALL_AD        ad = argd; ad->ad_name != '\0'; ad++
  111.   #define ALL_DEFS    ad = _DefaultArgs; ad->ad_name != '\0'; ad++
  112.   
  113. ! char    *ProgName;
  114.   
  115.   #ifdef TRACESTUFF
  116.   extern BOOL    argTrace ARGS((ARGDESC *, char *, BOOL));
  117.   #endif
  118. --- 35,44 ----
  119.   #define ALL_AD        ad = argd; ad->ad_name != '\0'; ad++
  120.   #define ALL_DEFS    ad = _DefaultArgs; ad->ad_name != '\0'; ad++
  121.   
  122. ! #define HANDLE(a,n,f) ((*(a)->ad_type)(a,n,f))
  123.   
  124. + char    *ProgName;
  125. + 
  126.   #ifdef TRACESTUFF
  127.   extern BOOL    argTrace ARGS((ARGDESC *, char *, BOOL));
  128.   #endif
  129. ***************
  130. *** 100,106 ****
  131.           if(ad)
  132.           {
  133.               /* try to convert the type */
  134. !             if (!(*ad->ad_type)(ad, *av, FALSE))
  135.                   error = TRUE;
  136.               else
  137.                   ad->ad_flags |= ARGGIVEN;
  138. --- 102,108 ----
  139.           if(ad)
  140.           {
  141.               /* try to convert the type */
  142. !             if (!HANDLE(ad, *av, FALSE))
  143.                   error = TRUE;
  144.               else
  145.                   ad->ad_flags |= ARGGIVEN;
  146. ***************
  147. *** 130,136 ****
  148.               {
  149.                   p++;
  150.                   /* try to convert the type */
  151. !                 if (!(*ad->ad_type)(ad, p, FALSE))
  152.                       error = TRUE;
  153.                   else
  154.                       ad->ad_flags |= ARGGIVEN;
  155. --- 132,138 ----
  156.               {
  157.                   p++;
  158.                   /* try to convert the type */
  159. !                 if (!HANDLE(ad, p, FALSE))
  160.                       error = TRUE;
  161.                   else
  162.                       ad->ad_flags |= ARGGIVEN;
  163. ***************
  164. *** 150,156 ****
  165.                       ad->ad_flags |= ARGGIVEN;
  166.                       ad = NULL;
  167.                   }
  168. !                 else if (ad->ad_type == argList)
  169.                   {
  170.                       list = ad;
  171.                       ad = NULL;
  172. --- 152,158 ----
  173.                       ad->ad_flags |= ARGGIVEN;
  174.                       ad = NULL;
  175.                   }
  176. !                 else if (ad->ad_flags & ARGLIST)
  177.                   {
  178.                       list = ad;
  179.                       ad = NULL;
  180. ***************
  181. *** 160,166 ****
  182.           else /* it's a positional argument */
  183.           {
  184.               if(list) {
  185. !                 if (!argList(list, *av, FALSE))
  186.                       error = TRUE;
  187.                   list->ad_flags |= ARGGIVEN;
  188.                   continue;
  189. --- 162,168 ----
  190.           else /* it's a positional argument */
  191.           {
  192.               if(list) {
  193. !                 if (!HANDLE(list, *av, FALSE))
  194.                       error = TRUE;
  195.                   list->ad_flags |= ARGGIVEN;
  196.                   continue;
  197. ***************
  198. *** 170,176 ****
  199.                   for (ALL_AD)
  200.                   {
  201.                       if (ad->ad_name == ' ' &&
  202. !                         (ad->ad_type == argList ||
  203.                            !BITSET(ARGGIVEN, ad->ad_flags))
  204.                          )
  205.                           break;
  206. --- 172,178 ----
  207.                   for (ALL_AD)
  208.                   {
  209.                       if (ad->ad_name == ' ' &&
  210. !                         ( (ad->ad_flags & ARGLIST) ||
  211.                            !BITSET(ARGGIVEN, ad->ad_flags))
  212.                          )
  213.                           break;
  214. ***************
  215. *** 184,190 ****
  216.                   else
  217.                   {
  218.                       /* try to convert */
  219. !                     if (!(*ad->ad_type)(ad, *av, FALSE))
  220.                           error = TRUE;
  221.                       else
  222.                           ad->ad_flags |= ARGGIVEN;
  223. --- 186,192 ----
  224.                   else
  225.                   {
  226.                       /* try to convert */
  227. !                     if (!HANDLE(ad, *av, FALSE))
  228.                           error = TRUE;
  229.                       else
  230.                           ad->ad_flags |= ARGGIVEN;
  231. ***************
  232. *** 231,236 ****
  233. --- 233,239 ----
  234.           usage(argd);
  235.           exit(20);
  236.       }
  237. +     cleanup_lists(argd);
  238.   }
  239.    /*
  240.   **  USAGE -- print a usage message
  241. ***************
  242. *** 302,308 ****
  243.           }
  244.           if (!BITSET(ARGREQ, ad->ad_flags))
  245.               pl += 2;                /* [ ] */
  246. !         if (ad->ad_type == argList)
  247.               pl += 3;            /* ... */
  248.           pl += 1;                    /* leading sp */
  249.   
  250. --- 305,311 ----
  251.           }
  252.           if (!BITSET(ARGREQ, ad->ad_flags))
  253.               pl += 2;                /* [ ] */
  254. !         if (ad->ad_flags & ARGLIST)
  255.               pl += 3;            /* ... */
  256.           pl += 1;                    /* leading sp */
  257.   
  258. ***************
  259. *** 333,339 ****
  260.               fprintf(stderr, "<%s>", name);
  261.           if (!BITSET(ARGREQ, ad->ad_flags))
  262.               fprintf(stderr, "]");
  263. !         if (ad->ad_type == argList)
  264.               fprintf(stderr, "...");
  265.       }
  266.       fprintf(stderr, "\n");
  267. --- 336,342 ----
  268.               fprintf(stderr, "<%s>", name);
  269.           if (!BITSET(ARGREQ, ad->ad_flags))
  270.               fprintf(stderr, "]");
  271. !         if (ad->ad_flags & ARGLIST)
  272.               fprintf(stderr, "...");
  273.       }
  274.       fprintf(stderr, "\n");
  275. *** post/argtype.c
  276. --- argtype.c
  277. ***************
  278. *** 252,293 ****
  279.   {
  280.       return (FALSE);
  281.   }
  282. - 
  283. - BOOL
  284. - argList(ad, vp, copyf)
  285. -     register ARGDESC *ad;
  286. -     register char *vp;
  287. -     BOOL copyf;
  288. - {
  289. -     char *cp;
  290. -     struct namelist *nl;
  291. - 
  292. -     if (copyf)
  293. -     {
  294. -         register int i;
  295. - 
  296. -         i = strlen(vp) + 1;
  297. -         cp = (char *) malloc(i);
  298. -         if(!cp) {
  299. -             usrerr("out of memory saving string %s", ad->ad_prompt);
  300. -             return FALSE;
  301. -         }
  302. -         bcopy(vp, cp, i);
  303. -     }
  304. -     else
  305. -     {
  306. -         cp = vp;
  307. -     }
  308. - 
  309. -     nl = (struct namelist *) malloc(sizeof *nl);
  310. -     if(!nl) {
  311. -         usrerr("out of memory saving arg %s", ad->ad_prompt);
  312. -         if(copyf) free(cp);
  313. -         return FALSE;
  314. -     }
  315. - 
  316. -     nl->nl_next = *(struct namelist **) ad->ad_valp;
  317. -     nl->nl_name = cp;
  318. -     *(struct namelist **) ad->ad_valp = nl;
  319. -     return (TRUE);
  320. - }
  321. --- 252,254 ----
  322. *** post/parseargs.h
  323. --- parseargs.h
  324. ***************
  325. *** 31,36 ****
  326. --- 31,37 ----
  327.   #define ARGOPT        0x00    /* optional argument pseudo-flag */
  328.   #define ARGHIDDEN    0x02    /* don't display in usage message */
  329.   #define ARGGIVEN    0x08    /* (internal) argument has been specified */
  330. + #define ARGLIST        0x10    /* Argument is a list handler */
  331.   
  332.   /* types available for ad_type */
  333.   extern BOOL    argBool ARGS((ARGDESC *, char *, BOOL));
  334. ***************
  335. *** 41,52 ****
  336.   extern BOOL    argLong ARGS((ARGDESC *, char *, BOOL));
  337.   extern BOOL    argFloat ARGS((ARGDESC *, char *, BOOL));
  338.   extern BOOL    argDouble ARGS((ARGDESC *, char *, BOOL));
  339. ! extern BOOL    argList ARGS((ARGDESC *, char *, BOOL));
  340.   
  341. ! struct namelist {
  342. !     struct namelist *nl_next;
  343. !     char *nl_name;
  344.   };
  345.   
  346.   #define ENDOFARGS    { '\0' }
  347.   
  348. --- 42,56 ----
  349.   extern BOOL    argLong ARGS((ARGDESC *, char *, BOOL));
  350.   extern BOOL    argFloat ARGS((ARGDESC *, char *, BOOL));
  351.   extern BOOL    argDouble ARGS((ARGDESC *, char *, BOOL));
  352. ! extern BOOL    listStr ARGS((ARGDESC *, char *, BOOL));
  353.   
  354. ! struct arglist {
  355. !     struct arglist *nl_next;
  356. !     ARBPTR nl_val;
  357.   };
  358. + 
  359. + #define L_NEXT(l) ((l)->nl_next)        /* Next elt of list */
  360. + #define L_STRING(e) ((char *)((e)->nl_val))    /* Elt as a string */
  361.   
  362.   #define ENDOFARGS    { '\0' }
  363.   
  364. *** post/stest.c
  365. --- stest.c
  366. ***************
  367. *** 18,30 ****
  368.   BOOL    YFlag =        FALSE;
  369.   BOOL    ZFlag =        FALSE;
  370.   char    TabChar =    ':';
  371. ! struct namelist *Argv =    NULL;
  372. ! struct namelist *Groups = NULL;
  373.   
  374.   ARGDESC    Args[] =
  375.   {
  376.       ' ',    ARGREQ,        argStr,        __ &Name,    "Name",
  377. !     'n',    ARGOPT,        argList,    __ &Groups,    "newsGROUP",
  378.       'c',    ARGOPT,        argInt,        __ &RepCount,    "REPcount",
  379.       'd',    ARGOPT,        argStr,        __ &DirName,    "DIRname",
  380.       'x',    ARGOPT,        argBool,    __ &XFlag,    "Xflag",
  381. --- 18,30 ----
  382.   BOOL    YFlag =        FALSE;
  383.   BOOL    ZFlag =        FALSE;
  384.   char    TabChar =    ':';
  385. ! struct arglist *Argv =    NULL;
  386. ! struct arglist *Groups = NULL;
  387.   
  388.   ARGDESC    Args[] =
  389.   {
  390.       ' ',    ARGREQ,        argStr,        __ &Name,    "Name",
  391. !     'n',    ARGOPT|ARGLIST,    listStr,    __ &Groups,    "newsGROUP",
  392.       'c',    ARGOPT,        argInt,        __ &RepCount,    "REPcount",
  393.       'd',    ARGOPT,        argStr,        __ &DirName,    "DIRname",
  394.       'x',    ARGOPT,        argBool,    __ &XFlag,    "Xflag",
  395. ***************
  396. *** 31,37 ****
  397.       'y',    ARGOPT,        argBool,    __ &YFlag,    "Yflag",
  398.       'z',    ARGOPT,        argBool,    __ &ZFlag,    "Zflag",
  399.       't',    ARGOPT,        argChar,    __ &TabChar,    "TABchar",
  400. !     ' ',    ARGOPT,        argList,    __ &Argv,    "File",
  401.       ENDOFARGS
  402.   };
  403.   
  404. --- 31,37 ----
  405.       'y',    ARGOPT,        argBool,    __ &YFlag,    "Yflag",
  406.       'z',    ARGOPT,        argBool,    __ &ZFlag,    "Zflag",
  407.       't',    ARGOPT,        argChar,    __ &TabChar,    "TABchar",
  408. !     ' ',    ARGOPT|ARGLIST,    listStr,    __ &Argv,    "File",
  409.       ENDOFARGS
  410.   };
  411.   
  412. ***************
  413. *** 49,56 ****
  414.       if(Groups) {
  415.           printf("Newsgroups: ");
  416.           while(Groups) {
  417. !             printf("%s", Groups->nl_name);
  418. !             Groups = Groups->nl_next;
  419.               if(Groups)
  420.                   putchar(' ');
  421.               else
  422. --- 49,56 ----
  423.       if(Groups) {
  424.           printf("Newsgroups: ");
  425.           while(Groups) {
  426. !             printf("%s", L_STRING(Groups));
  427. !             Groups = L_NEXT(Groups);
  428.               if(Groups)
  429.                   putchar(' ');
  430.               else
  431. ***************
  432. *** 61,68 ****
  433.       if(Argv) {
  434.           printf("Remaining args: ");
  435.           while(Argv) {
  436. !             printf("%s", Argv->nl_name);
  437. !             Argv = Argv->nl_next;
  438.               if(Argv)
  439.                   putchar(' ');
  440.               else
  441. --- 61,68 ----
  442.       if(Argv) {
  443.           printf("Remaining args: ");
  444.           while(Argv) {
  445. !             printf("%s", L_STRING(Argv));
  446. !             Argv = L_NEXT(Argv);
  447.               if(Argv)
  448.                   putchar(' ');
  449.               else
  450. *** post/unix_args.c
  451. --- unix_args.c
  452. ***************
  453. *** 35,42 ****
  454.   #define ALL_AD        ad = argd; ad->ad_name != '\0'; ad++
  455.   #define ALL_DEFS    ad = _DefaultArgs; ad->ad_name != '\0'; ad++
  456.   
  457. ! char    *ProgName;
  458.   
  459.   #ifdef TRACESTUFF
  460.   extern BOOL    argTrace ARGS((ARGDESC *, char *, BOOL));
  461.   #endif
  462. --- 35,44 ----
  463.   #define ALL_AD        ad = argd; ad->ad_name != '\0'; ad++
  464.   #define ALL_DEFS    ad = _DefaultArgs; ad->ad_name != '\0'; ad++
  465.   
  466. ! #define HANDLE(a,n,f) ((*(a)->ad_type)(a,n,f))
  467.   
  468. + char    *ProgName;
  469. + 
  470.   #ifdef TRACESTUFF
  471.   extern BOOL    argTrace ARGS((ARGDESC *, char *, BOOL));
  472.   #endif
  473. ***************
  474. *** 176,186 ****
  475.                   }
  476.   
  477.                   /* try to convert the type */
  478. !                 if (!(*ad->ad_type)(ad, p, FALSE))
  479.                       error = TRUE;
  480.                   else
  481.                       ad->ad_flags |= ARGGIVEN;
  482. !                 if(ad->ad_type == argList)
  483.                       list = ad;
  484.                   else
  485.                       list = NULL;
  486. --- 178,188 ----
  487.                   }
  488.   
  489.                   /* try to convert the type */
  490. !                 if (!HANDLE(ad, p, FALSE))
  491.                       error = TRUE;
  492.                   else
  493.                       ad->ad_flags |= ARGGIVEN;
  494. !                 if(ad->ad_flags & ARGLIST)
  495.                       list = ad;
  496.                   else
  497.                       list = NULL;
  498. ***************
  499. *** 191,197 ****
  500.           {
  501.               /* parsing a list of arguments */
  502.               if(list) {
  503. !                 if (!argList(list, p, FALSE))
  504.                       error = TRUE;
  505.                   continue;
  506.               }
  507. --- 193,199 ----
  508.           {
  509.               /* parsing a list of arguments */
  510.               if(list) {
  511. !                 if (!HANDLE(list, p, FALSE))
  512.                       error = TRUE;
  513.                   continue;
  514.               }
  515. ***************
  516. *** 199,205 ****
  517.               for (ALL_AD)
  518.               {
  519.                   if (ad->ad_name == ' ' &&
  520. !                     (ad->ad_type == argList ||
  521.                        !BITSET(ARGGIVEN, ad->ad_flags))
  522.                       )
  523.                       break;
  524. --- 201,207 ----
  525.               for (ALL_AD)
  526.               {
  527.                   if (ad->ad_name == ' ' &&
  528. !                     ( (ad->ad_flags & ARGLIST) ||
  529.                        !BITSET(ARGGIVEN, ad->ad_flags))
  530.                       )
  531.                       break;
  532. ***************
  533. *** 212,218 ****
  534.               }
  535.   
  536.               /* try to convert */
  537. !             if (!(*ad->ad_type)(ad, p, FALSE))
  538.                   error = TRUE;
  539.               else
  540.                   ad->ad_flags |= ARGGIVEN;
  541. --- 214,220 ----
  542.               }
  543.   
  544.               /* try to convert */
  545. !             if (!HANDLE(ad, p, FALSE))
  546.                   error = TRUE;
  547.               else
  548.                   ad->ad_flags |= ARGGIVEN;
  549. ***************
  550. *** 242,248 ****
  551.                       usrerr("value required");
  552.                       continue;
  553.                   }
  554. !                 if ((*ad->ad_type)(ad, buf, TRUE))
  555.                   {
  556.                       ad->ad_flags |= ARGGIVEN;
  557.                       break;
  558. --- 244,250 ----
  559.                       usrerr("value required");
  560.                       continue;
  561.                   }
  562. !                 if (HANDLE(ad, buf, TRUE))
  563.                   {
  564.                       ad->ad_flags |= ARGGIVEN;
  565.                       break;
  566. ***************
  567. *** 274,280 ****
  568.           exit(2);
  569.       }
  570.   
  571. !     return argc;
  572.   }
  573.    /*
  574.   **  USAGE -- print a usage message
  575. --- 276,282 ----
  576.           exit(2);
  577.       }
  578.   
  579. !     cleanup_lists(argd);
  580.   }
  581.    /*
  582.   **  USAGE -- print a usage message
  583. ***************
  584. *** 327,333 ****
  585.           }
  586.           if (!BITSET(ARGREQ, ad->ad_flags))
  587.               pl += 2;                /* [ ] */
  588. !         if (ad->ad_type == argList)            /* ... */
  589.               pl += 3;
  590.           pl += 1;                    /* leading sp */
  591.   
  592. --- 329,335 ----
  593.           }
  594.           if (!BITSET(ARGREQ, ad->ad_flags))
  595.               pl += 2;                /* [ ] */
  596. !         if (ad->ad_flags & ARGLIST)            /* ... */
  597.               pl += 3;
  598.           pl += 1;                    /* leading sp */
  599.   
  600. ***************
  601. *** 358,364 ****
  602.               fprintf(stderr, "<%s>", ad->ad_prompt);
  603.           if (!BITSET(ARGREQ, ad->ad_flags))
  604.               fprintf(stderr, "]");
  605. !         if (ad->ad_type == argList)
  606.               fprintf(stderr, "...");
  607.       }
  608.       fprintf(stderr, "\n");
  609. --- 360,366 ----
  610.               fprintf(stderr, "<%s>", ad->ad_prompt);
  611.           if (!BITSET(ARGREQ, ad->ad_flags))
  612.               fprintf(stderr, "]");
  613. !         if (ad->ad_flags & ARGLIST)
  614.               fprintf(stderr, "...");
  615.       }
  616.       fprintf(stderr, "\n");
  617. -- 
  618.  _--_|\  Peter da Silva. +1 713 274 5180. <peter@ficc.uu.net>.
  619. /      \
  620. \_.--._/ Xenix Support -- it's not just a job, it's an adventure!
  621.       v  "Have you hugged your wolf today?" `-_-'
  622.  
  623.  
  624.