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