home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume20 / parseargs / patch06 / PATCH
Encoding:
Text File  |  1991-06-08  |  49.2 KB  |  1,533 lines
  1. *** Intro.OLD    Mon Jun  3 11:13:52 1991
  2. --- Intro    Wed May 22 14:47:07 1991
  3. ***************
  4. *** 83,89 ****
  5.   
  6.    And before you know it, your command-line had been parsed, all variables 
  7.    have been assigned their corresponding values from the command-line, syntax
  8. !  has been verified, and a usage message (if required) has been printed. 
  9.   
  10.    Under UNIX, the command-line syntax (using single character options) for the
  11.    above command would be:
  12. --- 83,89 ----
  13.   
  14.    And before you know it, your command-line had been parsed, all variables 
  15.    have been assigned their corresponding values from the command-line, syntax
  16. !  have been verified, and a usage message (if required) has been printed. 
  17.   
  18.    Under UNIX, the command-line syntax (using single character options) for the
  19.    above command would be:
  20. ***************
  21. *** 108,114 ****
  22.       cmdname [/a[=<areacode>]] [/g=<newsgroups>...] [/r=<repcount>]
  23.               [/s=<sepchar>] [/x]  <name>  [<args>...]
  24.   
  25. !   The AmigaDOS command-line syntax would be the following:
  26.   
  27.       cmdname [AREA [<areacode>]] [GROUPS <newsgroups>...] [REP <repcount>]
  28.               [SEP <sepchar>] [X]  <name>  [<args>...]
  29. --- 108,114 ----
  30.       cmdname [/a[=<areacode>]] [/g=<newsgroups>...] [/r=<repcount>]
  31.               [/s=<sepchar>] [/x]  <name>  [<args>...]
  32.   
  33. !  The AmigaDOS command-line syntax would be the following:
  34.   
  35.       cmdname [AREA [<areacode>]] [GROUPS <newsgroups>...] [REP <repcount>]
  36.               [SEP <sepchar>] [X]  <name>  [<args>...]
  37. *** README.OLD    Mon Jun  3 11:14:12 1991
  38. --- README    Wed May 22 14:56:09 1991
  39. ***************
  40. *** 290,295 ****
  41. --- 290,296 ----
  42.    I also added the capability to handle ARGVEC arguments into the
  43.    remaining argument type functions.
  44.   
  45. + 
  46.    NEW ARGUMENT FLAGS:
  47.    ===================
  48.    I added the following argument flags to parseargs:
  49. ***************
  50. *** 306,311 ****
  51. --- 307,313 ----
  52.   
  53.    Consult the manual page for parseargs(1) & parseargs(3) for more information.
  54.   
  55. + 
  56.    NEW INTERFACE
  57.    =============
  58.    I added a set of Macros to allow a more "self documenting" approach to
  59. ***************
  60. *** 336,341 ****
  61. --- 338,344 ----
  62.    variable.  See the parseargs(3) and parseargs(1) manual pages for more
  63.    information regarding USAGECNTL.
  64.   
  65. + 
  66.    SPECIFYING ALTERNATE PARSING BEHAVIOR
  67.    =====================================
  68.    Parseargs provides 3 methods for controlling "how" the command-line is
  69. ***************
  70. *** 351,356 ****
  71. --- 354,360 ----
  72.    See the manual pages for parseargs(1), parseargs(3), and parsecntl(3)
  73.    for more information.
  74.   
  75. + 
  76.    GIVING DEFAULT ARGUMENTS
  77.    ========================
  78.    Programs that use parseargs may be given default arguments under UNIX
  79. ***************
  80. *** 379,389 ****
  81.    relatively easy to add new shell-types. At this point in time, parseargs
  82.    will generate output for the following command-interpreters:
  83.   
  84. !      sh           (Bourne Shell)
  85. !      csh/tcsh     (C-Shell)
  86. !      bash         (Bourne-Again Shell)
  87. !      ksh          (Korn Shell)
  88. !      rc           (Plan 9 Shell)
  89.        perl
  90.        awk
  91.   
  92. --- 383,394 ----
  93.    relatively easy to add new shell-types. At this point in time, parseargs
  94.    will generate output for the following command-interpreters:
  95.   
  96. !      sh               (Bourne Shell)
  97. !      csh/tcsh/itcsh   (C-Shell)
  98. !      bash             (Bourne-Again Shell)
  99. !      ksh              (Korn Shell)
  100. !      rc               (Plan 9 Shell)
  101. !      zsh              (Z shell)
  102.        perl
  103.        awk
  104.   
  105. *** amiga_args.c.OLD    Mon Jun  3 11:14:17 1991
  106. --- amiga_args.c    Mon May 13 13:44:24 1991
  107. ***************
  108. *** 144,150 ****
  109.                  BSET( arg_flags(cmd_prev(cmd)), ARGGIVEN );
  110.               }
  111.               else {  /* value was required */
  112. !                (VOID)get_keyword( arg_sname(cmd_prev(cmd)), keyword );
  113.                  usrerr( "value required for %s keyword", keyword );
  114.                  parse_error = pe_SYNTAX;
  115.               }
  116. --- 144,150 ----
  117.                  BSET( arg_flags(cmd_prev(cmd)), ARGGIVEN );
  118.               }
  119.               else {  /* value was required */
  120. !                (VOID)get_kwdname( arg_sname(cmd_prev(cmd)), keyword );
  121.                  usrerr( "value required for %s keyword", keyword );
  122.                  parse_error = pe_SYNTAX;
  123.               }
  124. ***************
  125. *** 310,316 ****
  126.            BSET( arg_flags(cmd_prev(cmd)), ARGGIVEN );
  127.         }
  128.         else {  /* value was required */
  129. !          (VOID)get_keyword( arg_sname(cmd_prev(cmd)), keyword );
  130.            usrerr( "value required for %s keyword", keyword );
  131.            parse_error = pe_SYNTAX;
  132.         }
  133. --- 310,316 ----
  134.            BSET( arg_flags(cmd_prev(cmd)), ARGGIVEN );
  135.         }
  136.         else {  /* value was required */
  137. !          (VOID)get_kwdname( arg_sname(cmd_prev(cmd)), keyword );
  138.            usrerr( "value required for %s keyword", keyword );
  139.            parse_error = pe_SYNTAX;
  140.         }
  141. ***************
  142. *** 366,378 ****
  143.      char * pos;
  144.      argName_t  keyword, name;
  145.   
  146. !    (VOID) get_name(arg_sname(ad), name);
  147.   
  148.      if ( ARG_isPOSITIONAL(ad) ) {
  149.         sprintf( buf, "<%s>", name );
  150.      }
  151.      else {
  152. !       (VOID) get_keyword(arg_sname(ad), keyword);
  153.         (VOID) strcpy( buf, keyword );
  154.         pos = buf + strlen(buf);
  155.   
  156. --- 366,378 ----
  157.      char * pos;
  158.      argName_t  keyword, name;
  159.   
  160. !    (VOID) get_argname(arg_sname(ad), name);
  161.   
  162.      if ( ARG_isPOSITIONAL(ad) ) {
  163.         sprintf( buf, "<%s>", name );
  164.      }
  165.      else {
  166. !       (VOID) get_kwdname(arg_sname(ad), keyword);
  167.         (VOID) strcpy( buf, keyword );
  168.         pos = buf + strlen(buf);
  169.   
  170. *** arglist.c.OLD    Mon Jun  3 11:14:22 1991
  171. --- arglist.c    Mon May 13 13:44:24 1991
  172. ***************
  173. *** 94,100 ****
  174.      ArgListHead *nl;
  175.      ArgList *nd;
  176.   
  177. !    (VOID) get_name( arg_sname(ad), argname );
  178.      if (copyf) {
  179.         register int i;
  180.   
  181. --- 94,100 ----
  182.      ArgListHead *nl;
  183.      ArgList *nd;
  184.   
  185. !    (VOID) get_argname( arg_sname(ad), argname );
  186.      if (copyf) {
  187.         register int i;
  188.   
  189. *** argtype.c.OLD    Mon Jun  3 11:14:26 1991
  190. --- argtype.c    Mon May 13 13:44:25 1991
  191. ***************
  192. *** 202,208 ****
  193.      char *cp;
  194.      argName_t  argname;
  195.   
  196. !    (VOID) get_name( arg_sname(ad), argname );
  197.      if (copyf) {
  198.         register int i;
  199.   
  200. --- 202,208 ----
  201.      char *cp;
  202.      argName_t  argname;
  203.   
  204. !    (VOID) get_argname( arg_sname(ad), argname );
  205.      if (copyf) {
  206.         register int i;
  207.   
  208. ***************
  209. *** 270,276 ****
  210.      int status = FALSE;
  211.      char c;
  212.   
  213. !    (VOID) get_name( arg_sname(ad), argname );
  214.      if (!vp || !*vp) {
  215.         status = FALSE;
  216.      }
  217. --- 270,276 ----
  218.      int status = FALSE;
  219.      char c;
  220.   
  221. !    (VOID) get_argname( arg_sname(ad), argname );
  222.      if (!vp || !*vp) {
  223.         status = FALSE;
  224.      }
  225. ***************
  226. *** 340,346 ****
  227.      argName_t  argname; \
  228.      num_t  value; \
  229.    \
  230. !    (VOID) get_name( arg_sname(ad), argname ); \
  231.      value = (num_t) strtol(vp, &vpp, 0); \
  232.      if (*vpp != '\0') { \
  233.         usrerr("invalid integer argument '%s' for %s", vp, argname); \
  234. --- 340,346 ----
  235.      argName_t  argname; \
  236.      num_t  value; \
  237.    \
  238. !    (VOID) get_argname( arg_sname(ad), argname ); \
  239.      value = (num_t) strtol(vp, &vpp, 0); \
  240.      if (*vpp != '\0') { \
  241.         usrerr("invalid integer argument '%s' for %s", vp, argname); \
  242. ***************
  243. *** 401,407 ****
  244.      argName_t  argname; \
  245.      dec_t  value; \
  246.    \
  247. !    (VOID) get_name( arg_sname(ad), argname ); \
  248.      value = (dec_t) strtod(vp, &vpp); \
  249.      if (*vpp != '\0') { \
  250.         usrerr("invalid decimal argument '%s' for %s", vp, argname); \
  251. --- 401,407 ----
  252.      argName_t  argname; \
  253.      dec_t  value; \
  254.    \
  255. !    (VOID) get_argname( arg_sname(ad), argname ); \
  256.      value = (dec_t) strtod(vp, &vpp); \
  257.      if (*vpp != '\0') { \
  258.         usrerr("invalid decimal argument '%s' for %s", vp, argname); \
  259. ***************
  260. *** 504,510 ****
  261.      argName_t  argname;
  262.      int len;
  263.   
  264. !    (VOID) get_name( arg_sname(ad), argname );
  265.   
  266.      /* ARGVECs are not supported for this Boolean arg-types */
  267.      if ( ARG_isVEC(ad) )
  268. --- 504,510 ----
  269.      argName_t  argname;
  270.      int len;
  271.   
  272. !    (VOID) get_argname( arg_sname(ad), argname );
  273.   
  274.      /* ARGVECs are not supported for this Boolean arg-types */
  275.      if ( ARG_isVEC(ad) )
  276. ***************
  277. *** 574,580 ****
  278.      argName_t  argname;
  279.      BOOL  retval;
  280.   
  281. !    (VOID) get_name( arg_sname(ad), argname );
  282.   
  283.      /* ARGVECs are not supported for this Boolean arg-types */
  284.      if ( ARG_isVEC(ad) )
  285. --- 574,580 ----
  286.      argName_t  argname;
  287.      BOOL  retval;
  288.   
  289. !    (VOID) get_argname( arg_sname(ad), argname );
  290.   
  291.      /* ARGVECs are not supported for this Boolean arg-types */
  292.      if ( ARG_isVEC(ad) )
  293. ***************
  294. *** 596,602 ****
  295.      argName_t  argname;
  296.      BOOL  retval;
  297.   
  298. !    (VOID) get_name( arg_sname(ad), argname );
  299.   
  300.      /* ARGVECs are not supported for this Boolean arg-types */
  301.      if ( ARG_isVEC(ad) )
  302. --- 596,602 ----
  303.      argName_t  argname;
  304.      BOOL  retval;
  305.   
  306. !    (VOID) get_argname( arg_sname(ad), argname );
  307.   
  308.      /* ARGVECs are not supported for this Boolean arg-types */
  309.      if ( ARG_isVEC(ad) )
  310. ***************
  311. *** 618,624 ****
  312.      argName_t  argname;
  313.      BOOL  retval;
  314.   
  315. !    (VOID) get_name( arg_sname(ad), argname );
  316.   
  317.      /* ARGVECs are not supported for this Boolean arg-types */
  318.      if ( ARG_isVEC(ad) )
  319. --- 618,624 ----
  320.      argName_t  argname;
  321.      BOOL  retval;
  322.   
  323. !    (VOID) get_argname( arg_sname(ad), argname );
  324.   
  325.      /* ARGVECs are not supported for this Boolean arg-types */
  326.      if ( ARG_isVEC(ad) )
  327. *** doc/Makefile.OLD    Mon Jun  3 11:14:32 1991
  328. --- doc/Makefile    Tue May 14 14:38:21 1991
  329. ***************
  330. *** 144,150 ****
  331.   clobber: clean
  332.       ${DEL} *.txt
  333.   
  334. ! spell: ${INCS} ${SRCS}}
  335.       ${SPELL} ${SPELLFLAGS} ${INCS} ${SRCS}
  336.   
  337.   print: ${MANFILES} ${INCS}
  338. --- 144,150 ----
  339.   clobber: clean
  340.       ${DEL} *.txt
  341.   
  342. ! spell: ${INCS} ${SRCS}
  343.       ${SPELL} ${SPELLFLAGS} ${INCS} ${SRCS}
  344.   
  345.   print: ${MANFILES} ${INCS}
  346. *** doc/argdesc.inc.OLD    Mon Jun  3 11:14:40 1991
  347. --- doc/argdesc.inc    Sat May 11 12:17:40 1991
  348. ***************
  349. *** 49,57 ****
  350.   description (the description must be separated from the long-name by
  351.   at least one whitespace character and may optionally be enclosed in
  352.   a set of balanced delimiters (such as parentheses, curly-braces,
  353. ! square-brackets, or angle-brackets). If the long-name contains any
  354.   uppercase characters, then the substring of long-name consisting of
  355. ! all uppercase characters is used as the argument keyword and the entire
  356. ! long-name is used as the name of the argument (if a value may be
  357. ! supplied). The long-name may be matched by supplying a unique prefix
  358. ! of either the argument keyword or the argument name.
  359. --- 49,63 ----
  360.   description (the description must be separated from the long-name by
  361.   at least one whitespace character and may optionally be enclosed in
  362.   a set of balanced delimiters (such as parentheses, curly-braces,
  363. ! square-brackets, or angle-brackets). The longname may be specifed
  364. ! in two parts: a keyword name and an argument name. The argument
  365. ! name may be separated from the keyword name by a single equal sign
  366. ! (`='). No whitespace is allowed before or after the equal sign.
  367. ! 
  368. ! Alternatatively, the keyword name may be distinguished from the
  369. ! argument name by character case: if the long-name contains any
  370.   uppercase characters, then the substring of long-name consisting of
  371. ! all uppercase characters is used as the argument keyword and the
  372. ! entire long-name is used as the name of the argument (if a value may
  373. ! be supplied). The long-name may be matched by supplying a unique
  374. ! prefix of either the argument keyword or the argument name.
  375. *** doc/parseargs.man1.OLD    Mon Jun  3 11:15:49 1991
  376. --- doc/parseargs.man1    Sat May 11 12:20:43 1991
  377. ***************
  378. *** 158,163 ****
  379. --- 158,176 ----
  380.   and printed in usage messages. This string may be followed by a
  381.   textual description that is enclosed in parentheses, square brackets,
  382.   curly braces, or angle brackets.
  383. + 
  384. + The prompt-string may be specifed
  385. + in two parts: a keyword name and an argument name. The argument
  386. + name may be separated from the keyword name by a single equal sign
  387. + ('='). No whitespace is allowed before or after the equal sign.
  388. + 
  389. + Alternatatively, the keyword name may be distinguished from the
  390. + argument name by character case: if the long-name contains any
  391. + uppercase characters, then the substring of long-name consisting of
  392. + all uppercase characters is used as the argument keyword and the
  393. + entire long-name is used as the name of the argument (if a value may
  394. + be supplied). The long-name may be matched by supplying a unique
  395. + prefix of either the argument keyword or the argument name.
  396.   .PP
  397.   The argument specification string must be terminated by the single string:
  398.   ``ENDOFARGS''.
  399. *** doc/returns.inc.OLD    Mon Jun  3 11:16:33 1991
  400. --- doc/returns.inc    Mon May 20 17:36:20 1991
  401. ***************
  402. *** 28,35 ****
  403.   .IP "\fIpe_\s-1NOMATCH\s+1\fP"
  404.   Unable to match the named argument. This occurs
  405.   when the argument keyword name passed to \fIparsecntl\fP (using the 
  406. ! \fIpc_\s-1ARGFLAGS\s+1\fP functions code) was found in the given argdesc-array
  407. ! or in its default-list.
  408.   .\"---------------------------------------------
  409.   .IP "\fIpe_\s-1BADMODE\s+1\fP"
  410.   Bad mode for given command in \fIparsecntl\fP. This occurs when 
  411. --- 28,35 ----
  412.   .IP "\fIpe_\s-1NOMATCH\s+1\fP"
  413.   Unable to match the named argument. This occurs
  414.   when the argument keyword name passed to \fIparsecntl\fP (using the 
  415. ! \fIpc_\s-1ARGFLAGS\s+1\fP functions code) was NOT found in the given
  416. ! argdesc-array or in its default-list.
  417.   .\"---------------------------------------------
  418.   .IP "\fIpe_\s-1BADMODE\s+1\fP"
  419.   Bad mode for given command in \fIparsecntl\fP. This occurs when 
  420. *** ibm_args.c.OLD    Mon Jun  3 11:17:03 1991
  421. --- ibm_args.c    Mon May 13 13:44:26 1991
  422. ***************
  423. *** 301,307 ****
  424.                     BSET( arg_flags(ad), ARGGIVEN );
  425.                  }
  426.                  else {
  427. !                   (VOID) get_keyword( arg_sname(ad), name );
  428.                     usrerr("%c%s switch requires an argument", KwdPrefix, name);
  429.                     arg_flags(ad) = flags;
  430.                     parse_error = pe_SYNTAX;
  431. --- 301,307 ----
  432.                     BSET( arg_flags(ad), ARGGIVEN );
  433.                  }
  434.                  else {
  435. !                   (VOID) get_kwdname( arg_sname(ad), name );
  436.                     usrerr("%c%s switch requires an argument", KwdPrefix, name);
  437.                     arg_flags(ad) = flags;
  438.                     parse_error = pe_SYNTAX;
  439. ***************
  440. *** 429,435 ****
  441.                        BSET( arg_flags(ad), ARGGIVEN );
  442.                     }
  443.                     else {
  444. !                      (VOID) get_name(arg_sname(ad), name);
  445.                        usrerr( "%s required for %c%c flag",
  446.                                name, OptPrefix, arg_cname(ad) );
  447.                        arg_flags(ad) = flags;
  448. --- 429,435 ----
  449.                        BSET( arg_flags(ad), ARGGIVEN );
  450.                     }
  451.                     else {
  452. !                      (VOID) get_argname(arg_sname(ad), name);
  453.                        usrerr( "%s required for %c%c flag",
  454.                                name, OptPrefix, arg_cname(ad) );
  455.                        arg_flags(ad) = flags;
  456. ***************
  457. *** 585,597 ****
  458.      char *pos;
  459.      argName_t   name, keyword;
  460.   
  461. !    (VOID) get_name( arg_sname(ad), name );
  462.   
  463.      if (ARG_isPOSITIONAL(ad)) {
  464.         sprintf( buf, "<%s>", name );
  465.      }
  466.      else {
  467. !       (VOID) get_keyword( arg_sname(ad), keyword );
  468.   
  469.         if ( isupper(arg_cname(ad))  &&  toupper(*keyword) == arg_cname(ad) ) {
  470.            *keyword = toupper(*keyword);
  471. --- 585,597 ----
  472.      char *pos;
  473.      argName_t   name, keyword;
  474.   
  475. !    (VOID) get_argname( arg_sname(ad), name );
  476.   
  477.      if (ARG_isPOSITIONAL(ad)) {
  478.         sprintf( buf, "<%s>", name );
  479.      }
  480.      else {
  481. !       (VOID) get_kwdname( arg_sname(ad), keyword );
  482.   
  483.         if ( isupper(arg_cname(ad))  &&  toupper(*keyword) == arg_cname(ad) ) {
  484.            *keyword = toupper(*keyword);
  485. *** parseargs.awk.OLD    Mon Jun  3 11:17:09 1991
  486. --- parseargs.awk    Wed May 15 10:03:26 1991
  487. ***************
  488. *** 40,46 ****
  489.   ##    The following global variables may be assigned before calling parseargs:
  490.   ##
  491.   ##       PROGNAME -- name of the current awk script (default= ARGV[0])
  492. ! ##       PARSEOPTS -- any extra options to pass toi parseargs() (default="-ul")
  493.   ##       PARSEINPUT -- input file for parseargs(1) (default=unique-name)
  494.   ##       PARSEOUTPUT -- output file for parseargs(1) (default=unique-name)
  495.   ##
  496. --- 40,46 ----
  497.   ##    The following global variables may be assigned before calling parseargs:
  498.   ##
  499.   ##       PROGNAME -- name of the current awk script (default= ARGV[0])
  500. ! ##       PARSEOPTS -- any extra options to pass to parseargs() (default="-ul")
  501.   ##       PARSEINPUT -- input file for parseargs(1) (default=unique-name)
  502.   ##       PARSEOUTPUT -- output file for parseargs(1) (default=unique-name)
  503.   ##
  504. *** parseargs.c.OLD    Mon Jun  3 11:17:16 1991
  505. --- parseargs.c    Thu May 16 16:51:21 1991
  506. ***************
  507. *** 1092,1098 ****
  508.   #endif
  509.   {
  510.      int  i;
  511. !    register char *sh = sh_str;
  512.   
  513.         /* special case to recognize tcsh & itcsh */
  514.      if ( strEQ( sh, "tcsh" ) )  ++sh;
  515. --- 1092,1098 ----
  516.   #endif
  517.   {
  518.      int  i;
  519. !    register CONST char *sh = sh_str;
  520.   
  521.         /* special case to recognize tcsh & itcsh */
  522.      if ( strEQ( sh, "tcsh" ) )  ++sh;
  523. *** parseargs.h.OLD    Mon Jun  3 11:17:24 1991
  524. --- parseargs.h    Mon May 20 17:35:46 1991
  525. ***************
  526. *** 97,103 ****
  527.   **       description (the description must be separated from the long-name by
  528.   **       at least one whitespace character and may optionally be enclosed in
  529.   **       a set of balanced delimiters (such as parentheses, curly-braces,
  530. ! **       square-brackets, or angle-brackets). If the long-name contains any
  531.   **       uppercase characters, then the substring of long-name consisting of
  532.   **       all uppercase characters is used as the argument keyword and the
  533.   **       entire long-name is used as the name of the argument (if a value may
  534. --- 97,108 ----
  535.   **       description (the description must be separated from the long-name by
  536.   **       at least one whitespace character and may optionally be enclosed in
  537.   **       a set of balanced delimiters (such as parentheses, curly-braces,
  538. ! **       square-brackets, or angle-brackets). The longname may be specifed
  539. ! **       in two parts: a keyword name and an argument name. The argument
  540. ! **       name may be separated from the keyword name by a single equal sign
  541. ! **       ('='). No whitespace is allowed before or after the equal sign.
  542. ! **       Alternatatively, the keyword name may be distinguished from the
  543. ! **       argument name by character case: if the long-name contains any
  544.   **       uppercase characters, then the substring of long-name consisting of
  545.   **       all uppercase characters is used as the argument keyword and the
  546.   **       entire long-name is used as the name of the argument (if a value may
  547. ***************
  548. *** 140,146 ****
  549.   #define  pe_NOMATCH   3
  550.   /*    -- unable to match the named argument. This occurs
  551.   **       when the argument keyword name passed to parsecntl() (using the 
  552. ! **       pc_ARGFLAGS functions code) was found in the given argdesc-array
  553.   **       or in its default-list.
  554.   */
  555.   #define  pe_BADMODE   4
  556. --- 145,151 ----
  557.   #define  pe_NOMATCH   3
  558.   /*    -- unable to match the named argument. This occurs
  559.   **       when the argument keyword name passed to parsecntl() (using the 
  560. ! **       pc_ARGFLAGS function code) was NOT found in the given argdesc-array
  561.   **       or in its default-list.
  562.   */
  563.   #define  pe_BADMODE   4
  564. *** parseargs.pl.OLD    Mon Jun  3 11:17:30 1991
  565. --- parseargs.pl    Wed May 15 10:02:06 1991
  566. ***************
  567. *** 39,45 ****
  568.   ;#    The global variable PARSEARGS will contain the command-line used to
  569.   ;#    invoke parseargs(1).
  570.   ;#
  571. ! ;#    ARGV and ARGC may be reset, all other values are (re)set in <arr>.
  572.   ;#
  573.   ;# ^RETURN-VALUE:
  574.   ;#    The exit code returned by parseargs(1).
  575. --- 39,45 ----
  576.   ;#    The global variable PARSEARGS will contain the command-line used to
  577.   ;#    invoke parseargs(1).
  578.   ;#
  579. ! ;#    ARGV and (and any other variables named in <argd>) may be overwritten.
  580.   ;#
  581.   ;# ^RETURN-VALUE:
  582.   ;#    The exit code returned by parseargs(1).
  583. *** patchlevel.h.OLD    Mon Jun  3 11:17:35 1991
  584. --- patchlevel.h    Mon Jun  3 10:35:24 1991
  585. ***************
  586. *** 2,7 ****
  587. --- 2,21 ----
  588.   ** ^FILE: patchlevel.h - current patchlevel for parseargs
  589.   **
  590.   ** ^HISTORY:
  591. + **    05/11/91    Brad Appleton    <brad@ssd.csd.harris.com>
  592. + **    Patch06
  593. + **    - parsecntl(3) now correctly handles mispelled keywords for the
  594. + **      pc_ARGFLAGS request (it was looping forever).
  595. + **    - fixed an error in the documentation (a "NOT" was omitted).
  596. + **    - added #ifdef SVR4 stuff to unix_man.c to print System V Release 4
  597. + **      style manual pages.
  598. + **    - allowed "sname=aname" syntax in the ad_prompt field of an ARGDESC
  599. + **      in addition to the existing syntax. This new syntax allows argument
  600. + **      names to be be completely different from keyword names.
  601. + **    - changed get_name() & get_keyword to get_argname() & get_kwdname()
  602. + **      (respectively) in strfuncs.[ch]. Also sped up the algorithm to get
  603. + **      the keyword (since it no longer needs malloc).
  604. + **
  605.   **    04/25/91    Brad Appleton    <brad@ssd.csd.harris.com>
  606.   **    Patch05
  607.   **    - documented support for zsh in parseargs(1)
  608. ***************
  609. *** 66,72 ****
  610.   
  611.   #define  VERSION     2
  612.   #define  REVISION    0
  613. ! #define  PATCHLEVEL  5
  614.   
  615.   #ifdef __STDC__
  616.      static const char
  617. --- 80,86 ----
  618.   
  619.   #define  VERSION     2
  620.   #define  REVISION    0
  621. ! #define  PATCHLEVEL  6
  622.   
  623.   #ifdef __STDC__
  624.      static const char
  625. ***************
  626. *** 73,76 ****
  627.   #else
  628.      static char
  629.   #endif
  630. !    _Ident[] = "@(#)parseargs  2.0  patchlevel 5";
  631. --- 87,90 ----
  632.   #else
  633.      static char
  634.   #endif
  635. !    _Ident[] = "@(#)parseargs  2.0  patchlevel 6";
  636. *** stest.c.OLD    Mon Jun  3 11:17:47 1991
  637. --- stest.c    Mon Jun  3 10:34:00 1991
  638. ***************
  639. *** 115,121 ****
  640.      'n', ARGREQ|ARGPOS, argStr,  __ &Name,  "name (name to look for)",
  641.      's', ARGVALOPT, argStr,  __ &Str,       "STRing (optional string to use)",
  642.      'g', ARGVEC,    argStr,  __ &Groups,    "newsGROUPS (newsgroups to test)",
  643. !    'c', ARGOPT,    argInt,  __ &RepCount,  "REPcount (repeat count per group)",
  644.      'd', ARGOPT,    argStr,   __ &DirName,  "DIRname (work directory)",
  645.      'i', ARGVEC,    argInt,   __ &Integers, "INTegerS (vector of numbers)",
  646.      '#', ARGHIDDEN, argBool,  __ &XRated,   "XratedMODE (naughty! naughty!)",
  647. --- 115,121 ----
  648.      'n', ARGREQ|ARGPOS, argStr,  __ &Name,  "name (name to look for)",
  649.      's', ARGVALOPT, argStr,  __ &Str,       "STRing (optional string to use)",
  650.      'g', ARGVEC,    argStr,  __ &Groups,    "newsGROUPS (newsgroups to test)",
  651. !    'c', ARGOPT,    argInt,  __ &RepCount,  "REP=count (repeat count per group)",
  652.      'd', ARGOPT,    argStr,   __ &DirName,  "DIRname (work directory)",
  653.      'i', ARGVEC,    argInt,   __ &Integers, "INTegerS (vector of numbers)",
  654.      '#', ARGHIDDEN, argBool,  __ &XRated,   "XratedMODE (naughty! naughty!)",
  655. ***************
  656. *** 124,130 ****
  657.      'y', ARGOPT, argUBool, __ &YFlag, "Yflag (unset Y flag)",
  658.      'z', ARGOPT, argTBool, __ &ZFlag, "Zflag (toggle Z flag)",
  659.   
  660. !    't', ARGOPT,   argChar, __ &TabChar, "TABchar (field delimiter)",
  661.      'r', ARGNOVAL, argMine, __ NULL,     "raw (trigger raw-mode \
  662.   before processing any more arguments on the command-line)",
  663.   
  664. --- 124,130 ----
  665.      'y', ARGOPT, argUBool, __ &YFlag, "Yflag (unset Y flag)",
  666.      'z', ARGOPT, argTBool, __ &ZFlag, "Zflag (toggle Z flag)",
  667.   
  668. !    't', ARGOPT,   argChar, __ &TabChar, "TAB=char (field delimiter)",
  669.      'r', ARGNOVAL, argMine, __ NULL,     "raw (trigger raw-mode \
  670.   before processing any more arguments on the command-line)",
  671.   
  672. ***************
  673. *** 143,149 ****
  674.      'n', ARGREQ|ARGPOS, argStr,  __ &Name,  "name (name to look for)",
  675.      's', ARGVALOPT, argStr,  __ &Str,       "STRing (optional string to use)",
  676.      'g', ARGVEC,    argStr,  __ &Groups,    "newsGROUPS (newsgroups to test)",
  677. !    'c', ARGOPT,    argInt,  __ &RepCount,  "REPcount (repeat count per group)",
  678.      'd', ARGOPT,    argStr,   __ &DirName,  "DIRname (work directory)",
  679.      'i', ARGVEC,    argInt,   __ &Integers, "INTegerS (vector of numbers)",
  680.      '#', ARGHIDDEN, argBool,  __ &XRated,   "XratedMODE (naughty! naughty!)",
  681. --- 143,149 ----
  682.      'n', ARGREQ|ARGPOS, argStr,  __ &Name,  "name (name to look for)",
  683.      's', ARGVALOPT, argStr,  __ &Str,       "STRing (optional string to use)",
  684.      'g', ARGVEC,    argStr,  __ &Groups,    "newsGROUPS (newsgroups to test)",
  685. !    'c', ARGOPT,    argInt,  __ &RepCount,  "REP=count (repeat count per group)",
  686.      'd', ARGOPT,    argStr,   __ &DirName,  "DIRname (work directory)",
  687.      'i', ARGVEC,    argInt,   __ &Integers, "INTegerS (vector of numbers)",
  688.      '#', ARGHIDDEN, argBool,  __ &XRated,   "XratedMODE (naughty! naughty!)",
  689. ***************
  690. *** 152,158 ****
  691.      'y', ARGOPT, argUBool, __ &YFlag, "Yflag (unset Y flag)",
  692.      'z', ARGOPT, argTBool, __ &ZFlag, "Zflag (toggle Z flag)",
  693.   
  694. !    't', ARGOPT,   argChar, __ &TabChar, "TABchar (field delimiter)",
  695.      'r', ARGNOVAL, argMine, __ NULL,     "raw (trigger raw-mode \
  696.   before processing any more arguments on the command-line)",
  697.   
  698. --- 152,158 ----
  699.      'y', ARGOPT, argUBool, __ &YFlag, "Yflag (unset Y flag)",
  700.      'z', ARGOPT, argTBool, __ &ZFlag, "Zflag (toggle Z flag)",
  701.   
  702. !    't', ARGOPT,   argChar, __ &TabChar, "TAB=char (field delimiter)",
  703.      'r', ARGNOVAL, argMine, __ NULL,     "raw (trigger raw-mode \
  704.   before processing any more arguments on the command-line)",
  705.   
  706. ***************
  707. *** 258,264 ****
  708.      printf( "XRated=%d, Raw-Mode = \"%s\"\n", XRated, Mode );
  709.   
  710.         /* to call parsecntl() to see if the optional value was supplied */
  711. !    (VOID) parsecntl( (ARGDESC *)argd, pc_ARGFLAGS, pc_READ, "string", &flags);
  712.   
  713.      if ( BTEST(flags, ARGGIVEN) && !BTEST(flags, ARGVALGIVEN) ) {
  714.         printf("String=!No Value Given on CmdLine!\n" );
  715. --- 258,264 ----
  716.      printf( "XRated=%d, Raw-Mode = \"%s\"\n", XRated, Mode );
  717.   
  718.         /* to call parsecntl() to see if the optional value was supplied */
  719. !    i = parsecntl( (ARGDESC *)argd, pc_ARGFLAGS, pc_READ, "string", &flags);
  720.   
  721.      if ( BTEST(flags, ARGGIVEN) && !BTEST(flags, ARGVALGIVEN) ) {
  722.         printf("String=!No Value Given on CmdLine!\n" );
  723. *** strfuncs.c.OLD    Mon Jun  3 11:17:52 1991
  724. --- strfuncs.c    Wed May 15 14:33:16 1991
  725. ***************
  726. *** 23,30 ****
  727.   **       strtrim() -- trim leading and trailing characters in a string
  728.   **       strsplit() -- split a string up into a vector of tokens
  729.   **       strjoin() -- join a vector of tokens into a single string
  730. ! **       get_name() -- return the aname (argument-name) of an argument
  731. ! **       get_keyword() -- return the sname (keyword-name) of an argument
  732.   **       match() -- match two keywords (case insensitive) upto a unique prefix
  733.   **       basename() -- remove the leading directories (and disks) from a path
  734.   **       indent_para() -- print an indented hanging paragraph
  735. --- 23,30 ----
  736.   **       strtrim() -- trim leading and trailing characters in a string
  737.   **       strsplit() -- split a string up into a vector of tokens
  738.   **       strjoin() -- join a vector of tokens into a single string
  739. ! **       get_argname() -- return the aname (argument-name) of an argument
  740. ! **       get_kwdname() -- return the sname (keyword-name) of an argument
  741.   **       match() -- match two keywords (case insensitive) upto a unique prefix
  742.   **       basename() -- remove the leading directories (and disks) from a path
  743.   **       indent_para() -- print an indented hanging paragraph
  744. ***************
  745. *** 47,57 ****
  746.   
  747.   static CONST char WhiteSpace[] = " \t\n\r\v\f";
  748.   
  749. ! 
  750.   #if ( defined(unix_style)  ||  defined(ibm_style) )
  751.   # define  TO_KWDCASE(c)  TOLOWER(c)
  752.   #else
  753.   # define  TO_KWDCASE(c)  TOUPPER(c)
  754.   #endif
  755.   
  756.   
  757. --- 47,59 ----
  758.   
  759.   static CONST char WhiteSpace[] = " \t\n\r\v\f";
  760.   
  761. ! #define c_ARG_SEP '='
  762.   #if ( defined(unix_style)  ||  defined(ibm_style) )
  763.   # define  TO_KWDCASE(c)  TOLOWER(c)
  764. + # define  KWDCASECOPY(dest,src)  strlcpy(dest,src)
  765.   #else
  766.   # define  TO_KWDCASE(c)  TOUPPER(c)
  767. + # define  KWDCASECOPY(dest,src)  strucpy(dest,src)
  768.   #endif
  769.   
  770.   
  771. ***************
  772. *** 746,757 ****
  773.   
  774.   
  775.   /***************************************************************************
  776. ! ** ^FUNCTION: get_name - return the aname (argument-name) of an argument
  777.   **
  778.   ** ^SYNOPSIS:
  779.   */
  780.   #ifndef __ANSI_C__
  781. !    char  *get_name( s, buf )
  782.   /*
  783.   ** ^PARAMETERS:
  784.   */
  785. --- 748,759 ----
  786.   
  787.   
  788.   /***************************************************************************
  789. ! ** ^FUNCTION: get_argname - return the aname (argument-name) of an argument
  790.   **
  791.   ** ^SYNOPSIS:
  792.   */
  793.   #ifndef __ANSI_C__
  794. !    char  *get_argname( s, buf )
  795.   /*
  796.   ** ^PARAMETERS:
  797.   */
  798. ***************
  799. *** 764,770 ****
  800.   #endif  /* !__ANSI_C__ */
  801.   
  802.   /* ^DESCRIPTION:
  803. ! **    Get_name will get the full argument name of the given argument
  804.   **    (not just the keyword name) and copy it to buf.
  805.   **
  806.   ** ^REQUIREMENTS:
  807. --- 766,772 ----
  808.   #endif  /* !__ANSI_C__ */
  809.   
  810.   /* ^DESCRIPTION:
  811. ! **    Get_argname will get the full argument name of the given argument
  812.   **    (not just the keyword name) and copy it to buf.
  813.   **
  814.   ** ^REQUIREMENTS:
  815. ***************
  816. *** 782,803 ****
  817.   **    and copy the result in the given buffer
  818.   ***^^**********************************************************************/
  819.   #ifdef __ANSI_C__
  820. !    char *get_name( const char *s, char *buf )
  821.   #endif
  822.   {
  823. !       /* <buf> must be large enough to hold the result! */
  824. !    strlcpy(buf, s);
  825.      return   buf;
  826.   }
  827.   
  828.   
  829.   /***************************************************************************
  830. ! ** ^FUNCTION: get_keyword - get the sname (keyword name) of an argument
  831.   **
  832.   ** ^SYNOPSIS:
  833.   */
  834.   #ifndef __ANSI_C__
  835. !    char  *get_keyword( s, buf )
  836.   /*
  837.   ** ^PARAMETERS:
  838.   */
  839. --- 784,815 ----
  840.   **    and copy the result in the given buffer
  841.   ***^^**********************************************************************/
  842.   #ifdef __ANSI_C__
  843. !    char *get_argname( const char *s, char *buf )
  844.   #endif
  845.   {
  846. !    register CONST char *p1 = s, *p2;
  847. ! 
  848. !       /* see if sname and aname are separated by c_ARG_SEP
  849. !       ** <buf> must be large enough to hold the result!
  850. !       */
  851. !    p2 = strchr( p1, c_ARG_SEP );
  852. !    if ( p2 ) {
  853. !       strlcpy( buf, ++p2 );
  854. !    }
  855. !    else {
  856. !       strlcpy(buf, s);
  857. !    }
  858.      return   buf;
  859.   }
  860.   
  861.   
  862.   /***************************************************************************
  863. ! ** ^FUNCTION: get_kwdname - get the sname (keyword name) of an argument
  864.   **
  865.   ** ^SYNOPSIS:
  866.   */
  867.   #ifndef __ANSI_C__
  868. !    char  *get_kwdname( s, buf )
  869.   /*
  870.   ** ^PARAMETERS:
  871.   */
  872. ***************
  873. *** 810,816 ****
  874.   #endif  /* !__ANSI_C__ */
  875.   
  876.   /* ^DESCRIPTION:
  877. ! **    Get_name will get the keyword name of the given argument
  878.   **    (not the entire argument name) and copy it to buf.
  879.   **
  880.   **    The sname (keyword-name) consists only of all uppercase characters
  881. --- 822,828 ----
  882.   #endif  /* !__ANSI_C__ */
  883.   
  884.   /* ^DESCRIPTION:
  885. ! **    Get_kwdname will get the keyword name of the given argument
  886.   **    (not the entire argument name) and copy it to buf.
  887.   **
  888.   **    The sname (keyword-name) consists only of all uppercase characters
  889. ***************
  890. *** 833,877 ****
  891.   **    and copy the result in the given buffer
  892.   ***^^**********************************************************************/
  893.   #ifdef __ANSI_C__
  894. !    char *get_keyword( const char *s, char *buf )
  895.   #endif
  896.   {
  897. !    register char *p1 = (char *)s, *p2;
  898. !    register int   i, len = 0;
  899. !    char *caps = CHARNULL;
  900.   
  901.      if ( !p1 )  return  CHARNULL;
  902.   
  903. !       /* find size to copy (use all caps if possible) */
  904. !    for ( p1 = (char *)s ; *p1 ; p1++ )   {
  905. !      if ( !caps  &&  isupper( *p1 ) )  caps = p1;
  906. !          if ( caps   &&   isupper( *p1 ) )   ++len;
  907.      }
  908. -    if ( !caps )   len = (int) (p1 - (char *)s);
  909.   
  910.         /* copy string into buffer and convert it to desired case */
  911.         /* <buf> must be large enough to hold the result! */
  912. !    p1 = buf;
  913. !    if ( len )   {
  914. !      if ( !caps ) {
  915. !         for ( p1 = buf, p2 = (char *)s, i = 0 ; i < len ; p1++, p2++, i++ ) {
  916. !             *p1 = TO_KWDCASE(*p2);
  917. !         }
  918. !      }/*if*/
  919.   
  920. -      else {
  921. -         for ( p2 = caps, i = 0 ; i < len ; p2++ ) {
  922. -            if ( isupper( *p2 ) )   {
  923. -               *(p1++) = TO_KWDCASE(*p2);
  924. -               ++i;
  925. -            }
  926. -         }/*for*/
  927. -      }/*else*/
  928. -    }/*if*/
  929. -    *p1 = '\0';
  930. - 
  931.      return   buf;   /* return buffer address */
  932.   }
  933.   #ifndef amiga_style
  934.   
  935.   /***************************************************************************
  936. --- 845,887 ----
  937.   **    and copy the result in the given buffer
  938.   ***^^**********************************************************************/
  939.   #ifdef __ANSI_C__
  940. !    char *get_kwdname( const char *s, char *buf )
  941.   #endif
  942.   {
  943. !    register char *p1 = (char *)s, *p2, ch;
  944. !    BOOL caps = FALSE;
  945.   
  946.      if ( !p1 )  return  CHARNULL;
  947.   
  948. !       /* see if sname and aname are separated by c_ARG_SEP */
  949. !    p2 = strchr( p1, c_ARG_SEP );
  950. !    if ( p2 ) {
  951. !       ch = *p2;
  952. !       *p2 = '\0';
  953. !       KWDCASECOPY( buf, p1 );
  954. !       *p2 = ch;
  955. !       return  buf;
  956.      }
  957.   
  958.         /* copy string into buffer and convert it to desired case */
  959.         /* <buf> must be large enough to hold the result! */
  960. !    for ( p2 = buf; *p1 ; p1++ ) {
  961. !       if ( isupper(*p1) ) {
  962. !          if ( !caps ) {
  963. !             caps = TRUE;
  964. !             p2 = buf;
  965. !          }
  966. !          *p2++ = TO_KWDCASE(*p1);
  967. !       }
  968. !       else if ( !caps ) {
  969. !          *p2++ = TO_KWDCASE(*p1);
  970. !       }
  971. !    }
  972. !    *p2 = '\0';
  973.   
  974.      return   buf;   /* return buffer address */
  975.   }
  976. + 
  977.   #ifndef amiga_style
  978.   
  979.   /***************************************************************************
  980. ***************
  981. *** 928,945 ****
  982.   #endif
  983.   {
  984.      int  i, clen, tlen, too_short=0;
  985. !    CONST char *full_targ;
  986. !    char *up_targ;
  987.   
  988.   
  989. !    full_targ = target;
  990.   
  991. -       /* make up_targ the uppercase portion of target */
  992. -    up_targ = strdup( full_targ );
  993. -    (VOID) get_keyword( full_targ, up_targ );
  994. - 
  995.         /* match at least MINLEN characters if possible */
  996. !    tlen = strlen( up_targ );
  997.      clen = strlen( candidate );
  998.      if ( (tlen >= MINLEN)   &&   (clen < MINLEN) ) {
  999.         ++too_short;      /* not long enough -- no match */
  1000. --- 938,951 ----
  1001.   #endif
  1002.   {
  1003.      int  i, clen, tlen, too_short=0;
  1004. !    char  arg_targ[ 256 ], kwd_targ[ 256 ];
  1005.   
  1006.   
  1007. !       /* make kwd_targ the keyword portion of target */
  1008. !    (VOID) get_kwdname( target, kwd_targ );
  1009.   
  1010.         /* match at least MINLEN characters if possible */
  1011. !    tlen = strlen( kwd_targ );
  1012.      clen = strlen( candidate );
  1013.      if ( (tlen >= MINLEN)   &&   (clen < MINLEN) ) {
  1014.         ++too_short;      /* not long enough -- no match */
  1015. ***************
  1016. *** 947,953 ****
  1017.   
  1018.   #ifdef vms_style
  1019.         /* if first two chars are NO then match at least MINLEN+2 chars */
  1020. !    if ( !strnicmp(up_targ, "NO", 2) ) {
  1021.         if ( (tlen >= (MINLEN + 2))   &&   (clen < (MINLEN + 2)) ) {
  1022.            ++too_short;      /* not long enough -- no match */
  1023.         }
  1024. --- 953,959 ----
  1025.   
  1026.   #ifdef vms_style
  1027.         /* if first two chars are NO then match at least MINLEN+2 chars */
  1028. !    if ( !strnicmp(kwd_targ, "NO", 2) ) {
  1029.         if ( (tlen >= (MINLEN + 2))   &&   (clen < (MINLEN + 2)) ) {
  1030.            ++too_short;      /* not long enough -- no match */
  1031.         }
  1032. ***************
  1033. *** 954,971 ****
  1034.      }
  1035.   #endif
  1036.   
  1037. !       /* first try to match prefix of the uppercase portion */
  1038. !    i = (too_short) ? -1 : strnicmp(up_targ, candidate, clen);
  1039.   
  1040. -    free( up_targ );
  1041. - 
  1042.         /* did we match? */
  1043.      if ( !i )  return  0;   /* yes! */
  1044.   
  1045. !    /* no! : compare the whole target
  1046.      **       match at least MINLEN characters if possible
  1047.      */
  1048. !    tlen = strlen(full_targ);
  1049.      if ( (tlen >= MINLEN)   &&   (clen < MINLEN) ) {
  1050.         return   -1;      /* not long enough -- no match */
  1051.      }
  1052. --- 960,978 ----
  1053.      }
  1054.   #endif
  1055.   
  1056. !       /* first try to match prefix of the keyword portion */
  1057. !    i = (too_short) ? -1 : strnicmp(kwd_targ, candidate, clen);
  1058.   
  1059.         /* did we match? */
  1060.      if ( !i )  return  0;   /* yes! */
  1061.   
  1062. !    /* no! : compare the argument portion
  1063.      **       match at least MINLEN characters if possible
  1064.      */
  1065. !       /* make arg_targ the argument portion of target */
  1066. !    (VOID) get_argname( target, arg_targ );
  1067. ! 
  1068. !    tlen = strlen(arg_targ);
  1069.      if ( (tlen >= MINLEN)   &&   (clen < MINLEN) ) {
  1070.         return   -1;      /* not long enough -- no match */
  1071.      }
  1072. ***************
  1073. *** 972,978 ****
  1074.   
  1075.   #ifdef vms_style
  1076.      /* if first two chars are NO then match at least MINLEN+2 chars */
  1077. !    if ( !strnicmp(full_targ, "no", 2) ) {
  1078.         if ( (tlen >= (MINLEN + 2))   &&   (clen < (MINLEN + 2)) ) {
  1079.            return   -1;      /* not long enough -- no match */
  1080.         }
  1081. --- 979,985 ----
  1082.   
  1083.   #ifdef vms_style
  1084.      /* if first two chars are NO then match at least MINLEN+2 chars */
  1085. !    if ( !strnicmp(arg_targ, "no", 2) ) {
  1086.         if ( (tlen >= (MINLEN + 2))   &&   (clen < (MINLEN + 2)) ) {
  1087.            return   -1;      /* not long enough -- no match */
  1088.         }
  1089. ***************
  1090. *** 979,985 ****
  1091.      }
  1092.   #endif
  1093.   
  1094. !    return   strnicmp(full_targ, candidate, clen);
  1095.   }
  1096.   
  1097.   
  1098. --- 986,992 ----
  1099.      }
  1100.   #endif
  1101.   
  1102. !    return  strnicmp(arg_targ, candidate, clen);
  1103.   }
  1104.   
  1105.   
  1106. ***************
  1107. *** 992,1014 ****
  1108.      int match( candidate, target) char *candidate, *target;
  1109.   # endif
  1110.   {
  1111. !    int i, j;
  1112. !    char c;
  1113.   
  1114. !    i = j = 0;
  1115.   
  1116. !    while ( isgraph(target[i]) || isgraph(candidate[i]) ) {
  1117. !       while ( islower(target[i]) ) i++;
  1118. !       if ( !isgraph(target[i]) ) {
  1119. !          if ( !isgraph(candidate[j]) )  return 0;
  1120. !          return  stricmp(target, candidate);
  1121. !       }
  1122. !       c = islower( candidate[j] ) ? toupper(candidate[j]) : candidate[j];
  1123. !       if (target[i] != c)  return  stricmp(target, candidate);
  1124. !       i++;
  1125. !       j++;
  1126. !    }
  1127. !    return 0;
  1128.   }
  1129.   
  1130.   #endif
  1131. --- 999,1016 ----
  1132.      int match( candidate, target) char *candidate, *target;
  1133.   # endif
  1134.   {
  1135. !    char kwd_targ[ 256 ], arg_targ[ 256 ];
  1136. !    int rc;
  1137.   
  1138. !    (VOID) get_kwdname( target, kwd_targ );
  1139. !    rc = stricmp( kwd_targ, candidate );
  1140.   
  1141. !    if ( rc == 0 )  return  0;
  1142. ! 
  1143. !    (VOID) get_argname( target, arg_targ );
  1144. !    rc = stricmp( arg_targ, candidate );
  1145. ! 
  1146. !    return  rc;
  1147.   }
  1148.   
  1149.   #endif
  1150. *** strfuncs.h.OLD    Mon Jun  3 11:18:00 1991
  1151. --- strfuncs.h    Mon May 13 13:59:31 1991
  1152. ***************
  1153. *** 33,40 ****
  1154.   EXTERN  int    strsplit     ARGS(( char ***, char *, const char * ));
  1155.   EXTERN  char  *strjoin      ARGS(( const char **, const char * ));
  1156.   
  1157. ! EXTERN  char  *get_name     ARGS(( const char *, char * ));
  1158. ! EXTERN  char  *get_keyword  ARGS(( const char *, char * ));
  1159.   EXTERN  int    match        ARGS(( const char *, const char * ));
  1160.   EXTERN  char  *basename     ARGS(( char * ));
  1161.   EXTERN  VOID   indent_para  ARGS(( FILE *, int, int,
  1162. --- 33,40 ----
  1163.   EXTERN  int    strsplit     ARGS(( char ***, char *, const char * ));
  1164.   EXTERN  char  *strjoin      ARGS(( const char **, const char * ));
  1165.   
  1166. ! EXTERN  char  *get_argname  ARGS(( const char *, char * ));
  1167. ! EXTERN  char  *get_kwdname  ARGS(( const char *, char * ));
  1168.   EXTERN  int    match        ARGS(( const char *, const char * ));
  1169.   EXTERN  char  *basename     ARGS(( char * ));
  1170.   EXTERN  VOID   indent_para  ARGS(( FILE *, int, int,
  1171. *** unix_args.c.OLD    Mon Jun  3 11:18:42 1991
  1172. --- unix_args.c    Mon May 13 13:44:30 1991
  1173. ***************
  1174. *** 215,221 ****
  1175.                     BSET( arg_flags(ad), ARGGIVEN );
  1176.                  }
  1177.                  else {
  1178. !                   (VOID) get_keyword( arg_sname(ad), name );
  1179.                     usrerr("option %c%s requires an argument", c_KWD_PFX, name);
  1180.                     arg_flags(ad) = flags;
  1181.                     parse_error = pe_SYNTAX;
  1182. --- 215,221 ----
  1183.                     BSET( arg_flags(ad), ARGGIVEN );
  1184.                  }
  1185.                  else {
  1186. !                   (VOID) get_kwdname( arg_sname(ad), name );
  1187.                     usrerr("option %c%s requires an argument", c_KWD_PFX, name);
  1188.                     arg_flags(ad) = flags;
  1189.                     parse_error = pe_SYNTAX;
  1190. ***************
  1191. *** 339,345 ****
  1192.                        BSET( arg_flags(ad), ARGGIVEN );
  1193.                     }
  1194.                     else {
  1195. !                      (VOID) get_name(arg_sname(ad), name);
  1196.                        usrerr( "%s required for %c%c flag",
  1197.                                name, c_OPT_PFX, arg_cname(ad) );
  1198.                        arg_flags(ad) = flags;
  1199. --- 339,345 ----
  1200.                        BSET( arg_flags(ad), ARGGIVEN );
  1201.                     }
  1202.                     else {
  1203. !                      (VOID) get_argname(arg_sname(ad), name);
  1204.                        usrerr( "%s required for %c%c flag",
  1205.                                name, c_OPT_PFX, arg_cname(ad) );
  1206.                        arg_flags(ad) = flags;
  1207. ***************
  1208. *** 505,517 ****
  1209.      char *pos;
  1210.      argName_t   name, keyword;
  1211.   
  1212. !    (VOID) get_name( arg_sname(ad), name );
  1213.   
  1214.      if (ARG_isPOSITIONAL(ad)) {
  1215.         sprintf( buf, "<%s>", name );
  1216.      }
  1217.      else {
  1218. !       (VOID) get_keyword( arg_sname(ad), keyword );
  1219.   
  1220.         if ( isupper(arg_cname(ad))  &&  toupper(*keyword) == arg_cname(ad) ) {
  1221.            *keyword = toupper(*keyword);
  1222. --- 505,517 ----
  1223.      char *pos;
  1224.      argName_t   name, keyword;
  1225.   
  1226. !    (VOID) get_argname( arg_sname(ad), name );
  1227.   
  1228.      if (ARG_isPOSITIONAL(ad)) {
  1229.         sprintf( buf, "<%s>", name );
  1230.      }
  1231.      else {
  1232. !       (VOID) get_kwdname( arg_sname(ad), keyword );
  1233.   
  1234.         if ( isupper(arg_cname(ad))  &&  toupper(*keyword) == arg_cname(ad) ) {
  1235.            *keyword = toupper(*keyword);
  1236. *** unix_man.c.OLD    Mon Jun  3 11:18:48 1991
  1237. --- unix_man.c    Mon May 13 13:44:31 1991
  1238. ***************
  1239. *** 75,81 ****
  1240.      char *pos;
  1241.      argName_t   name;
  1242.   
  1243. !    (VOID) get_name( arg_sname(ad), name );
  1244.   
  1245.      if (ARG_isPOSITIONAL(ad)) {
  1246.          if ( ARG_isMULTIVAL(ad) ) {
  1247. --- 75,81 ----
  1248.      char *pos;
  1249.      argName_t   name;
  1250.   
  1251. !    (VOID) get_argname( arg_sname(ad), name );
  1252.   
  1253.      if (ARG_isPOSITIONAL(ad)) {
  1254.          if ( ARG_isMULTIVAL(ad) ) {
  1255. ***************
  1256. *** 87,93 ****
  1257. --- 87,97 ----
  1258.          return  strlen(name);
  1259.      }/*if parm*/
  1260.   
  1261. + #ifdef SVR4
  1262. +    sprintf(buf, "\\f4\\-%c\\fP", arg_cname(ad));
  1263. + #else
  1264.      sprintf(buf, "\\fB\\-%c\\fP", arg_cname(ad));
  1265. + #endif
  1266.      pos = buf + strlen(buf);
  1267.   
  1268.      if ( ARG_isVALTAKEN(ad)  &&  !ARG_isBOOLEAN(ad)  &&  !ARG_isPSEUDOARG(ad) ) {
  1269. ***************
  1270. *** 185,191 ****
  1271. --- 189,199 ----
  1272.      printf(".if n .ll 78\n");
  1273.   
  1274.      COMMENT;
  1275. + #ifdef SVR4
  1276. +    TH( name, 1 );
  1277. + #else
  1278.      TH( strupr(name), 1 );
  1279. + #endif
  1280.   
  1281.      COMMENT;
  1282.      SH( "NAME" );
  1283. ***************
  1284. *** 195,201 ****
  1285. --- 203,213 ----
  1286.      SH( "SYNOPSIS" );
  1287.   
  1288.      len = strlen( program ) + 1;
  1289. + #ifdef SVR4
  1290. +    sprintf( name, "\\f4%s\\fP", program );
  1291. + #else
  1292.      sprintf( name, "\\fB%s\\fP", program );
  1293. + #endif
  1294.      TP( len, name );
  1295.   
  1296.      maxlen = 0;
  1297. *** useful.h.OLD    Mon Jun  3 11:18:52 1991
  1298. --- useful.h    Thu May 16 16:21:26 1991
  1299. ***************
  1300. *** 31,36 ****
  1301. --- 31,42 ----
  1302.   # endif
  1303.   #endif /* _unix */
  1304.   
  1305. + #if (defined(_UNIX) || defined(__UNIX) || defined(_UNIX_) || defined(__UNIX__))
  1306. + # ifndef unix
  1307. + #   define unix
  1308. + # endif
  1309. + #endif /* _UNIX */
  1310. + 
  1311.      /* give a stab at the dual Unix universe dilemma (UCB vs AT&T) */
  1312.   #ifdef unix
  1313.   # if ( defined(_BSD) && !defined(BSD) )
  1314. ***************
  1315. *** 84,102 ****
  1316.   #endif /* unix */
  1317.   
  1318.   #ifndef MSDOS
  1319. ! # if ( defined(_MSDOS_) || defined(__MSDOS__) || defined(_MSDOS) )
  1320.   #  define MSDOS
  1321.   # endif
  1322.   #endif
  1323.   
  1324.   #ifndef OS2
  1325. ! # if ( defined(_OS2_) || defined(__OS2__) || defined(_OS2) )
  1326.   #  define OS2
  1327.   # endif
  1328.   #endif
  1329.   
  1330.   #ifndef AmigaDOS
  1331. ! # if ( defined(MANX) || defined(AZTEC) )
  1332.   #   define AmigaDOS
  1333.   # endif
  1334.   #endif /* AmigaDOS */
  1335. --- 90,108 ----
  1336.   #endif /* unix */
  1337.   
  1338.   #ifndef MSDOS
  1339. ! # if (defined(_MSDOS_)||defined(__MSDOS__)||defined(_MSDOS)||defined(__MSDOS))
  1340.   #  define MSDOS
  1341.   # endif
  1342.   #endif
  1343.   
  1344.   #ifndef OS2
  1345. ! # if ( defined(_OS2_) || defined(__OS2__) || defined(_OS2) || defined(__OS2) )
  1346.   #  define OS2
  1347.   # endif
  1348.   #endif
  1349.   
  1350.   #ifndef AmigaDOS
  1351. ! # if ( defined(AMIGA) || defined(MANX) || defined(AZTEC) )
  1352.   #   define AmigaDOS
  1353.   # endif
  1354.   #endif /* AmigaDOS */
  1355. ***************
  1356. *** 303,312 ****
  1357.   # endif  /* !_SIZE_T_DEFINED */
  1358.   #endif
  1359.   
  1360. ! #ifndef __malloc_h
  1361. !  EXTERN  ARBPTR  malloc   ARGS(( size_t ));
  1362. !  EXTERN  ARBPTR  realloc  ARGS(( ARBPTR, size_t ));
  1363. !  EXTERN  VOID    free     ARGS(( ARBPTR ));
  1364.   #endif /*__malloc_h*/
  1365.   
  1366.   EXTERN  ARBPTR  ckalloc  ARGS(( size_t ));
  1367. --- 309,316 ----
  1368.   # endif  /* !_SIZE_T_DEFINED */
  1369.   #endif
  1370.   
  1371. ! #if ( !defined(__malloc_h) && !defined(__MALLOC_H) )
  1372. ! # include <malloc.h>
  1373.   #endif /*__malloc_h*/
  1374.   
  1375.   EXTERN  ARBPTR  ckalloc  ARGS(( size_t ));
  1376. *** vms_args.c.OLD    Mon Jun  3 11:18:57 1991
  1377. --- vms_args.c    Mon May 13 13:44:32 1991
  1378. ***************
  1379. *** 683,689 ****
  1380.                  BSET( arg_flags(ad), ARGVALGIVEN );
  1381.               }
  1382.               else {
  1383. !                (VOID) get_keyword( arg_sname(ad), keyword );
  1384.                  usrerr("qualifier %s requires an argument", keyword);
  1385.                  arg_flags(ad) = flags;
  1386.                  parse_error = pe_SYNTAX;
  1387. --- 683,689 ----
  1388.                  BSET( arg_flags(ad), ARGVALGIVEN );
  1389.               }
  1390.               else {
  1391. !                (VOID) get_kwdname( arg_sname(ad), keyword );
  1392.                  usrerr("qualifier %s requires an argument", keyword);
  1393.                  arg_flags(ad) = flags;
  1394.                  parse_error = pe_SYNTAX;
  1395. ***************
  1396. *** 849,861 ****
  1397.      char * pos;
  1398.      argName_t  keyword, name;
  1399.   
  1400. !    (VOID) get_name( arg_sname(ad), name );
  1401.   
  1402.      if (ARG_isPOSITIONAL(ad)) {
  1403.         sprintf( buf, "<%s>", name );
  1404.      }
  1405.      else {
  1406. !       (VOID) get_keyword( arg_sname(ad), keyword );
  1407.         sprintf( buf, "%c%s", *s_KWD_PFX, keyword );
  1408.         pos = buf + strlen(buf);
  1409.   
  1410. --- 849,861 ----
  1411.      char * pos;
  1412.      argName_t  keyword, name;
  1413.   
  1414. !    (VOID) get_argname( arg_sname(ad), name );
  1415.   
  1416.      if (ARG_isPOSITIONAL(ad)) {
  1417.         sprintf( buf, "<%s>", name );
  1418.      }
  1419.      else {
  1420. !       (VOID) get_kwdname( arg_sname(ad), keyword );
  1421.         sprintf( buf, "%c%s", *s_KWD_PFX, keyword );
  1422.         pos = buf + strlen(buf);
  1423.   
  1424. ***************
  1425. *** 965,971 ****
  1426.   
  1427.   
  1428.               if ( ARG_isMULTIVAL(ad) ) {
  1429. !                (VOID) get_name( arg_sname(ad), name );
  1430.                  strcat(buf, "[,<");
  1431.                  strcat(buf, name);
  1432.                  strcat(buf, ">...]");
  1433. --- 965,971 ----
  1434.   
  1435.   
  1436.               if ( ARG_isMULTIVAL(ad) ) {
  1437. !                (VOID) get_argname( arg_sname(ad), name );
  1438.                  strcat(buf, "[,<");
  1439.                  strcat(buf, name);
  1440.                  strcat(buf, ">...]");
  1441. *** xparse.c.OLD    Mon Jun  3 11:19:13 1991
  1442. --- xparse.c    Mon Jun  3 10:29:49 1991
  1443. ***************
  1444. *** 857,872 ****
  1445.            if ( ARG_isREQUIRED(ad)  &&  !ARG_isGIVEN(ad) ) {
  1446.                  /* still didn't get a value... sigh */
  1447.               if ( ARG_isPOSITIONAL(ad) ) {
  1448. !                (VOID) get_name( arg_sname(ad), s );
  1449.                  usrerr("%s required", s);
  1450.               }
  1451.               else {
  1452.   #ifdef amiga_style
  1453. !                (VOID) get_keyword( arg_sname(ad), s );
  1454.                  usrerr("argument required for %s keyword", s);
  1455.   #endif
  1456.   #ifdef ibm_style
  1457. !                (VOID) get_name( arg_sname(ad), s );
  1458.                  {
  1459.                     char c, *pfx = getenv( "SWITCHAR" );
  1460.                     c = ( pfx &&  *pfx ) ? *pfx : '/';
  1461. --- 857,872 ----
  1462.            if ( ARG_isREQUIRED(ad)  &&  !ARG_isGIVEN(ad) ) {
  1463.                  /* still didn't get a value... sigh */
  1464.               if ( ARG_isPOSITIONAL(ad) ) {
  1465. !                (VOID) get_argname( arg_sname(ad), s );
  1466.                  usrerr("%s required", s);
  1467.               }
  1468.               else {
  1469.   #ifdef amiga_style
  1470. !                (VOID) get_kwdname( arg_sname(ad), s );
  1471.                  usrerr("argument required for %s keyword", s);
  1472.   #endif
  1473.   #ifdef ibm_style
  1474. !                (VOID) get_argname( arg_sname(ad), s );
  1475.                  {
  1476.                     char c, *pfx = getenv( "SWITCHAR" );
  1477.                     c = ( pfx &&  *pfx ) ? *pfx : '/';
  1478. ***************
  1479. *** 874,884 ****
  1480.                  }
  1481.   #endif
  1482.   #ifdef unix_style
  1483. !                (VOID) get_name( arg_sname(ad), s );
  1484.                  usrerr("%s required for %c%c flag", s, c_OPT_PFX, arg_cname(ad));
  1485.   #endif
  1486.   #ifdef vms_style
  1487. !                (VOID) get_keyword( arg_sname(ad), s );
  1488.                  usrerr("value required for %c%s qualifier", *s_KWD_PFX, s);
  1489.   #endif
  1490.               }
  1491. --- 874,884 ----
  1492.                  }
  1493.   #endif
  1494.   #ifdef unix_style
  1495. !                (VOID) get_argname( arg_sname(ad), s );
  1496.                  usrerr("%s required for %c%c flag", s, c_OPT_PFX, arg_cname(ad));
  1497.   #endif
  1498.   #ifdef vms_style
  1499. !                (VOID) get_kwdname( arg_sname(ad), s );
  1500.                  usrerr("value required for %c%s qualifier", *s_KWD_PFX, s);
  1501.   #endif
  1502.               }
  1503. ***************
  1504. *** 1689,1701 ****
  1505.               int  *argflags;
  1506.               BOOL  is_match = FALSE;
  1507.   
  1508. !             for (args = argd; !is_match  &&  args; args = cmd_defargs(argd) ) {
  1509. !                for (ad = ARG_FIRST(args); !ARG_isEND(ad); ARG_ADVANCE(ad) ) {
  1510. !                   if (arg_type(ad) == argDummy)   continue;
  1511.                     if ( match(name, arg_sname(ad)) == 0 ) {
  1512.                        is_match = TRUE;
  1513.                        break;
  1514. !                   }
  1515.                  }/*foreach arg*/
  1516.               }/*foreach argdesc*/
  1517.   
  1518. --- 1689,1702 ----
  1519.               int  *argflags;
  1520.               BOOL  is_match = FALSE;
  1521.   
  1522. !             for (args = argd ; args  &&  !is_match ; args = cmd_defargs(args)) {
  1523. !                for (ad = ARG_FIRST(args) ; !ARG_isEND(ad) ; ARG_ADVANCE(ad)) {
  1524. !                   if ( arg_type(ad) == argDummy )  continue;
  1525. ! 
  1526.                     if ( match(name, arg_sname(ad)) == 0 ) {
  1527.                        is_match = TRUE;
  1528.                        break;
  1529. !                   }/*if*/
  1530.                  }/*foreach arg*/
  1531.               }/*foreach argdesc*/
  1532.   
  1533.