home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume26 / parseargs / patch09a next >
Text File  |  1991-11-25  |  57KB  |  1,738 lines
  1. Newsgroups: comp.sources.misc
  2. From: Brad Appleton <brad@hcx1.ssd.csd.harris.com>
  3. Subject:  v26i065:  parseargs - functions to parse command line arguments, Patch09a/2
  4. Message-ID: <csm-v26i065=parseargs.203314@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: 11ba3c1bdff2402c3ff1fadceddd8d5d
  6. Date: Tue, 26 Nov 1991 02:34:56 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: Brad Appleton <brad@hcx1.ssd.csd.harris.com>
  10. Posting-number: Volume 26, Issue 65
  11. Archive-name: parseargs/patch09a
  12. Environment: UNIX, VMS, MS-DOS, OS/2, Amiga
  13. Patch-To: parseargs: Volume 17, Issue 46-57
  14.  
  15. This is patch09 for parseargs. To apply this patch:
  16.  
  17. 1) cd to your parseargs source directory (which should be at patchlevel 8.
  18.    look at the file patchlevel.h to see which patchlevel you have)
  19.  
  20. 2) Unshar both parts to this patch to create the file PATCH09
  21.  
  22. 3) type "patch -p0 <PATCH09"
  23.  
  24.  
  25. If you dont have all the patches and/or want parseargs in its entirety I will
  26. honor your requests to send it by e-mail.
  27.  
  28. The following is a brief introduction to parseargs for those who are not
  29. already familiar with it:
  30.  
  31.  
  32.  
  33.                                   PARSEARGS
  34.  
  35.                         extracted from Eric Allman's
  36.  
  37.                             NIFTY UTILITY LIBRARY
  38.  
  39.                           Created by Eric P. Allman
  40.                              <eric@Berkeley.EDU>
  41.  
  42.                          Modified by Peter da Silva
  43.                             <peter@Ferranti.COM>
  44.  
  45.                    Modified and Rewritten by Brad Appleton
  46.                           <brad@SSD.CSD.Harris.COM>
  47.  
  48.  
  49.  Welcome to parseargs! Dont let the initial size of this package scare you.
  50.  over 75% of it is English text, and more than 50% of the source is comments.
  51.  
  52.  Parseargs is a set of functions to parse command-line arguments. Unlike
  53.  getopt and its variants, parseargs does more than just split up the
  54.  command-line into some canonical form. Parseargs will actually parse the
  55.  command-line, assigning the appropriate command-line values to the
  56.  corresponding variables, and will verify the command-line syntax (and print
  57.  a usage message if necessary). Furthermore, many features of it's parsing
  58.  behavior are configurable at run-time. Some of these features include the
  59.  following:
  60.  
  61.      o  Prompting the user for missing arguments
  62.      o  Allowing keywords (+count=4) and/or options (-c4)
  63.      o  Checking for default arguments in an environment variable
  64.      o  Ignoring bad syntax instead of terminating
  65.      o  Ignoring upper/lower case on the command-line
  66.      o  Controlling the location of non-positional parameters
  67.      o  Controlling the contents (syntax and verbosity) of usage messages
  68.      o  Having long usage messages piped through a paging program
  69.  
  70.  Parseargs also allows for options that take an optional argument, and
  71.  options that take a (possibly optional) list of one or more arguments.
  72.  In addition, parseargs may be configured at compile-time to parse
  73.  command-lines in accordance with the native command-syntax of any of the
  74.  following operating systems:
  75.  
  76.      o  Unix
  77.      o  VAX/VMS
  78.      o  OS/2
  79.      o  MS-DOS
  80.      o  AmigaDOS
  81.  
  82.  Parseargs consists of a set of C-functions to parse arguments from the
  83.  command-line, from files, from strings, from linked-lists, and from
  84.  string-vectors. Also included is a command-line interface which will parse
  85.  arguments for shell scripts (sh, csh/tcsh/itcsh, ksh, bash, zsh, and rc),
  86.  awk-scripts, and perl-scripts.
  87.  
  88.  The basic structure used by parseargs is the argument-descriptor (sometimes
  89.  called "argdesc" for brevity).  An array/string of argdescs is declared by
  90.  the user to describe the command in question.  The resulting argdesc-array
  91.  is passed to all the parseargs functions and is used to hold all information
  92.  about the command. a sample argdesc-array is shown below.
  93.  
  94.     STARTOFARGS,
  95.     { 'a', ARGVALOPT, argStr,   &area,    "AREAcode : optional area-code" },
  96.     { 'g', ARGLIST,   argStr,   &groups,  "newsGROUPS : groups to test" },
  97.     { 'r', ARGOPT,    argInt,   &count,   "REPcount : repetition factor" },
  98.     { 's', ARGOPT,    argChar,  &sepch,   "SEPchar : field separator" },
  99.     { 'x', ARGOPT,    argBool,  &xflag,   "Xflag : turn on X-mode" },
  100.     { ' ', ARGREQ,    argStr,   &name,    "name : name to use" },
  101.     { ' ', ARGLIST,   argStr,   &args,    "args : any remaining arguments" },
  102.     ENDOFARGS
  103.  
  104.  Once the above array/string is declared it is a simple matter to invoke
  105.  parseargs from C as in the following example:
  106.  
  107.     status = parseargs( argv, argdesc_array );
  108.  
  109.  or from a shell script as in the following example:
  110.  
  111.     echo "$ARGDESC_STR" | parseargs -s sh -- "$0" "$@" >tmp$$
  112.     test  $? = 0  &&  . tmp$$
  113.     /bin/rm -f tmp$$
  114.  
  115.  And before you know it, your command-line had been parsed, all variables 
  116.  have been assigned their corresponding values from the command-line, syntax
  117.  have been verified, and a usage message (if required) has been printed. 
  118.  
  119.  Under UNIX, the command-line syntax (using single character options) for the
  120.  above command would be:
  121.  
  122.     cmdname [-a [<areacode>]] [-g <newsgroups>...] [-r <repcount>]
  123.             [-s <sepchar>] [-x]  <name>  [<args>...]
  124.  
  125.  The UNIX command-line syntax using keywords (or long options) would be:
  126.  
  127.     cmdname [+area [<areacode>]] [+groups <newsgroups>...] [+rep <repcount>]
  128.             [+sep <sepchar>] [+x]  <name>  [<args>...]
  129.  
  130.  The VMS command-line syntax would be the following:
  131.  
  132.     cmdname [/AREA[=<areacode>]] [/GROUPS=<newsgroups>[,<newsgroups>...]]
  133.             [/REP=<repcount>] [/SEP=<sepchar>] [/X]  <name>
  134.             [<args>[,<args>...]]
  135.  
  136.  The MS-DOS and OS/2 command-line syntax would be the following (unless the
  137.  environment variable $SWITCHAR is '-' in which case UNIX syntax is used):
  138.  
  139.     cmdname [/a[=<areacode>]] [/g=<newsgroups>...] [/r=<repcount>]
  140.             [/s=<sepchar>] [/x]  <name>  [<args>...]
  141.  
  142.  The AmigaDOS command-line syntax would be the following:
  143.  
  144.     cmdname [AREA [<areacode>]] [GROUPS <newsgroups>...] [REP <repcount>]
  145.             [SEP <sepchar>] [X]  <name>  [<args>...]
  146.  
  147.  
  148.  Please look at the README files and manpages for more detailed information!
  149. ----
  150. #!/bin/sh
  151. # This is a shell archive (produced by shar 3.49)
  152. # To extract the files from this archive, save it to a file, remove
  153. # everything above the "!/bin/sh" line above, and type "sh file_name".
  154. #
  155. # made 11/26/1991 02:28 UTC by kent@sparky.IMD.Sterling.COM
  156. # Source directory /home/kent/mod/csm/queue/parseargs
  157. #
  158. # existing files will NOT be overwritten unless -c is specified
  159. #
  160. # This is part 1 of a multipart archive                                    
  161. # do not concatenate these parts, unpack them in order with /bin/sh        
  162. #
  163. # This shar contains:
  164. # length  mode       name
  165. # ------ ---------- ------------------------------------------
  166. #  66669 -rw-rw-r-- PATCH09
  167. #
  168. if test -r _shar_seq_.tmp; then
  169.     echo 'Must unpack archives in sequence!'
  170.     echo Please unpack part `cat _shar_seq_.tmp` next
  171.     exit 1
  172. fi
  173. # ============= PATCH09 ==============
  174. if test -f 'PATCH09' -a X"$1" != X"-c"; then
  175.     echo 'x - skipping PATCH09 (File already exists)'
  176.     rm -f _shar_wnt_.tmp
  177. else
  178. > _shar_wnt_.tmp
  179. echo 'x - extracting PATCH09 (Text)'
  180. sed 's/^X//' << 'SHAR_EOF' > 'PATCH09' &&
  181. *** README.OLD    Thu Nov 21 15:16:56 1991
  182. --- README    Thu Nov 21 11:34:11 1991
  183. ***************
  184. *** 784,797 ****
  185. X      USE_TERMCAP  --  Parseargs will use curses/terminfo/termcap when trying
  186. X                       to figure out the size of the screen.
  187. X  
  188. -     UNWRITABLE_STRING_LITERALS
  189. -                  --  This should be used only for compilers and/or machines
  190. -                      that do NOT allow the programmer to modify the contents
  191. -                      of string literals such as "hello, world". If this
  192. -                      constant is #defined, then all modified strings will be
  193. -                      duplicated (using strdup()) before they are changed.
  194. - 
  195. - 
  196. X   IBM-PC VERSION OF parseargs(3)
  197. X   ==============================
  198. X   I also added ibm_args.c for MS-DOS and OS/2.
  199. --- 784,789 ----
  200. ***************
  201. *** 892,898 ****
  202. X   - get parseargs(1) to support arrays for bash
  203. X   - verify that parseargs(1) works for rc, the Plan 9 shell
  204. X   - verify that parseargs(1) works for zsh
  205. -  - verify that parseargs(3) works on VMS systems.
  206. X   - verify that parseargs(3) works on MS-DOS and OS/2 systems.
  207. X  
  208. X  
  209. --- 884,889 ----
  210. ***************
  211. *** 921,929 ****
  212. X   retrieving the value of a symbol), and to Tom Christiansen and Raymond
  213. X   Chen for their help in getting parseargs(1) to work for perl scripts.
  214. X  
  215. !  Thanx also to Gillmer J. Derge, Marco Nijdam, Chris Johnston, & Earl Chew
  216. !  for sending me their bug reports and fixes so that I could incorporate them
  217. !  into the latest patch of parseargs.
  218. X  
  219. X   Lastly, thanks to all those who use and will continue to improve
  220. X   parseargs, all I ask is that you keep me updated of your efforts (so I
  221. --- 912,920 ----
  222. X   retrieving the value of a symbol), and to Tom Christiansen and Raymond
  223. X   Chen for their help in getting parseargs(1) to work for perl scripts.
  224. X  
  225. !  Thanx also to Gillmer J. Derge, Marco Nijdam, Chris Johnston, Earl Chew
  226. !  and Mike Levin for sending me their bug reports and fixes so that I could
  227. !  incorporate them into the latest patch of parseargs.
  228. X  
  229. X   Lastly, thanks to all those who use and will continue to improve
  230. X   parseargs, all I ask is that you keep me updated of your efforts (so I
  231. *** amiga_args.c.OLD    Thu Nov 21 15:17:08 1991
  232. --- amiga_args.c    Mon Nov 18 16:06:49 1991
  233. ***************
  234. *** 6,11 ****
  235. --- 6,15 ----
  236. X  **    vectors and to print AmigaDOS usage messages.
  237. X  **
  238. X  ** ^HISTORY:
  239. + **    27/08/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  240. + **    - Use ProgNameLen when accessing ProgName
  241. + **    - Use get_argdesc() to access description
  242. + **
  243. X  **    01/02/91     Brad Appleton     <brad@ssd.csd.harris.com>
  244. X  **    - Added structured block comments
  245. X  **    - Added optional arguments to keywords
  246. ***************
  247. *** 456,463 ****
  248. X        /* get screen size */
  249. X     get_winsize( fileno(stderr), &max_lines, &max_cols );
  250. X  
  251. !    fprintf(fp, "Format: %s", ProgName);
  252. !    ll = strlen( ProgName ) + 8;
  253. X     margin = ll + 1;
  254. X     longest = 0;
  255. X  
  256. --- 460,467 ----
  257. X        /* get screen size */
  258. X     get_winsize( fileno(stderr), &max_lines, &max_cols );
  259. X  
  260. !    fprintf(fp, "Format: %.*s", ProgNameLen, ProgName);
  261. !    ll = ProgNameLen + 8;
  262. X     margin = ll + 1;
  263. X     longest = 0;
  264. X  
  265. ***************
  266. *** 529,534 ****
  267. --- 533,540 ----
  268. X        for ( args = argd ; args ; args = cmd_defargs(args) ) {
  269. X           for ( ad = ARG_FIRST(args) ; !ARG_isEND(ad) ; ARG_ADVANCE(ad) ) {
  270. X              argName_t  buf;
  271. +             char  *desc;
  272. +             int  desclen;
  273. X  
  274. X                 /* don't display hidden arguments */
  275. X              if ( ARG_isHIDDEN(ad) )  continue;
  276. ***************
  277. *** 537,543 ****
  278. X  
  279. X              if( !(keywords++) )  fprintf(fp, "Keywords/Arguments:\n");
  280. X              (VOID) fmtarg(ad, buf);
  281. !             indent_para(fp, max_cols, 8, buf, longest+2, arg_description(ad));
  282. X           }/*for each ad */
  283. X        }/* for each argd */
  284. X     }/* for each parm-type */
  285. --- 543,550 ----
  286. X  
  287. X              if( !(keywords++) )  fprintf(fp, "Keywords/Arguments:\n");
  288. X              (VOID) fmtarg(ad, buf);
  289. !             desc = get_argdesc(arg_description(ad), &desclen);
  290. !             indent_para(fp, max_cols, 8, buf, longest+2, desc, desclen);
  291. X           }/*for each ad */
  292. X        }/* for each argd */
  293. X     }/* for each parm-type */
  294. *** arglist.c.OLD    Thu Nov 21 15:17:14 1991
  295. --- arglist.c    Mon Nov 18 16:08:00 1991
  296. ***************
  297. *** 6,11 ****
  298. --- 6,14 ----
  299. X  **    and to delete all items in an arglist.
  300. X  **
  301. X  ** ^HISTORY:
  302. + **    27/08/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  303. + **       - Use get_argpfx() when accessing arg_sname().
  304. + **
  305. X  **    01/02/91    Brad Appleton    <brad@ssd.csd.harris.com>
  306. X  **       - Added structured comments
  307. X  **       - Changed arglists to always be kept in FIFO order (hence
  308. ***************
  309. *** 125,131 ****
  310. X     }
  311. X  
  312. X     if ( badalloc ) {
  313. !       usrerr("out of memory saving arg %s", arg_sname(ad));
  314. X        if(copyf) free(cp);
  315. X        return FALSE;
  316. X     }
  317. --- 128,135 ----
  318. X     }
  319. X  
  320. X     if ( badalloc ) {
  321. !       usrerr("out of memory saving arg %.*s", get_argpfx(arg_sname(ad)),
  322. !                                               arg_sname(ad));
  323. X        if(copyf) free(cp);
  324. X        return FALSE;
  325. X     }
  326. *** ibm_args.c.OLD    Thu Nov 21 15:19:57 1991
  327. --- ibm_args.c    Mon Nov 18 16:09:09 1991
  328. ***************
  329. *** 6,11 ****
  330. --- 6,15 ----
  331. X  **    argument vectors and to print MS-DOS and OS/2 usage messages.
  332. X  **
  333. X  ** ^HISTORY:
  334. + **    27/08/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  335. + **    - Use ProgNameLen when accessing ProgName
  336. + **    - Use get_argdesc() to access description
  337. + **
  338. X  **    01/02/91     Brad Appleton     <brad@ssd.csd.harris.com>    Created
  339. X  ***^^**********************************************************************/
  340. X  
  341. ***************
  342. *** 699,707 ****
  343. X        /* get screen size */
  344. X     get_winsize( fileno(fp), &max_lines, &max_cols );
  345. X  
  346. !    fprintf(fp, "Usage: %s", ProgName);
  347. X  
  348. !    ll = strlen( ProgName ) + 7;
  349. X     margin = ll + 1;
  350. X     longest = 0;
  351. X  
  352. --- 703,711 ----
  353. X        /* get screen size */
  354. X     get_winsize( fileno(fp), &max_lines, &max_cols );
  355. X  
  356. !    fprintf(fp, "Usage: %.*s", ProgNameLen, ProgName);
  357. X  
  358. !    ll = ProgNameLen + 7;
  359. X     margin = ll + 1;
  360. X     longest = 0;
  361. X  
  362. ***************
  363. *** 777,782 ****
  364. --- 781,788 ----
  365. X        for ( args = argd ; args ; args = cmd_defargs(args) ) {
  366. X           for ( ad = ARG_FIRST(args) ; !ARG_isEND(ad) ; ARG_ADVANCE(ad) ) {
  367. X              argName_t  buf;
  368. +             char  *desc;
  369. +             int  desclen;
  370. X  
  371. X                 /* don't display hidden arguments */
  372. X              if ( ARG_isHIDDEN(ad) )  continue;
  373. ***************
  374. *** 785,791 ****
  375. X  
  376. X              if ( !options++ )   fprintf(fp, "Options/Arguments:\n");
  377. X              fmtarg(ad, buf, usage_flags);
  378. !             indent_para( fp, max_cols, 8, buf, longest+2, arg_description(ad) );
  379. X           }/*for each ad */
  380. X        }/* for each argd */
  381. X     }/* for each parm-type */
  382. --- 791,798 ----
  383. X  
  384. X              if ( !options++ )   fprintf(fp, "Options/Arguments:\n");
  385. X              fmtarg(ad, buf, usage_flags);
  386. !             desc = get_argdesc(arg_description(ad), &desclen);
  387. !             indent_para( fp, max_cols, 8, buf, longest+2, desc, desclen );
  388. X           }/*for each ad */
  389. X        }/* for each argd */
  390. X     }/* for each parm-type */
  391. *** parseargs.c.OLD    Thu Nov 21 15:20:11 1991
  392. --- parseargs.c    Mon Nov 18 16:09:34 1991
  393. ***************
  394. *** 80,85 ****
  395. --- 80,88 ----
  396. X  **    - fixed printing of single quotes for perl scripts
  397. X  **    - added -C option for case-insensitivity
  398. X  **    - added hidden -# option to print current version and patchlevel
  399. + **
  400. + **    27/08/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  401. + **    - Use ProgNameLen when accessing ProgName
  402. X  ***^^**********************************************************************/
  403. X  
  404. X  #include <stdio.h>
  405. ***************
  406. *** 2215,2220 ****
  407. --- 2218,2224 ----
  408. X     if ( !UsrArgc )   UsrArgd = ARGDESCNULL;
  409. X  
  410. X     ProgName = UsrName;      /* set up program name */
  411. +    ProgNameLen = strlen(ProgName);
  412. X  
  413. X     if ( PrUsage ) {   /* just print usage and exit */
  414. X        usage( UsrArgd );
  415. *** parseargs.h.OLD    Thu Nov 21 15:20:22 1991
  416. --- parseargs.h    Wed Nov 20 11:05:05 1991
  417. ***************
  418. *** 23,28 ****
  419. --- 23,39 ----
  420. X  **
  421. X  ** ^HISTORY:
  422. X  **    12/03/90    Brad Appleton    <brad@ssd.csd.harris.com>
  423. + **    - added ps_NOTCMDLINE state-flag for vms_style
  424. + **
  425. + **    08/27/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  426. + **    - Add ProgNameLen
  427. + **    - Promote ps_flags_t to unsigned short
  428. + **    - Add new states ps_USERNAME, ps_USERPURPOSE, ps_FREENAME,
  429. + **      ps_FREEPURPOSE
  430. + **    - arg_sdesc() now only returns a raw string --- use get_argdesc()
  431. + **      to extract the description from it
  432. + **
  433. + **    12/03/90    Brad Appleton    <brad@ssd.csd.harris.com>
  434. X  **    - Added all the #ifdef stuff
  435. X  **    - Added public and private macros for getting and setting
  436. X  **      the attributes of an argdesc-array and an argdesc
  437. ***************
  438. *** 282,291 ****
  439. X  #define  arg_sname(ad)        ((ad) -> ad_prompt)
  440. X  /*    -- return the string name of an argument.
  441. X  */
  442. ! #define  arg_sdesc(ad)        ( arg_sname(ad) + strlen(arg_sname(ad)) + 1 )
  443. X  /*    -- return the description of an argument. If a description was supplied,
  444. ! **       the ARGDESCRIBED flag will be set and the description will immediately
  445. ! **       follow the NULL byte of the string name.
  446. X  */
  447. X  #define  ARG_isDESCRIBED(ad)  BTEST( arg_flags(ad), ARGDESCRIBED )
  448. X  /*    -- Evaluates to TRUE only if an argument description was provided.
  449. --- 293,302 ----
  450. X  #define  arg_sname(ad)        ((ad) -> ad_prompt)
  451. X  /*    -- return the string name of an argument.
  452. X  */
  453. ! #define  arg_sdesc(ad)        ( arg_sname(ad) )
  454. X  /*    -- return the description of an argument. If a description was supplied,
  455. ! **       the ARGDESCRIBED flag will be set and the description is available
  456. ! **       by calling get_argdesc().
  457. X  */
  458. X  #define  ARG_isDESCRIBED(ad)  BTEST( arg_flags(ad), ARGDESCRIBED )
  459. X  /*    -- Evaluates to TRUE only if an argument description was provided.
  460. ***************
  461. *** 836,843 ****
  462. X  # define  ps_NOFLAGS      0x02  /* opt/kwd parsing in effect? */
  463. X  # define  ps_NOCMDENV     0x04  /* <CMD>_ARGS environment-variable parsed? */
  464. X  # define  ps_NOPARSECNTL  0x08  /* PARSECNTL environment-variable parsed? */
  465. X  
  466. ! typedef unsigned char   ps_flags_t;
  467. X  
  468. X  
  469. X     /*
  470. --- 847,861 ----
  471. X  # define  ps_NOFLAGS      0x02  /* opt/kwd parsing in effect? */
  472. X  # define  ps_NOCMDENV     0x04  /* <CMD>_ARGS environment-variable parsed? */
  473. X  # define  ps_NOPARSECNTL  0x08  /* PARSECNTL environment-variable parsed? */
  474. + # define  ps_USERNAME     0x10    /* user supplied name string */
  475. + # define  ps_FREENAME     0x10    /* free name string space */
  476. + # define  ps_USERPURPOSE  0x20    /* user supplied purpose string */
  477. + # define  ps_FREEPURPOSE  0x20    /* free purpose string space */
  478. + # ifdef vms_style
  479. + #  define  ps_NOTCMDLINE  0x40  /* argv-array is NOT from the command-line */
  480. + # endif
  481. X  
  482. ! typedef unsigned short   ps_flags_t;
  483. X  
  484. X  
  485. X     /*
  486. ***************
  487. *** 1012,1017 ****
  488. --- 1030,1036 ----
  489. X     EXTERN VOID  usage       ARGS(( const ARGDESC * ));
  490. X     EXTERN VOID  init_args   ARGS(( ARGDESC * ));
  491. X     EXTERN CONST char *ProgName;
  492. +    EXTERN int   ProgNameLen;
  493. X  #endif  /* PARSEARGS_NEXTERNS */
  494. X  
  495. X  #endif  /* PARSEARGS_H */
  496. *** patchlevel.h.OLD    Thu Nov 21 15:20:36 1991
  497. --- patchlevel.h    Thu Nov 21 11:32:17 1991
  498. ***************
  499. *** 2,7 ****
  500. --- 2,38 ----
  501. X  ** ^FILE: patchlevel.h - current patchlevel for parseargs
  502. X  **
  503. X  ** ^HISTORY:
  504. + **    08/27/91    Brad Appleton    <brad@ssd.csd.harris.com>
  505. + **    08/27/91    Earl Chew    <cechew@bruce.cs.monash.edu.au>
  506. + **    Patch09
  507. + **    - Added proper support for unwritable strings
  508. + **    - strfuncs.c/strsplit():
  509. + **      Leading, and in particular, trailing space trimming may spin off
  510. + **      the end of the token string. This occurs when the string is empty,
  511. + **      or when it has trailing space.
  512. + **      Out of memory error doesn't call syserr() like the rest of the
  513. + **      routines do.
  514. + **    - xparse.c/parsecntl():
  515. + **      Documentation says that the fourth parameter for pc_ARGFLAGS and
  516. + **      pc_PARSEARGS should be either argMask_t (promoted to int) in the
  517. + **      case of writes, or argMask_t * in the case of reads. The code is 
  518. + **      at odds with the documentation and requires (int *) on reads.
  519. + **      Also, should check for NULL cmd-name before passing it to strdup().
  520. + **    - vms_args.c/is_cmdline():
  521. + **      Mike Level pointed out to me that if lib$get_foreing returns a
  522. + **      zero-length string then the proper actions are not taken. This
  523. + **      has been fixed.
  524. + **    - vms_args.c, parseargs.h, xparse.c
  525. + **      For vms_style I added a new parse-state called ps_NOTCMDLINE.
  526. + **      When this flag is SET, then vms_parse() knows for a fact that
  527. + **      the given argv[] array is NOT from the cmdline so it doesnt even
  528. + **      need to call is_cmdline(). SO Now I just have the proper routines
  529. + **      in xparse.c set this flag before calling vms_parse() (and unset
  530. + **      the flag when they are done).
  531. + **    - vms_args.c/vms_parse():
  532. + **      ARGVALGIVEN was set instead of ARGGIVEN (this was wrong).
  533. + **
  534. + **
  535. X  **    08/15/91    Brad Appleton    <brad@ssd.csd.harris.com>
  536. X  **    Patch08
  537. X  **    - fixed some typos in the comments (SIDE-EFFECTS was misspelled
  538. ***************
  539. *** 101,107 ****
  540. X  
  541. X  #define  VERSION     2
  542. X  #define  REVISION    0
  543. ! #define  PATCHLEVEL  8
  544. X  
  545. X  #ifdef __STDC__
  546. X     static const char
  547. --- 132,138 ----
  548. X  
  549. X  #define  VERSION     2
  550. X  #define  REVISION    0
  551. ! #define  PATCHLEVEL  9
  552. X  
  553. X  #ifdef __STDC__
  554. X     static const char
  555. ***************
  556. *** 108,111 ****
  557. X  #else
  558. X     static char
  559. X  #endif
  560. !    _Ident[] = "@(#)parseargs  2.0  patchlevel 8";
  561. --- 139,142 ----
  562. X  #else
  563. X     static char
  564. X  #endif
  565. !    _Ident[] = "@(#)parseargs  2.0  patchlevel 9";
  566. *** stest.c.OLD    Thu Nov 21 15:20:49 1991
  567. --- stest.c    Wed Nov 20 15:14:47 1991
  568. ***************
  569. *** 246,252 ****
  570. X     static void print_args( const ARGDESC *argd )
  571. X  #endif
  572. X  {
  573. !    int  i, flags;
  574. X     ArgList *ls;
  575. X  
  576. X     printf( "Name = \"%s\", DirName = \"%s\", RepCount = %d,\n",
  577. --- 246,253 ----
  578. X     static void print_args( const ARGDESC *argd )
  579. X  #endif
  580. X  {
  581. !    int  i;
  582. !    argMask_t flags;
  583. X     ArgList *ls;
  584. X  
  585. X     printf( "Name = \"%s\", DirName = \"%s\", RepCount = %d,\n",
  586. *** strfuncs.c.OLD    Thu Nov 21 15:20:55 1991
  587. --- strfuncs.c    Wed Nov 20 10:43:54 1991
  588. ***************
  589. *** 23,28 ****
  590. --- 23,30 ----
  591. X  **       strtrim() -- trim leading and trailing characters in a string
  592. X  **       strsplit() -- split a string up into a vector of tokens
  593. X  **       strjoin() -- join a vector of tokens into a single string
  594. + **       get_argpfx() -- return the length of the first part of the string
  595. + **       get_argdesc() -- return the description (second part) of the string
  596. X  **       get_argname() -- return the aname (argument-name) of an argument
  597. X  **       get_kwdname() -- return the sname (keyword-name) of an argument
  598. X  **       match() -- match two keywords (case insensitive) upto a unique prefix
  599. ***************
  600. *** 30,35 ****
  601. --- 32,47 ----
  602. X  **       indent_para() -- print an indented hanging paragraph
  603. X  **
  604. X  ** ^HISTORY:
  605. + **    08/27/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  606. + **    - add extra length argument to indent_para().
  607. + **    - add FORCE_KWDCASE() macro
  608. + **    - add non-writable strings support to get_argname() and
  609. + **      get_kwdname()
  610. + **    08/27/91    Earl Chew    <cechew@bruce.cs.monash.edu.au>
  611. + **    - add get_argpfx() and get_argdesc() for non-writable strings
  612. + **      support
  613. + **    - allow zero length string for strsplit()
  614. + **
  615. X  **    01/02/91     Brad Appleton     <brad@ssd.csd.harris.com>     Created
  616. X  **    - changed from file misc.c to this name and added all of the strxxx
  617. X  **      functions (plus got rid of some unused functions).
  618. ***************
  619. *** 43,48 ****
  620. --- 55,62 ----
  621. X  #include <ctype.h>
  622. X  #include <useful.h>
  623. X  
  624. + #include "strfuncs.h"
  625. + 
  626. X  EXTERN  VOID   syserr  ARGS((const char *, ...));
  627. X  
  628. X  static CONST char WhiteSpace[] = " \t\n\r\v\f";
  629. ***************
  630. *** 49,58 ****
  631. X  
  632. X  #define c_ARG_SEP '='
  633. X  #if ( defined(unix_style)  ||  defined(ibm_style) )
  634. ! # define  TO_KWDCASE(c)  TOLOWER(c)
  635. X  # define  KWDCASECOPY(dest,src)  strlcpy(dest,src)
  636. X  #else
  637. ! # define  TO_KWDCASE(c)  TOUPPER(c)
  638. X  # define  KWDCASECOPY(dest,src)  strucpy(dest,src)
  639. X  #endif
  640. X  
  641. --- 63,74 ----
  642. X  
  643. X  #define c_ARG_SEP '='
  644. X  #if ( defined(unix_style)  ||  defined(ibm_style) )
  645. ! # define  FORCE_KWDCASE(s)       strlwr(s)
  646. ! # define  TO_KWDCASE(c)          TOLOWER(c)
  647. X  # define  KWDCASECOPY(dest,src)  strlcpy(dest,src)
  648. X  #else
  649. ! # define  FORCE_KWDCASE(s)       strupr(s)
  650. ! # define  TO_KWDCASE(c)          TOUPPER(c)
  651. X  # define  KWDCASECOPY(dest,src)  strucpy(dest,src)
  652. X  #endif
  653. X  
  654. ***************
  655. *** 308,314 ****
  656. X    unsigned len = strlen(str) + 1;
  657. X    char *p = malloc( len * sizeof(char) );
  658. X  
  659. !   if ( !p )  syserr( "Fatal Error -- out of memory" );
  660. X    strcpy(p, str);
  661. X  
  662. X    return p;
  663. --- 324,330 ----
  664. X    unsigned len = strlen(str) + 1;
  665. X    char *p = malloc( len * sizeof(char) );
  666. X  
  667. !   if ( !p )  syserr( "malloc failed in strdup()" );
  668. X    strcpy(p, str);
  669. X  
  670. X    return p;
  671. ***************
  672. *** 582,588 ****
  673. X  **
  674. X  ** ^REQUIREMENTS:
  675. X  **    vec must be non-NULL (it must be a valid address).
  676. ! **    token_str should be non-null and non-empty
  677. X  **
  678. X  ** ^SIDE-EFFECTS:
  679. X  **    All leading and trailing characters from <separators> are removed
  680. --- 598,604 ----
  681. X  **
  682. X  ** ^REQUIREMENTS:
  683. X  **    vec must be non-NULL (it must be a valid address).
  684. ! **    token_str should be non-null
  685. X  **
  686. X  ** ^SIDE-EFFECTS:
  687. X  **    All leading and trailing characters from <separators> are removed
  688. ***************
  689. *** 605,610 ****
  690. --- 621,627 ----
  691. X  **         - advance token_str to point at the next character past the
  692. X  **           rightmost NUL-byte (which should be the start of the next token).
  693. X  **      end-for
  694. + **    - vector[numtokens] = NUL
  695. X  **    - return the number of tokens parsed.
  696. X  ***^^**********************************************************************/
  697. X  #ifdef __ANSI_C__
  698. ***************
  699. *** 614,620 ****
  700. X     register   char c, *pread, *pwrite;
  701. X     int   i, count = 0;
  702. X  
  703. !    if ( !token_str )    return   0;
  704. X        /* if delim-string is NULL, whitespace is used */
  705. X     if ( !separators )   separators = WhiteSpace;
  706. X  
  707. --- 631,637 ----
  708. X     register   char c, *pread, *pwrite;
  709. X     int   i, count = 0;
  710. X  
  711. !    if ( !token_str )    token_str = "";
  712. X        /* if delim-string is NULL, whitespace is used */
  713. X     if ( !separators )   separators = WhiteSpace;
  714. X  
  715. ***************
  716. *** 621,626 ****
  717. --- 638,644 ----
  718. X        /* trim leading separators */
  719. X     pread = token_str;
  720. X     while ( strchr(separators, *pread) )   ++pread;
  721. +    if ( ! *pread )  return  0;
  722. X     token_str = pwrite = pread;
  723. X  
  724. X        /*
  725. ***************
  726. *** 627,653 ****
  727. X        ** make first pass through string, counting # of tokens and
  728. X        ** separating all tokens by a single '\0'
  729. X        */
  730. !    while ( c = *pread++ ) {
  731. X        if ( !strchr(separators, c) )   {
  732. !          *pwrite++ = c;
  733. !       }
  734. !       else {
  735. !          *pwrite++ = '\0';   /* null terminate this token */
  736. !          ++count;                /* update token count */
  737. !          while ( strchr(separators, *pread) )   ++pread;
  738. !       }
  739. !    }/*while*/
  740. !    if ( *(pwrite - 1) )  {
  741. !       ++count;         /* dont forget last token */
  742. !       *pwrite = '\0';   /* null-terminate */
  743. !    }
  744. X  
  745. X        /* allocate space for the caller's vector (remember NULL at the end) */
  746. X     (*vec) = (char **)malloc( (1 + count) * sizeof( char * ) );
  747. !    if ( !*vec ) {
  748. !       fprintf( stderr, "out of memory in strsplit() - aborting\n" );
  749. !       exit( -1 );
  750. !    }
  751. X  
  752. X        /* now go thru token-string again assigning pointers from vector */
  753. X     pread = token_str;
  754. --- 645,669 ----
  755. X        ** make first pass through string, counting # of tokens and
  756. X        ** separating all tokens by a single '\0'
  757. X        */
  758. !    for ( c = *pread++ ; c ; ) {
  759. X        if ( !strchr(separators, c) )   {
  760. !          do {
  761. !             *pwrite++ = c;
  762. !          } while ( (c = *pread++) && !strchr(separators, c) );
  763. !          *pwrite++ = '\0';
  764. !          ++count;
  765. !          do {
  766. !             *pwrite++ = c;
  767. !          } while ( (c = *pread++) && !strchr(separators, c) );
  768. !         *pwrite++ = '\0';
  769. !         ++count;
  770. !       }/*if*/
  771. !       while ( c && strchr(separators, c) )   c = *pread++;
  772. !    }/*for*/
  773. X  
  774. X        /* allocate space for the caller's vector (remember NULL at the end) */
  775. X     (*vec) = (char **)malloc( (1 + count) * sizeof( char * ) );
  776. !    if ( !*vec )  syserr( "malloc failed in strsplit()" );
  777. X  
  778. X        /* now go thru token-string again assigning pointers from vector */
  779. X     pread = token_str;
  780. ***************
  781. *** 748,753 ****
  782. --- 764,912 ----
  783. X  
  784. X  
  785. X  /***************************************************************************
  786. + ** ^FUNCTION: get_argpfx - get the prefix portion of a string
  787. + **
  788. + ** ^SYNOPSIS:
  789. + */
  790. + #ifndef __ANSI_C__
  791. +    int get_argpfx( str )
  792. + /*
  793. + ** ^PARAMETERS:
  794. + */
  795. +    char *str;
  796. + /*    -- the string to parse for a description
  797. + */
  798. + #endif  /* !__ANSI_C__ */
  799. + 
  800. + /* ^DESCRIPTION:
  801. + **    Get_argdesc returns the length of the first portion of the string.
  802. + **
  803. + **    Two "portions" must be either separated by whitespace or the second
  804. + **    portion may be within "(),{},[], or <>" delimiters. The second
  805. + **    portion is assumed to begin with the first alphabetic following
  806. + **    separator.
  807. + **
  808. + ** ^REQUIREMENTS:
  809. + **    str should be non-null and non-empty
  810. + **
  811. + ** ^SIDE-EFFECTS:
  812. + **    None.
  813. + **
  814. + ** ^RETURN-VALUE:
  815. + **    The length of the first portion.
  816. + **
  817. + ** ^ALGORITHM:
  818. + **    - locate the end of the first portion by scanning for whitespace or
  819. + **      balanced delimiters.
  820. + ***^^**********************************************************************/
  821. + #ifdef __ANSI_C__
  822. +    int get_argpfx( const char *str )
  823. + #endif
  824. + {
  825. +    register char  *description;
  826. +    static CONST char  whitespace[]  = " \t\n\r\f\v";
  827. +    static CONST char  beg_portion[] = "(<{[";
  828. + 
  829. +    description = strpbrk( str, whitespace );
  830. +    if ( !description ) {
  831. +        description = strpbrk( str, beg_portion );
  832. +    }
  833. + 
  834. +    return description ? description - str : strlen(str);
  835. + }
  836. + 
  837. + 
  838. + /***************************************************************************
  839. + ** ^FUNCTION: get_argdesc - get the description portion of a string
  840. + **
  841. + ** ^SYNOPSIS:
  842. + */
  843. + #ifndef __ANSI_C__
  844. +    char *get_argdesc( str, len )
  845. + /*
  846. + ** ^PARAMETERS:
  847. + */
  848. +    char *str;
  849. + /*    -- the string to parse for a description
  850. + */
  851. +    int *len;
  852. + /*    -- the pointer to the length
  853. + */
  854. + #endif  /* !__ANSI_C__ */
  855. + 
  856. + /* ^DESCRIPTION:
  857. + **    Get_argdesc returns a pointer to the second portion of the string
  858. + **    and also indicates how long it is.
  859. + **
  860. + **    Two "portions" must be either separated by whitespace or the second
  861. + **    portion may be within "(),{},[], or <>" delimiters. The second
  862. + **    portion is assumed to begin with the first alphabetic following
  863. + **    separator.
  864. + **
  865. + ** ^REQUIREMENTS:
  866. + **    str should be non-null and non-empty
  867. + **
  868. + ** ^SIDE-EFFECTS:
  869. + **    The length of the description is written to *len.
  870. + **
  871. + ** ^RETURN-VALUE:
  872. + **    Address of the description (or NULL if the string has no description).
  873. + **
  874. + ** ^ALGORITHM:
  875. + **    - locate the end of the first portion by scanning for whitespace or
  876. + **      balanced delimiters.
  877. + **    - locate the beginning of the second portion by scanning for the first
  878. + **      alpha-numeric following the end of the first portion.
  879. + **    - return the address of the description.
  880. + ***^^**********************************************************************/
  881. + #ifdef __ANSI_C__
  882. +    char *get_argdesc( const char *str, int *len )
  883. + #endif
  884. + {
  885. +    register char  *description = CHARNULL;
  886. +    BOOL  is_end = FALSE, is_balanced = FALSE;
  887. +    char  *p;
  888. +    static CONST char  whitespace[]  = " \t\n\r\f\v";
  889. +    static CONST char  beg_portion[] = "(<{[";
  890. +    static CONST char  end_portion[] = ")>}]";
  891. + 
  892. +    description = strpbrk( str, whitespace );
  893. +    if ( description ) {
  894. +       is_end = TRUE;
  895. +       while ( isspace(*++description) )  continue;  /* trim leading ' ' */
  896. +       if ( strchr(beg_portion, *description) ) {
  897. +             is_balanced = TRUE;
  898. +             ++description;
  899. +       }
  900. +    }
  901. +    else {
  902. +        description = strpbrk( str, beg_portion );
  903. +        if ( description ) {  /* skip leading '(' */
  904. +           is_end = is_balanced = TRUE;
  905. +           ++description;
  906. +        }
  907. +    }
  908. + 
  909. +    if ( !description ) {
  910. +       *len = 0;
  911. +    }
  912. +    else {
  913. +       if ( is_balanced ) {  /* remove trailing ')' */
  914. +          p = description + (strlen( description ) - 1);
  915. +          if ( !strchr(end_portion, *p) )  ++p;
  916. +          *len = p - description;
  917. +       }
  918. +       else {
  919. +          while ( !isalnum(*description) )  ++description;
  920. +          *len = strlen( description );
  921. +       }
  922. +    }
  923. + 
  924. +    return  description;
  925. + }
  926. + 
  927. + 
  928. + /***************************************************************************
  929. X  ** ^FUNCTION: get_argname - return the aname (argument-name) of an argument
  930. X  **
  931. X  ** ^SYNOPSIS:
  932. ***************
  933. *** 787,803 ****
  934. X     char *get_argname( const char *s, char *buf )
  935. X  #endif
  936. X  {
  937. !    register CONST char *p1 = s, *p2;
  938. X  
  939. X        /* see if sname and aname are separated by c_ARG_SEP
  940. X        ** <buf> must be large enough to hold the result!
  941. X        */
  942. !    p2 = strchr( p1, c_ARG_SEP );
  943. !    if ( p2 ) {
  944. !       strlcpy( buf, ++p2 );
  945. X     }
  946. X     else {
  947. !       strlcpy(buf, s);
  948. X     }
  949. X     return   buf;
  950. X  }
  951. --- 946,969 ----
  952. X     char *get_argname( const char *s, char *buf )
  953. X  #endif
  954. X  {
  955. !    register CONST char *p2;
  956. !    int len;
  957. X  
  958. X        /* see if sname and aname are separated by c_ARG_SEP
  959. X        ** <buf> must be large enough to hold the result!
  960. X        */
  961. !    len = get_argpfx(s);
  962. !    p2 = strchr( s, c_ARG_SEP );
  963. !    if ( p2 && p2 < &s[len]) {
  964. !       ++p2;
  965. !       strncpy( buf, p2, len-(p2-s) );
  966. !       buf[len-(p2-s)] = 0;
  967. !       strlwr(buf);
  968. X     }
  969. X     else {
  970. !       strncpy( buf, s, len );
  971. !       buf[len] = 0;
  972. !       strlwr(buf);
  973. X     }
  974. X     return   buf;
  975. X  }
  976. ***************
  977. *** 849,871 ****
  978. X  #endif
  979. X  {
  980. X     register char *p1 = (char *)s, *p2, ch;
  981. X     BOOL caps = FALSE;
  982. X  
  983. X     if ( !p1 )  return  CHARNULL;
  984. X  
  985. X        /* see if sname and aname are separated by c_ARG_SEP */
  986. X     p2 = strchr( p1, c_ARG_SEP );
  987. !    if ( p2 ) {
  988. !       ch = *p2;
  989. !       *p2 = '\0';
  990. !       KWDCASECOPY( buf, p1 );
  991. !       *p2 = ch;
  992. X        return  buf;
  993. X     }
  994. X  
  995. X        /* copy string into buffer and convert it to desired case */
  996. X        /* <buf> must be large enough to hold the result! */
  997. !    for ( p2 = buf; *p1 ; p1++ ) {
  998. X        if ( isupper(*p1) ) {
  999. X           if ( !caps ) {
  1000. X              caps = TRUE;
  1001. --- 1015,1038 ----
  1002. X  #endif
  1003. X  {
  1004. X     register char *p1 = (char *)s, *p2, ch;
  1005. +    int len;
  1006. X     BOOL caps = FALSE;
  1007. X  
  1008. X     if ( !p1 )  return  CHARNULL;
  1009. X  
  1010. X        /* see if sname and aname are separated by c_ARG_SEP */
  1011. +    len = get_argpfx( p1 );
  1012. X     p2 = strchr( p1, c_ARG_SEP );
  1013. !    if ( p2 && p2 < &p1[len]) {
  1014. !       strncpy( buf, p1, p2-p1);
  1015. !       buf[p2-p1] = 0;
  1016. !       FORCE_KWDCASE(buf);
  1017. X        return  buf;
  1018. X     }
  1019. X  
  1020. X        /* copy string into buffer and convert it to desired case */
  1021. X        /* <buf> must be large enough to hold the result! */
  1022. !    for ( p2 = buf; *p1 && len != 0; p1++, len-- ) {
  1023. X        if ( isupper(*p1) ) {
  1024. X           if ( !caps ) {
  1025. X              caps = TRUE;
  1026. ***************
  1027. *** 1145,1151 ****
  1028. X  ** ^SYNOPSIS:
  1029. X  */
  1030. X  #ifndef __ANSI_C__
  1031. !    VOID indent_para(fp, maxcols, margin, title, indent, text)
  1032. X  /*
  1033. X  ** ^PARAMETERS:
  1034. X  */
  1035. --- 1312,1318 ----
  1036. X  ** ^SYNOPSIS:
  1037. X  */
  1038. X  #ifndef __ANSI_C__
  1039. !    VOID indent_para(fp, maxcols, margin, title, indent, text, textlen)
  1040. X  /*
  1041. X  ** ^PARAMETERS:
  1042. X  */
  1043. ***************
  1044. *** 1167,1172 ****
  1045. --- 1334,1342 ----
  1046. X     char *text;
  1047. X  /*    -- the body of the paragraph
  1048. X  */
  1049. +    int textlen;
  1050. + /*    -- the length of the body of the paragraph
  1051. + */
  1052. X  #endif  /* !__ANSI_C__ */
  1053. X  
  1054. X  /* ^DESCRIPTION:
  1055. ***************
  1056. *** 1193,1204 ****
  1057. X  ***^^**********************************************************************/
  1058. X  #ifdef __ANSI_C__
  1059. X     void indent_para( FILE *fp, int maxcols, int margin,
  1060. !                      const char *title, int indent, const char *text )
  1061. X  #endif
  1062. X  {
  1063. X     register int idx = 0;
  1064. X     BOOL first_line = TRUE;
  1065. -    int  text_len = strlen(text);
  1066. X     char ch;
  1067. X  
  1068. X     /* print the title */
  1069. --- 1363,1374 ----
  1070. X  ***^^**********************************************************************/
  1071. X  #ifdef __ANSI_C__
  1072. X     void indent_para( FILE *fp, int maxcols, int margin,
  1073. !                      const char *title, int indent, const char *text,
  1074. !                      int textlen )
  1075. X  #endif
  1076. X  {
  1077. X     register int idx = 0;
  1078. X     BOOL first_line = TRUE;
  1079. X     char ch;
  1080. X  
  1081. X     /* print the title */
  1082. ***************
  1083. *** 1206,1241 ****
  1084. X  
  1085. X     idx = maxcols - margin - indent;
  1086. X  
  1087. !    if ( text_len <= idx )
  1088. !       fprintf(fp, "%s\n", text);
  1089. X     else
  1090. X        do {
  1091. X                 /* backup to end of previous word */
  1092. X           while (idx  &&  !isspace(text[idx]))  --idx;
  1093. X           while (idx  &&  isspace(text[idx]))   --idx;
  1094. X  
  1095. X              /* print leading whitespace */
  1096. X           if (!first_line)
  1097. X              fprintf(fp, "%*s%-*s", margin, "", indent, "");
  1098. X  
  1099. !          ch = text[ ++idx ];
  1100. !          *((char *)text + idx) = '\0';
  1101. !          fprintf(fp, "%s\n", text);
  1102. !          *((char *)text + idx) = ch;
  1103. X           first_line = FALSE;
  1104. X           text = &(text[idx+1]);
  1105. !          text_len -= (idx+1);
  1106. X  
  1107. X           while (isspace(*text)) {  /* goto next word */
  1108. X              ++text;
  1109. !             --text_len;
  1110. X           }
  1111. X  
  1112. X           idx = maxcols - margin - indent;
  1113. X  
  1114. !          if ( text_len <= idx )  /* print-last line */
  1115. !             fprintf(fp, "%*s%-*s%s\n", margin, "", indent, "", text);
  1116. !       } while ( text_len > idx );
  1117. X  }
  1118. X  
  1119. X  
  1120. --- 1376,1410 ----
  1121. X  
  1122. X     idx = maxcols - margin - indent;
  1123. X  
  1124. !    if ( textlen <= idx )
  1125. !       fprintf(fp, "%.*s\n", textlen, text);
  1126. X     else
  1127. X        do {
  1128. X                 /* backup to end of previous word */
  1129. X           while (idx  &&  !isspace(text[idx]))  --idx;
  1130. X           while (idx  &&  isspace(text[idx]))   --idx;
  1131. +          idx++;
  1132. X  
  1133. X              /* print leading whitespace */
  1134. X           if (!first_line)
  1135. X              fprintf(fp, "%*s%-*s", margin, "", indent, "");
  1136. X  
  1137. !          fprintf(fp, "%.*s\n", idx, text);
  1138. ! 
  1139. X           first_line = FALSE;
  1140. X           text = &(text[idx+1]);
  1141. !          textlen -= (idx+1);
  1142. X  
  1143. X           while (isspace(*text)) {  /* goto next word */
  1144. X              ++text;
  1145. !             --textlen;
  1146. X           }
  1147. X  
  1148. X           idx = maxcols - margin - indent;
  1149. X  
  1150. !          if ( textlen <= idx )  /* print-last line */
  1151. !             fprintf(fp, "%*s%-*s%.*s\n", margin, "", indent, "", textlen, text);
  1152. !       } while ( textlen > idx );
  1153. X  }
  1154. X  
  1155. X  
  1156. *** strfuncs.h.OLD    Thu Nov 21 15:21:03 1991
  1157. --- strfuncs.h    Mon Nov 18 16:19:25 1991
  1158. ***************
  1159. *** 5,10 ****
  1160. --- 5,14 ----
  1161. X  **    External declarations for the functions implemented in strfuncs.c
  1162. X  **
  1163. X  ** ^HISTORY:
  1164. + **    27/08/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  1165. + **    - Add extra argument to indent_para()
  1166. + **    - Add new prototypes for get_argdesc() and get_argpfx()
  1167. + **
  1168. X  **    01/07/91    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  1169. X  ***^^**********************************************************************/
  1170. X  
  1171. ***************
  1172. *** 35,43 ****
  1173. X  
  1174. X  EXTERN  char  *get_argname  ARGS(( const char *, char * ));
  1175. X  EXTERN  char  *get_kwdname  ARGS(( const char *, char * ));
  1176. X  EXTERN  int    match        ARGS(( const char *, const char * ));
  1177. X  EXTERN  char  *basename     ARGS(( char * ));
  1178. X  EXTERN  VOID   indent_para  ARGS(( FILE *, int, int,
  1179. !                                    const char *, int, const char * ));
  1180. X  
  1181. X  #endif
  1182. --- 39,49 ----
  1183. X  
  1184. X  EXTERN  char  *get_argname  ARGS(( const char *, char * ));
  1185. X  EXTERN  char  *get_kwdname  ARGS(( const char *, char * ));
  1186. + EXTERN  char  *get_argdesc  ARGS(( const char *, int * ));
  1187. + EXTERN  int    get_argpfx   ARGS(( const char * ));
  1188. X  EXTERN  int    match        ARGS(( const char *, const char * ));
  1189. X  EXTERN  char  *basename     ARGS(( char * ));
  1190. X  EXTERN  VOID   indent_para  ARGS(( FILE *, int, int,
  1191. !                                    const char *, int, const char *, int ));
  1192. X  
  1193. X  #endif
  1194. *** syserr.c.OLD    Thu Nov 21 15:21:10 1991
  1195. --- syserr.c    Mon Nov 18 16:19:57 1991
  1196. ***************
  1197. *** 10,15 ****
  1198. --- 10,18 ----
  1199. X  **       eprintf() --  print to stderr and return
  1200. X  **
  1201. X  ** ^HISTORY:
  1202. + **    27/08/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  1203. + **    - Use ProgNameLen when accessing ProgName
  1204. + **
  1205. X  **    01/02/91    Brad Appleton    <brad@ssd.csd.harris.com>
  1206. X  **       - Changed to use varargs/stdargs
  1207. X  **       - Added structured comment blocks
  1208. ***************
  1209. *** 28,33 ****
  1210. --- 31,37 ----
  1211. X  VERSIONID("$Header: syserr.c,v 2.0 89/12/24 00:56:31 eric Exp $");
  1212. X  
  1213. X  extern  char *ProgName;
  1214. + extern  int ProgNameLen;
  1215. X  EXTERN  int   vfprintf  ARGS((FILE *, const char *, va_list));
  1216. X  
  1217. X  
  1218. ***************
  1219. *** 75,81 ****
  1220. X     int save_err;
  1221. X  
  1222. X     save_err = errno;
  1223. !    if (ProgName  &&  *ProgName)  fprintf(stderr, "%s: ", ProgName);
  1224. X  
  1225. X     (VOID) vfprintf(stderr, format, ap);
  1226. X  
  1227. --- 79,86 ----
  1228. X     int save_err;
  1229. X  
  1230. X     save_err = errno;
  1231. !    if (ProgName  &&  *ProgName)
  1232. !       fprintf(stderr, "%.*s: ", ProgNameLen, ProgName);
  1233. X  
  1234. X     (VOID) vfprintf(stderr, format, ap);
  1235. X  
  1236. *** unix_args.c.OLD    Thu Nov 21 15:21:49 1991
  1237. --- unix_args.c    Mon Nov 18 16:20:49 1991
  1238. ***************
  1239. *** 6,11 ****
  1240. --- 6,15 ----
  1241. X  **    vectors and to print Unix usage messages.
  1242. X  **
  1243. X  ** ^HISTORY:
  1244. + **    27/08/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  1245. + **    - Use ProgNameLen when accessing ProgName
  1246. + **    - Use get_argdesc() to access description
  1247. + **
  1248. X  **    01/02/91     Brad Appleton     <brad@ssd.csd.harris.com>
  1249. X  **    - Added structured block comments
  1250. X  **    - Added optional arguments to keywords and options
  1251. ***************
  1252. *** 615,623 ****
  1253. X        /* get screen size */
  1254. X     get_winsize( fileno(fp), &max_lines, &max_cols );
  1255. X  
  1256. !    fprintf(fp, "Usage: %s", ProgName);
  1257. X  
  1258. !    ll = strlen( ProgName ) + 7;
  1259. X     margin = ll + 1;
  1260. X     longest = 0;
  1261. X  
  1262. --- 619,627 ----
  1263. X        /* get screen size */
  1264. X     get_winsize( fileno(fp), &max_lines, &max_cols );
  1265. X  
  1266. !    fprintf(fp, "Usage: %.*s", ProgNameLen, ProgName);
  1267. X  
  1268. !    ll = ProgNameLen + 7;
  1269. X     margin = ll + 1;
  1270. X     longest = 0;
  1271. X  
  1272. ***************
  1273. *** 693,698 ****
  1274. --- 697,704 ----
  1275. X        for ( args = argd ; args ; args = cmd_defargs(args) ) {
  1276. X           for ( ad = ARG_FIRST(args) ; !ARG_isEND(ad) ; ARG_ADVANCE(ad) ) {
  1277. X              argName_t  buf;
  1278. +             char  *desc;
  1279. +             int  desclen;
  1280. X  
  1281. X                 /* don't display hidden arguments */
  1282. X              if ( ARG_isHIDDEN(ad) )  continue;
  1283. ***************
  1284. *** 701,707 ****
  1285. X  
  1286. X              if ( !options++ )   fprintf(fp, "Options/Arguments:\n");
  1287. X              fmtarg(ad, buf, usage_flags);
  1288. !             indent_para( fp, max_cols, 8, buf, longest+2, arg_description(ad) );
  1289. X           }/*for each ad */
  1290. X        }/* for each argd */
  1291. X     }/* for each parm-type */
  1292. --- 707,714 ----
  1293. X  
  1294. X              if ( !options++ )   fprintf(fp, "Options/Arguments:\n");
  1295. X              fmtarg(ad, buf, usage_flags);
  1296. !             desc = get_argdesc(arg_description(ad), &desclen);
  1297. !             indent_para( fp, max_cols, 8, buf, longest+2, desc, desclen );
  1298. X           }/*for each ad */
  1299. X        }/* for each argd */
  1300. X     }/* for each parm-type */
  1301. *** unix_man.c.OLD    Thu Nov 21 15:21:57 1991
  1302. --- unix_man.c    Mon Nov 18 16:23:09 1991
  1303. ***************
  1304. *** 7,12 ****
  1305. --- 7,16 ----
  1306. X  **    The template is formatted for {n|t}roff using the -man macros.
  1307. X  **
  1308. X  ** ^HISTORY:
  1309. + **    27/08/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  1310. + **    - Use ProgNameLen when accessing ProgName
  1311. + **    - Use get_argpfx() to access names
  1312. + **
  1313. X  **    01/02/91     Brad Appleton     <brad@ssd.csd.harris.com>     Created
  1314. X  ***^^**********************************************************************/
  1315. X  
  1316. ***************
  1317. *** 24,30 ****
  1318. X  #define MAXCOLS  65
  1319. X  #define VAL(str)           ((str) ? str : "")
  1320. X  #define COMMENT            printf(".\\\"-----------------------------------\n")
  1321. ! #define TH(title,section)  printf(".TH %s %d\n", title, section )
  1322. X  #define SH(title)          printf(".SH %s\n", title )
  1323. X  #define TP(cols,title)     printf(".TP %d\n%s\n", cols, title )
  1324. X  #define PP                 printf(".PP\n" )
  1325. --- 28,34 ----
  1326. X  #define MAXCOLS  65
  1327. X  #define VAL(str)           ((str) ? str : "")
  1328. X  #define COMMENT            printf(".\\\"-----------------------------------\n")
  1329. ! #define TH(title,len,section)  printf(".TH %.*s %d\n", len, title, section )
  1330. X  #define SH(title)          printf(".SH %s\n", title )
  1331. X  #define TP(cols,title)     printf(".TP %d\n%s\n", cols, title )
  1332. X  #define PP                 printf(".PP\n" )
  1333. ***************
  1334. *** 165,171 ****
  1335. X     register CONST ARGDESC *ad, *args, *cmd;
  1336. X     argName_t  name;
  1337. X     CONST char *program, *purpose, *description;
  1338. !    int   len, maxlen, positionals;
  1339. X  
  1340. X        /* allow null argument descriptor */
  1341. X     if ( !argd )  return;
  1342. --- 169,175 ----
  1343. X     register CONST ARGDESC *ad, *args, *cmd;
  1344. X     argName_t  name;
  1345. X     CONST char *program, *purpose, *description;
  1346. !    int   len, maxlen, positionals, namelen, programlen, purposelen;
  1347. X  
  1348. X        /* allow null argument descriptor */
  1349. X     if ( !argd )  return;
  1350. ***************
  1351. *** 173,187 ****
  1352. X     if ( !CMD_isINIT(argd) )   init_args( (ARGDESC *)argd );
  1353. X     cmd = argd;
  1354. X  
  1355. !    (VOID) strcpy( name, cmd_name(cmd) );
  1356. X     if ( cmd_name(cmd) ) {
  1357. X        program = cmd_name(cmd);
  1358. X     }
  1359. X     else if ( cmd_argv0(cmd) ) {
  1360. X        program = cmd_argv0(cmd);
  1361. X     }
  1362. X  
  1363. X     purpose = cmd_purpose(cmd);
  1364. X     description = cmd_description(cmd);
  1365. X  
  1366. X     printf(".\\\"---------- TO PRINT, USE: {n,t}roff -man file ----------\n");
  1367. --- 177,213 ----
  1368. X     if ( !CMD_isINIT(argd) )   init_args( (ARGDESC *)argd );
  1369. X     cmd = argd;
  1370. X  
  1371. !    name[0] = 0;
  1372. !    namelen = 0;
  1373. X     if ( cmd_name(cmd) ) {
  1374. +       (VOID) strcpy( name, cmd_name(cmd) );
  1375. +       if ( !BTEST(cmd_state(cmd), ps_USERNAME|ps_FREENAME) ) {
  1376. +          namelen = get_argpfx( name );
  1377. +          name[namelen] = 0;
  1378. +       }
  1379. +       else {
  1380. +          namelen = strlen( cmd_name(cmd) );
  1381. +       }
  1382. +    }
  1383. + 
  1384. +    program = 0;
  1385. +    programlen = 0;
  1386. +    if ( cmd_name(cmd) ) {
  1387. X        program = cmd_name(cmd);
  1388. +       programlen = namelen;
  1389. X     }
  1390. X     else if ( cmd_argv0(cmd) ) {
  1391. X        program = cmd_argv0(cmd);
  1392. +       programlen = strlen(program);
  1393. X     }
  1394. X  
  1395. X     purpose = cmd_purpose(cmd);
  1396. +    if ( !BTEST(cmd_state(cmd), ps_USERPURPOSE|ps_FREEPURPOSE) && purpose ) {
  1397. +       purpose = get_argdesc(purpose, &purposelen);
  1398. +    }
  1399. +    else {
  1400. +      purposelen = strlen(VAL(purpose));
  1401. +    }
  1402. X     description = cmd_description(cmd);
  1403. X  
  1404. X     printf(".\\\"---------- TO PRINT, USE: {n,t}roff -man file ----------\n");
  1405. ***************
  1406. *** 190,203 ****
  1407. X  
  1408. X     COMMENT;
  1409. X  #ifdef SVR4
  1410. !    TH( name, 1 );
  1411. X  #else
  1412. !    TH( strupr(name), 1 );
  1413. X  #endif
  1414. X  
  1415. X     COMMENT;
  1416. X     SH( "NAME" );
  1417. !    printf( "%s \\- %s\n", VAL(program), VAL(purpose) );
  1418. X  
  1419. X     COMMENT;
  1420. X     SH( "SYNOPSIS" );
  1421. --- 216,229 ----
  1422. X  
  1423. X     COMMENT;
  1424. X  #ifdef SVR4
  1425. !    TH( name, namelen, 1 );
  1426. X  #else
  1427. !    TH( strupr(name), namelen, 1 );
  1428. X  #endif
  1429. X  
  1430. X     COMMENT;
  1431. X     SH( "NAME" );
  1432. !    printf( "%s \\- %.*s\n", VAL(program), purposelen, VAL(purpose) );
  1433. X  
  1434. X     COMMENT;
  1435. X     SH( "SYNOPSIS" );
  1436. ***************
  1437. *** 204,212 ****
  1438. X  
  1439. X     len = strlen( program ) + 1;
  1440. X  #ifdef SVR4
  1441. !    sprintf( name, "\\f4%s\\fP", program );
  1442. X  #else
  1443. !    sprintf( name, "\\fB%s\\fP", program );
  1444. X  #endif
  1445. X     TP( len, name );
  1446. X  
  1447. --- 230,238 ----
  1448. X  
  1449. X     len = strlen( program ) + 1;
  1450. X  #ifdef SVR4
  1451. !    sprintf( name, "\\f4%.*s\\fP", programlen, program );
  1452. X  #else
  1453. !    sprintf( name, "\\fB%.*s\\fP", programlen, program );
  1454. X  #endif
  1455. X     TP( len, name );
  1456. X  
  1457. ***************
  1458. *** 246,251 ****
  1459. --- 272,279 ----
  1460. X        for ( args = argd ; args ; args = cmd_defargs(args) ) {
  1461. X           for ( ad = ARG_FIRST(args) ; !ARG_isEND(ad) ; ARG_ADVANCE(ad) ) {
  1462. X              argName_t  buf;
  1463. +             char  *desc;
  1464. +             int  desclen;
  1465. X  
  1466. X                 /* don't display hidden arguments */
  1467. X              if ( ARG_isHIDDEN(ad) )  continue;
  1468. ***************
  1469. *** 254,260 ****
  1470. X  
  1471. X              (VOID) fmtarg( ad, buf );
  1472. X              TP( maxlen + 2, buf );
  1473. !             indent_para(stdout, MAXCOLS, 0, "", 0, arg_description(ad) );
  1474. X           }/*for each ad */
  1475. X        }/* for each argd */
  1476. X     }/* for each parm-type */
  1477. --- 282,289 ----
  1478. X  
  1479. X              (VOID) fmtarg( ad, buf );
  1480. X              TP( maxlen + 2, buf );
  1481. !             desc = get_argdesc(arg_description(ad), &desclen);
  1482. !             indent_para(stdout, MAXCOLS, 0, "", 0, desc, desclen );
  1483. X           }/*for each ad */
  1484. X        }/* for each argd */
  1485. X     }/* for each parm-type */
  1486. *** useful.h.OLD    Thu Nov 21 15:22:05 1991
  1487. --- useful.h    Mon Nov 18 16:23:49 1991
  1488. ***************
  1489. *** 255,262 ****
  1490. X     EXTERN  char  *strpbrk   ARGS(( const char *, const char * ));
  1491. X     EXTERN  int    strspn    ARGS(( const char *, const char * ));
  1492. X     EXTERN  int    strcspn   ARGS(( const char *, const char * ));
  1493. !    EXTERN  char  *strtok    ARGS(( char *, char * ));
  1494. !    EXTERN  char  *strdup    ARGS(( const char * ));
  1495. X     
  1496. X  # else
  1497. X  #  define strchr(s,c)   index(s,c)
  1498. --- 255,261 ----
  1499. X     EXTERN  char  *strpbrk   ARGS(( const char *, const char * ));
  1500. X     EXTERN  int    strspn    ARGS(( const char *, const char * ));
  1501. X     EXTERN  int    strcspn   ARGS(( const char *, const char * ));
  1502. !    EXTERN  char  *strtok    ARGS(( char *, const char * ));
  1503. X     
  1504. X  # else
  1505. X  #  define strchr(s,c)   index(s,c)
  1506. ***************
  1507. *** 294,299 ****
  1508. --- 293,299 ----
  1509. X  
  1510. X  #if ( !defined(__ANSI_C__)  &&  !defined(_SIZE_T_DEFINED) )
  1511. X  # if (defined(sun) && defined(BSD))
  1512. + #  include <sys/types.h>
  1513. X  #  if (!defined (__sys_stdtypes_h))
  1514. X      /* size_t is also defined in <sys/stdtypes.h> in SunOS 4.1 */
  1515. X      typedef int size_t;
  1516. *** vms_args.c.OLD    Thu Nov 21 15:22:11 1991
  1517. --- vms_args.c    Thu Nov 21 15:16:13 1991
  1518. ***************
  1519. *** 6,11 ****
  1520. --- 6,22 ----
  1521. X  **    vectors and to print VMS/DCL usage messages.
  1522. X  **
  1523. X  ** ^HISTORY:
  1524. + **    11/21/91    Brad Appleton    <brad@ssd.csd.harris.com>
  1525. + **    - added Mike Levins fix to is_cmdline() to check for 0 length
  1526. + **      returned by lib$get_foreign.
  1527. + **    - added check of ps_NOTCMDLINE state-flag before calling is_cmdline()
  1528. + **    - fixed problem in vms_parse() where ARGVALGIVEN was getting set in
  1529. + **      place of ARGGIVEN.
  1530. + **
  1531. + **    08/27/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  1532. + **    - Use ProgNameLen when accessing ProgName
  1533. + **    - Use get_argdesc() to access description
  1534. + **
  1535. X  **    12/03/90    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  1536. X  ***^^**********************************************************************/
  1537. X  
  1538. ***************
  1539. *** 127,137 ****
  1540. X     static BOOL is_cmdline( const char *argv[], char **result )
  1541. X  #endif
  1542. X  {
  1543. X     unsigned long int stat;
  1544. X     unsigned short int len;
  1545. !    register CONST char *aptr, *sptr, *avstr;
  1546. !    static char str[ MAXCMDLINE ] = "" ;
  1547. ! #ifdef vms
  1548. X     $DESCRIPTOR(str_d, str);
  1549. X  #endif
  1550. X  
  1551. --- 138,150 ----
  1552. X     static BOOL is_cmdline( const char *argv[], char **result )
  1553. X  #endif
  1554. X  {
  1555. +    register CONST char *avstr;
  1556. + #ifdef vms
  1557. X     unsigned long int stat;
  1558. X     unsigned short int len;
  1559. !    register CONST char *aptr, *sptr;
  1560. !    static char str[ MAXCMDLINE ];
  1561. !    static BOOL got_cmd_line = FALSE;
  1562. X     $DESCRIPTOR(str_d, str);
  1563. X  #endif
  1564. X  
  1565. ***************
  1566. *** 144,155 ****
  1567. X  
  1568. X  #else
  1569. X        /* get the original command-line */
  1570. !    if ( !*str ) {
  1571. X        stat = lib$get_foreign( &str_d, VNULL, &len, VNULL );
  1572. X        str[len] = '\0';
  1573. X        if (! (stat & 1))  exit( stat );
  1574. X     }
  1575. X  
  1576. X        /* compare the two */
  1577. X     for ( aptr = avstr, sptr = str ; *aptr && *sptr ; sptr++ ) {
  1578. X        if ( toupper(*sptr) == toupper(*aptr) ) {
  1579. --- 157,175 ----
  1580. X  
  1581. X  #else
  1582. X        /* get the original command-line */
  1583. !    if ( ! got_cmd_line ) {
  1584. X        stat = lib$get_foreign( &str_d, VNULL, &len, VNULL );
  1585. X        str[len] = '\0';
  1586. +       got_cmd_line = TRUE;
  1587. X        if (! (stat & 1))  exit( stat );
  1588. X     }
  1589. X  
  1590. +       /* if we didnt have a command-line, dont bother comparing */
  1591. +    if ( !*str ) {
  1592. +       *result = (char *)avstr;
  1593. +       return  FALSE;
  1594. +    }
  1595. + 
  1596. X        /* compare the two */
  1597. X     for ( aptr = avstr, sptr = str ; *aptr && *sptr ; sptr++ ) {
  1598. X        if ( toupper(*sptr) == toupper(*aptr) ) {
  1599. ***************
  1600. *** 596,602 ****
  1601. X  
  1602. X     if ( !argv || !*argv )  return  parse_error;
  1603. X  
  1604. !    (VOID) is_cmdline( (CONST char **)argv, &avstr );
  1605. X     BSET( cmd_flags(cmd), pa_COPYF );
  1606. X     (VOID) dcl_strxlat( avstr );
  1607. X     if ( !avstr || !*avstr )  return  parse_error;
  1608. --- 616,624 ----
  1609. X  
  1610. X     if ( !argv || !*argv )  return  parse_error;
  1611. X  
  1612. !    if ( !BTEST(cmd_state(cmd), ps_NOTCMDLINE) ) {
  1613. !       (VOID) is_cmdline( (CONST char **)argv, &avstr );
  1614. !    }
  1615. X     BSET( cmd_flags(cmd), pa_COPYF );
  1616. X     (VOID) dcl_strxlat( avstr );
  1617. X     if ( !avstr || !*avstr )  return  parse_error;
  1618. ***************
  1619. *** 680,686 ****
  1620. X              /* now get the real value */
  1621. X           if ( !s || !(*s) ) {
  1622. X              if ( ARG_isVALOPTIONAL(ad) ) {
  1623. !                BSET( arg_flags(ad), ARGVALGIVEN );
  1624. X              }
  1625. X              else {
  1626. X                 (VOID) get_kwdname( arg_sname(ad), keyword );
  1627. --- 702,708 ----
  1628. X              /* now get the real value */
  1629. X           if ( !s || !(*s) ) {
  1630. X              if ( ARG_isVALOPTIONAL(ad) ) {
  1631. !                BSET( arg_flags(ad), ARGGIVEN );
  1632. X              }
  1633. X              else {
  1634. X                 (VOID) get_kwdname( arg_sname(ad), keyword );
  1635. ***************
  1636. *** 942,950 ****
  1637. X        : stderr;
  1638. X  
  1639. X        /* allow null argument descriptor */
  1640. !    fprintf(fp, "Format: %s", ProgName);
  1641. X  
  1642. !    ll = strlen( ProgName ) + 8;
  1643. X     margin = ll + 1;
  1644. X     longest = 0;
  1645. X  
  1646. --- 964,972 ----
  1647. X        : stderr;
  1648. X  
  1649. X        /* allow null argument descriptor */
  1650. !    fprintf(fp, "Format: %.*s", ProgNameLen, ProgName);
  1651. X  
  1652. !    ll = ProgNameLen + 8;
  1653. X     margin = ll + 1;
  1654. X     longest = 0;
  1655. X  
  1656. ***************
  1657. *** 1020,1025 ****
  1658. --- 1042,1049 ----
  1659. X        for ( args = argd ; args ; args = cmd_defargs(args) ) {
  1660. X           for ( ad = ARG_FIRST(args) ; !ARG_isEND(ad) ; ARG_ADVANCE(ad) ) {
  1661. X              argName_t  buf;
  1662. +         char  *desc;
  1663. +         int  desclen;
  1664. X  
  1665. X                 /* don't display hidden arguments */
  1666. X              if ( ARG_isHIDDEN(ad) )  continue;
  1667. ***************
  1668. *** 1028,1034 ****
  1669. X  
  1670. X              if ( !qualifiers++ )  fprintf(fp, "Qualifiers/Parameters:\n");
  1671. X              (VOID) fmtarg(ad, buf);
  1672. !             indent_para(fp, max_cols, 8, buf, longest+2, arg_description(ad) );
  1673. X           }/*for each ad */
  1674. X        }/* for each argd */
  1675. X     }/* for each parm-type */
  1676. --- 1052,1059 ----
  1677. X  
  1678. X              if ( !qualifiers++ )  fprintf(fp, "Qualifiers/Parameters:\n");
  1679. X              (VOID) fmtarg(ad, buf);
  1680. !         desc = get_argdesc(arg_description(ad), &desclen);
  1681. !             indent_para(fp, max_cols, 8, buf, longest+2, desc, desclen );
  1682. X           }/*for each ad */
  1683. X        }/* for each argd */
  1684. X     }/* for each parm-type */
  1685. *** xparse.c.OLD    Thu Nov 21 15:22:30 1991
  1686. --- xparse.c    Wed Nov 20 11:07:39 1991
  1687. ***************
  1688. *** 98,103 ****
  1689. --- 98,112 ----
  1690. X  **      previous parse-flags should not be reset until AFTER required
  1691. X  **      arguments are checked for, otherwise we may forget to prompt
  1692. X  **      for them if $PARSECNTL asked us to do so.
  1693. + **
  1694. + **    08/27/91     Earl Chew     <cechew@bruce.cs.monash.edu.au>
  1695. + **    - split out get_description().
  1696. + **    - add ProgNameLen
  1697. + **    - support for non-writable strings
  1698. + **    - allow sparseargs() to parse empty strings like parseargs()
  1699. + **
  1700. + **    04/03/91     Brad Appleton     <brad@ssd.csd.harris.com>
  1701. + **    - changed vms_style stuff to use ps_NOTCMDLINE
  1702. X  ***^^**********************************************************************/
  1703. X  
  1704. X  #include <stdio.h>
  1705. ***************
  1706. *** 170,176 ****
  1707. X  
  1708. X  
  1709. X  /***************************************************************************
  1710. ! ** ^GLOBAL-VARIABLE: ProgName
  1711. X  **
  1712. X  ** ^VISIBILITY:
  1713. X  **    external global (visible to functions in all files)
  1714. --- 179,185 ----
  1715. X  
  1716. X  
  1717. X  /***************************************************************************
  1718. ! ** ^GLOBAL-VARIABLE: ProgName, ProgNameLen
  1719. X  **
  1720. X  ** ^VISIBILITY:
  1721. X  **    external global (visible to functions in all files)
  1722. ***************
  1723. *** 179,186 ****
  1724. --- 188,197 ----
  1725. SHAR_EOF
  1726. true || echo 'restore of PATCH09 failed'
  1727. fi
  1728. echo 'End of  part 1'
  1729. echo 'File PATCH09 is continued in part 2'
  1730. echo 2 > _shar_seq_.tmp
  1731. exit 0
  1732. exit 0 # Just in case...
  1733. -- 
  1734. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1735. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1736. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1737. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1738.