home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume17 / parseargs / part09 < prev    next >
Internet Message Format  |  1991-03-18  |  63KB
  1. From: brad@hcx1.ssd.csd.harris.com (Brad Appleton)
  2. Newsgroups: comp.sources.misc
  3. Subject: v17i054:  parseargs - functions to parse command line arguments, Part09/12
  4. Message-ID: <1991Mar18.155707.2176@sparky.IMD.Sterling.COM>
  5. Date: 18 Mar 91 15:57:07 GMT
  6. Approved: kent@sparky.imd.sterling.com
  7. X-Checksum-Snefru: 5c2e25a2 b3a18d0f 8698d8b5 d41be7ad
  8.  
  9. Submitted-by: Brad Appleton <brad@hcx1.ssd.csd.harris.com>
  10. Posting-number: Volume 17, Issue 54
  11. Archive-name: parseargs/part09
  12.  
  13. This is part 9 of parseargs
  14.  
  15. #!/bin/sh
  16. # this is Part.09 (part 9 of a multipart archive)
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file parseargs/pgopen.c continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 9; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test ! -f _shar_wnt_.tmp; then
  33.     echo 'x - still skipping parseargs/pgopen.c'
  34. else
  35. echo 'x - continuing file parseargs/pgopen.c'
  36. sed 's/^X//' << 'SHAR_EOF' >> 'parseargs/pgopen.c' &&
  37. **    pager-file-pointer.
  38. **
  39. ** ^SIDE-EFECTS:
  40. **    None.
  41. **
  42. ** ^RETURN-VALUE:
  43. **    Zero if the pager is active; non-zero otherwise.
  44. **
  45. ** ^ALGORITHM:
  46. **    Trivial.
  47. ***^^**********************************************************************/
  48. #ifdef __ANSI_C__
  49. X   int pgactive( const FILE *pager_fp )
  50. #endif
  51. {
  52. X   return  ( (Pager_Type != PG_CLOSED)  &&  (pager_fp) );
  53. }
  54. X
  55. X
  56. /***************************************************************************
  57. ** ^FUNCTION: pgclose - close the pager.
  58. **
  59. ** ^SYNOPSIS:
  60. */
  61. #ifndef __ANSI_C__
  62. X   int pgclose( pager_fp )
  63. /*
  64. ** ^PARAMETERS:
  65. */
  66. X   FILE *pager_fp;
  67. /*    -- the file-pointer returned by pgopen()
  68. */
  69. #endif  /* !__ANSI_C__ */
  70. X
  71. /* ^DESCRIPTION:
  72. **    Pgclose will flush any remaining output and close the pager.
  73. **
  74. ** ^REQUIREMENTS:
  75. **    pgopen() must first be called in order to obtain a valid
  76. **    pager-file-pointer.
  77. **
  78. ** ^SIDE-EFECTS:
  79. **    None.
  80. **
  81. ** ^RETURN-VALUE:
  82. **    Returns 0 if the pager was succesfully close; non-zero if it wasnt
  83. **    in use to begin with.
  84. **
  85. ** ^ALGORITHM:
  86. **    - if ( pager-not-in-use )  return 1
  87. **    - flush any remaining pager output
  88. **    - if we used popen() to open this pager then
  89. **       - call pclose to close the pager-program
  90. **       - unset the SIGPIPE signal-handler
  91. **       - wait for the pager-process to die
  92. **      end-if
  93. **    - reset the pager-file-pointer to NULL
  94. **    - set the pager-state to closed
  95. **    - return 0
  96. ***^^**********************************************************************/
  97. #ifdef __ANSI_C__
  98. X   int pgclose( FILE *pager_fp )
  99. #endif
  100. {
  101. X   if ( Pager_Type == PG_CLOSED  ||  !Pager_FP  ||  !pager_fp )  return  1;
  102. X
  103. X   fflush( Pager_FP );
  104. X
  105. X   if ( Pager_Type == PG_ENV  ||  Pager_Type == PG_DFLT ) {
  106. X      signal( SIGPIPE, (void (*)())SIG_IGN );
  107. X      wait( (int *) 0 );
  108. X   }
  109. X
  110. X   Pager_FP = (FILE *)NULL;
  111. X   Pager_Type = PG_CLOSED;
  112. X
  113. X   return  0;
  114. }
  115. X
  116. X
  117. /***************************************************************************
  118. ** ^FUNCTION: pgopen - open the pager
  119. **
  120. ** ^SYNOPSIS:
  121. */
  122. #ifndef __ANSI_C__
  123. X   FILE *pgopen( fp, pager_cmd )
  124. /*
  125. ** ^PARAMETERS:
  126. */
  127. X   FILE *fp;
  128. /*    -- the file pointer to use if popen() fails
  129. */
  130. X   char *pager_cmd;
  131. /*    -- name of the pager-program to pass to popen()
  132. */
  133. #endif  /* !__ANSI_C__ */
  134. X
  135. /* ^DESCRIPTION:
  136. **    Pgopen will attempt to "redirect" output from the given file
  137. **    pointer to the pager specified by <pager_cmd>.  If <fp> is NOT
  138. **    connected to a terminal or <pager_cmd> cannot be succesfully
  139. **    opened, then <fp> is resturned output is sent to it unpaginated.
  140. **    Otherwise, pgopen will try to open <pager_cmd> for input. If it
  141. **    cannot succeed it tries to open $PAGER for input. If this also
  142. **    fails then /usr/ucb/more is tried. If all else fails, return <fp>.
  143. **
  144. ** ^REQUIREMENTS:
  145. **    pager_cmd should be the full-pathname name of a valid, executable
  146. **    program which reads from standard input and writes (one screenful
  147. **    at a time) to the terminal.
  148. **
  149. ** ^SIDE-EFECTS:
  150. **    If popen() succeeds, the SIGPIPE signal is trapped.
  151. **
  152. ** ^RETURN-VALUE:
  153. **    returns 0 upon success, non-zero if the pager is already in use.
  154. **
  155. ** ^ALGORITHM:
  156. **    - if the pager is already in use, return 1
  157. **    - if <fp> is not connected to a terminal, use it for output and return 0
  158. **    - set up recovery point for SIGPIPE signal
  159. **    - if we can open the pager_cmd, check for a SIGPIPE error
  160. **    - if either of the above fails, then try the same with $PAGER
  161. **    - if either of the above fails, then try the same with /usr/ucb/more
  162. **    - if either of the above fails, just use <fp> and return
  163. ***^^**********************************************************************/
  164. #ifdef __ANSI_C__
  165. X   FILE *pgopen( FILE *fp, const char *pager_cmd )
  166. #endif
  167. {
  168. X   pager_t  pg_type;
  169. X   char     pg_name[ MAX_NAME_LEN ];
  170. X
  171. X      /* if a pager is already open - ignore this call */
  172. X   if ( Pager_Type != PG_CLOSED  ||  Pager_FP )  return  fp;
  173. X
  174. X      /*
  175. X      ** dont page output if it has been redirected
  176. X      */
  177. X   if ( !isTERMINAL(fileno(fp)) ) {
  178. X      Pager_Type = PG_FILE;
  179. X      Pager_FP = fp;
  180. X      return  fp;
  181. X   }
  182. X
  183. X   *pg_name = '\0';
  184. X   if ( pager_cmd )  strcpy( pg_name, pager_cmd );
  185. X   pg_type = pg_pathname( pg_name );
  186. X   Pager_FP = (FILE *)NULL;
  187. X
  188. X      /* jump here after pg_error fields SIGPIPE */
  189. X   if ( setjmp( pg_recover ) ) {
  190. X      (void) pclose( Pager_FP );
  191. X      Pager_FP = (FILE *)NULL;
  192. X      pg_type = ( pg_type == PG_ENV ) ? PG_DFLT : PG_NONE;
  193. X   }
  194. X
  195. X      /* keep trying till we get a valid file-pointer */
  196. X   while ( !Pager_FP ) {
  197. X      switch( pg_type ) {
  198. X         case PG_DFLT:
  199. X               /* jump here if both $PAGER and DEFAULT-PAGER fail */
  200. X            if ( setjmp( pg_recover )) {
  201. X               (void) pclose( Pager_FP );
  202. X               Pager_FP = (FILE *)NULL;
  203. X               pg_type = PG_NONE;
  204. X               continue;
  205. X            }
  206. X               /* fall through to next case */
  207. X
  208. X         case PG_ENV:
  209. X            signal( SIGPIPE, pg_error );
  210. X            Pager_FP = (FILE *) popen( pg_name, "w" );
  211. X            if ( !Pager_FP ) {
  212. X               if ( pg_type == PG_ENV ) {
  213. X                  Pager_FP = (FILE *)NULL;
  214. X                  pg_type = PG_DFLT;
  215. X               }
  216. X               else {
  217. X                  Pager_FP = fp;
  218. X                  pg_type = PG_NONE;
  219. X               }
  220. X            }
  221. X            else {
  222. X                  /*
  223. X                  ** Sleep for a bit, just so we block, and the child
  224. X                  ** process can get moving. Then attempt to write to
  225. X                  ** the pager pipeline. If the pager is bad then the
  226. X                  ** pipe will be broken and pg_error() will handle
  227. X                  ** the broken-pipe signal. Othwerwise, the write will
  228. X                  ** succeed and we'll reset the handler to ignore the
  229. X                  ** broken pipe signal.
  230. X                  */
  231. X               sleep( 1 );
  232. X               fputc( '\n', Pager_FP );
  233. X               fflush( Pager_FP );
  234. X               signal( SIGPIPE, (void (*)())SIG_IGN );
  235. X            }
  236. X            break;
  237. X
  238. X         case PG_NONE:
  239. X         case PG_FILE:
  240. X            Pager_FP = fp;
  241. X            break;
  242. X
  243. X         default:
  244. X            fprintf( stderr, "Unrecognized state [%d] in pgopen()\n",
  245. X                     pg_type );
  246. X            exit( -1 );
  247. X      }/*switch*/
  248. X   }/*while*/
  249. X
  250. X   Pager_Type = pg_type;
  251. X   return  Pager_FP;
  252. }
  253. X
  254. X
  255. /***************************************************************************
  256. ** ^FUNCTION: pg_error - handle error when trying to open a pager
  257. **
  258. ** ^SYNOPSIS:
  259. */
  260. #ifndef __ANSI_C__
  261. X   static void pg_error()
  262. #endif
  263. /*
  264. ** ^PARAMETERS:
  265. **    None.
  266. **
  267. ** ^DESCRIPTION:
  268. **    Pgerror is called when the SIGPIPE signal is recieved. If SIGPIPE
  269. **    is recieved, it means that popen succesfully forked the shell to
  270. **    run the pager but the pager-command itself broke the read-end of
  271. **    the pipe between us (i.e. it is an invalid pager-program or it crashed).
  272. **
  273. **    When SIGPIPE is recieved, this routine will reset the signal handler
  274. **    to its previous value and jump to the recovery point set up by pgopen.
  275. **
  276. ** ^REQUIREMENTS:
  277. **    Pgopen must set up this function is the SIGPIPE handler function.
  278. **
  279. **    Pgopen must place the address of the desired recovery point in
  280. **    pg_recover.
  281. **
  282. ** ^SIDE-EFECTS:
  283. **    Resets SIGPIPE signal-handler and performs a non-local goto.
  284. **
  285. ** ^RETURN-VALUE:
  286. **    None.
  287. **
  288. ** ^ALGORITHM:
  289. **    Trivial.
  290. ***^^**********************************************************************/
  291. #ifdef __ANSI_C__
  292. X   static void pg_error( void )
  293. #endif
  294. {
  295. X   signal( SIGPIPE, (void (*)())SIG_IGN );
  296. X   longjmp( pg_recover, 1 );
  297. }
  298. X
  299. X
  300. /***************************************************************************
  301. ** ^FUNCTION: pg_pathname - get name of pager-program to use
  302. **
  303. ** ^SYNOPSIS:
  304. */
  305. #ifndef __ANSI_C__
  306. X   static pager_t pg_pathname( pager_cmd )
  307. /*
  308. ** ^PARAMETERS:
  309. */
  310. X   char *pager_cmd;
  311. /*    -- name of the pager-program to verify
  312. */
  313. #endif  /* !__ANSI_C__ */
  314. X 
  315. /* ^DESCRIPTION:
  316. **    Pg_pathname will determine the name of the pager-program to attempt to
  317. **    open based on the values of pager_cmd, and $PAGER.
  318. **
  319. ** ^REQUIREMENTS:
  320. **    pager_cmd must be non-null and be large enough to hold any of the
  321. **    possible pager program-names to be opened.
  322. **
  323. ** ^SIDE-EFECTS:
  324. **    pager_cmd is over-written with the name of the pager-command to
  325. **    try to open for output
  326. **
  327. ** ^RETURN-VALUE:
  328. **    Returns PG_DFLT if /usr/ucb/more is to be used.
  329. **    Returns PG_ENV if $PAGER or <pager_cmd> is to be used.
  330. **
  331. ** ^ALGORITHM:
  332. **    - If pager_cmd is executable then compare it to /usr/ucb/more
  333. **        return PG_ENV if not-equal, else return PG_DFLT
  334. **    - Else
  335. **      - pager_cmd = $PAGER
  336. **      - If $PAGER is executable then compare it to /usr/ucb/more
  337. **          return PG_ENV if not-equal, else return PG_DFLT
  338. **      - Else
  339. **          pager_cmd = /usr/ucb/more
  340. **          return  PG_DFLT
  341. **        End-if
  342. **      End-if
  343. ***^^**********************************************************************/
  344. #ifdef __ANSI_C__
  345. X   static pager_t  pg_pathname( char *pager_cmd )
  346. #endif
  347. {
  348. X   char      *pg_name = pager_cmd, *getenv();
  349. X   pager_t   pg_type;
  350. X
  351. X   if ( Pager_Type != PG_NONE )   pg_type = Pager_Type;
  352. X
  353. X      /* see if the given pager is okay */
  354. X   if ( !pg_name  ||  !*pg_name  ||  !access(pg_name, X_OK) ) {
  355. X      pg_name = getenv("PAGER");
  356. X   }
  357. X   else {
  358. X      pg_type = ( strcmp(pager_cmd, DEFAULT_PAGER) ) ? PG_ENV : PG_DFLT;
  359. X      return   pg_type;
  360. X   }
  361. X
  362. X      /* see if $PAGER is ok */
  363. X   if ( !access(pg_name, X_OK) ) {
  364. X      pg_type = ( strcmp(pg_name, DEFAULT_PAGER) ) ? PG_ENV : PG_DFLT;
  365. X      strcpy( pager_cmd, pg_name );
  366. X   }
  367. X   else {
  368. X      pg_type = PG_DFLT;
  369. X      strcpy( pager_cmd, DEFAULT_PAGER );
  370. X   }
  371. X
  372. X   return   pg_type;
  373. }/* pg_pathname */
  374. X
  375. X
  376. #endif  /* USE_PAGER */
  377. SHAR_EOF
  378. echo 'File parseargs/pgopen.c is complete' &&
  379. chmod 0664 parseargs/pgopen.c ||
  380. echo 'restore of parseargs/pgopen.c failed'
  381. Wc_c="`wc -c < 'parseargs/pgopen.c'`"
  382. test 12588 -eq "$Wc_c" ||
  383.     echo 'parseargs/pgopen.c: original size 12588, current size' "$Wc_c"
  384. rm -f _shar_wnt_.tmp
  385. fi
  386. # ============= parseargs/pgopen.h ==============
  387. if test -f 'parseargs/pgopen.h' -a X"$1" != X"-c"; then
  388.     echo 'x - skipping parseargs/pgopen.h (File already exists)'
  389.     rm -f _shar_wnt_.tmp
  390. else
  391. > _shar_wnt_.tmp
  392. echo 'x - extracting parseargs/pgopen.h (Text)'
  393. sed 's/^X//' << 'SHAR_EOF' > 'parseargs/pgopen.h' &&
  394. /*************************************************************************
  395. ** ^FILE: pgopen.h - include file for pgopen.c
  396. **
  397. ** ^DESCRIPTION:
  398. **    If USE_PAGER is #define'd then this file will define the function
  399. **    prototypes needed to use the paging library implemented in pgopen.c;
  400. **    Otherwise it will #define macros with the same name as the paging
  401. **    library routines which do NOT perform any paging.
  402. **
  403. ** ^HISTORY:
  404. **    01/02/91     Brad Appleton     <brad@ssd.csd.harris.com>     Created
  405. ***^^**********************************************************************/
  406. X
  407. #ifndef NULL
  408. #  include <stdio.h>
  409. #endif
  410. #include <useful.h>
  411. X
  412. #ifdef  USE_PAGER
  413. X   EXTERN   FILE *pgopen    ARGS(( FILE *, const char * ));
  414. X   EXTERN   int   pgclose   ARGS(( FILE * ));
  415. X   EXTERN   int   pgactive  ARGS(( const FILE * ));
  416. #else
  417. #  define  pgopen(fp,s)  (( !fp ) ? fp : (fflush(fp), fp))
  418. #  define  pgclose(fp)   (( !fp ) ?  0 : (fflush(fp), 0))
  419. #  define  pgactive(fp)  ( fp )
  420. #endif
  421. SHAR_EOF
  422. chmod 0664 parseargs/pgopen.h ||
  423. echo 'restore of parseargs/pgopen.h failed'
  424. Wc_c="`wc -c < 'parseargs/pgopen.h'`"
  425. test 977 -eq "$Wc_c" ||
  426.     echo 'parseargs/pgopen.h: original size 977, current size' "$Wc_c"
  427. rm -f _shar_wnt_.tmp
  428. fi
  429. # ============= parseargs/stest.c ==============
  430. if test -f 'parseargs/stest.c' -a X"$1" != X"-c"; then
  431.     echo 'x - skipping parseargs/stest.c (File already exists)'
  432.     rm -f _shar_wnt_.tmp
  433. else
  434. > _shar_wnt_.tmp
  435. echo 'x - extracting parseargs/stest.c (Text)'
  436. sed 's/^X//' << 'SHAR_EOF' > 'parseargs/stest.c' &&
  437. /*************************************************************************
  438. ** ^FILE: stest.c - test program for parseargs()
  439. **
  440. ** ^DESCRIPTION:
  441. **    This file is the test program for the parseargs(3) function libarary.
  442. **    It is used to test parseargs for all command-line styles (which presently
  443. **    includes: UNIX, VMS, AmigaDOS, MS-DOS, and OS/2).
  444. **
  445. ** ^HISTORY:
  446. **    --/--/--    Brad Appleton    <brad@ssd.csd.harris.com>    
  447. **    - Added structured block comments
  448. **    - Added an extra test for both old-style and new-style argument arrays
  449. **    - Added a test for triggers (ARGNOVAL arguments)
  450. **    - Added a test for arguments with optional values (using parsecntl())
  451. **    - Added arg-vector arguments
  452. **
  453. **    --/--/--    Peter da Silva    <peter@ferranti.com>    
  454. **
  455. **    --/--/--    Eric P. Allman    <eric@Berkeley.EDU>     Created
  456. ***^^**********************************************************************/
  457. X
  458. #include <useful.h>
  459. #include <parseargs.h>
  460. X
  461. VERSIONID("$Header: stest.c,v 2.0 89/12/24 00:56:29 eric Exp $");
  462. X
  463. static char Mode[4] = "OFF";
  464. X
  465. /***************************************************************************
  466. ** ^FUNCTION: argMine - example ARGNOVAL argument translation routine
  467. **
  468. ** ^SYNOPSIS:
  469. */
  470. #ifndef __ANSI_C__
  471. X   BOOL argMine( ad, vp, copyf )
  472. /*
  473. ** ^PARAMETERS:
  474. */
  475. X   ARGDESC *ad;
  476. /*    -- the argument descriptor for this parameter.
  477. */
  478. X   char *vp;
  479. /*    -- a pointer to the string input value.
  480. */
  481. X   BOOL copyf;
  482. /*    -- if TRUE, the value will be destroyed later, and so should be
  483. **       copied if it will be retained (as for a string).
  484. */
  485. #endif  /* !__ANSI_C__ */
  486. X
  487. /* ^DESCRIPTION:
  488. **    This routine is provided as a (very) simple example of how to use
  489. **    the ARGNOVAL flag to set up "trigger" arguments. Depending upon the
  490. **    implementation of the "trigger" function (this routine), the position
  491. **    of the corresponding argument on the command line may (or may not) be
  492. **    important.
  493. **
  494. ** ^REQUIREMENTS:
  495. **    ad should have ARGNOVAL set and this function as its ad_type.
  496. **
  497. ** ^SIDE-EFFECTS:
  498. **    The static global variable Mode is (re)written.
  499. **
  500. ** ^RETURN-VALUE:
  501. **    TRUE.
  502. **
  503. ** ^ALGORITHM:
  504. **    Trivial.
  505. ***^^**********************************************************************/
  506. /*ARGSUSED*/
  507. #ifdef __ANSI_C__
  508. X   BOOL argMine( ARGDESC *ad, char *vp, BOOL copyf )
  509. #endif
  510. {
  511. X   strcpy(Mode, "ON");
  512. X   return TRUE;
  513. }
  514. X
  515. /*************************************************************************/
  516. X   /* declare variables to hold values from the command-line */
  517. #define DEF_STR "Default String"
  518. X
  519. typedef ARGVEC_T(char *)  strvec_t;
  520. X
  521. static int    RepCount;
  522. static char    *Name;
  523. static char    *Str     = DEF_STR;
  524. static char    *DirName = ".";
  525. static BOOL    XRated   = FALSE;
  526. static BOOL    XFlag    = FALSE;
  527. static BOOL    YFlag    = TRUE;
  528. static BOOL    ZFlag    = FALSE;
  529. static char    TabChar  = ':';
  530. static ARGVEC_T(int) Integers = ARGVEC_EMPTY(int);
  531. static strvec_t Groups = ARGVEC_EMPTY(char *);
  532. static ArgList  *Argv  = (ArgList *)NULL;
  533. X
  534. /*************************************************************************/
  535. X   /* declare a new style argument-descriptor array */
  536. static
  537. CMD_OBJECT
  538. X   Cmd
  539. X
  540. CMD_NAME
  541. X   "stest -- test program for parseargs"
  542. X
  543. CMD_DESCRIPTION
  544. X   "This program is used to test parseargs for each desired command-line \
  545. style and for both old and new style argument-array declarations.  The actual \
  546. name of the command will be <os>_test.  parseargs will be called twice (with \
  547. the same command-line description) in order to test both the old and the new \
  548. syntax for declaring argument arrays."
  549. X
  550. CMD_ARGUMENTS
  551. X   'n', ARGREQ|ARGPOS, argStr,  __ &Name,  "name (name to look for)",
  552. X   's', ARGVALOPT, argStr,  __ &Str,       "STRing (optional string to use)",
  553. X   'g', ARGVEC,    argStr,  __ &Groups,    "newsGROUPS (newsgroups to test)",
  554. X   'c', ARGOPT,    argInt,  __ &RepCount,  "REPcount (repeat count per group)",
  555. X   'd', ARGOPT,    argStr,   __ &DirName,  "DIRname (work directory)",
  556. X   'i', ARGVEC,    argInt,   __ &Integers, "INTegerS (vector of numbers)",
  557. X   '#', ARGHIDDEN, argBool,  __ &XRated,   "XratedMODE (naughty! naughty!)",
  558. X
  559. X   'x', ARGOPT, argSBool, __ &XFlag, "Xflag (set X flag)",
  560. X   'y', ARGOPT, argUBool, __ &YFlag, "Yflag (unset Y flag)",
  561. X   'z', ARGOPT, argTBool, __ &ZFlag, "Zflag (toggle Z flag)",
  562. X
  563. X   't', ARGOPT,   argChar, __ &TabChar, "TABchar (field delimiter)",
  564. X   'r', ARGNOVAL, argMine, __ NULL,     "raw (trigger raw-mode \
  565. before processing any more arguments on the command-line)",
  566. X
  567. X   ' ', ARGLIST, listStr, __ &Argv, "file (list of files)",
  568. X
  569. X   END_ARGUMENTS
  570. CMD_END
  571. X
  572. X
  573. /*************************************************************************/
  574. X   /* declare an old style argument-descriptor array */
  575. static ARGDESC    Args[] =
  576. {
  577. X   STARTOFARGS,
  578. X
  579. X   'n', ARGREQ|ARGPOS, argStr,  __ &Name,  "name (name to look for)",
  580. X   's', ARGVALOPT, argStr,  __ &Str,       "STRing (optional string to use)",
  581. X   'g', ARGVEC,    argStr,  __ &Groups,    "newsGROUPS (newsgroups to test)",
  582. X   'c', ARGOPT,    argInt,  __ &RepCount,  "REPcount (repeat count per group)",
  583. X   'd', ARGOPT,    argStr,   __ &DirName,  "DIRname (work directory)",
  584. X   'i', ARGVEC,    argInt,   __ &Integers, "INTegerS (vector of numbers)",
  585. X   '#', ARGHIDDEN, argBool,  __ &XRated,   "XratedMODE (naughty! naughty!)",
  586. X
  587. X   'x', ARGOPT, argSBool, __ &XFlag, "Xflag (set X flag)",
  588. X   'y', ARGOPT, argUBool, __ &YFlag, "Yflag (unset Y flag)",
  589. X   'z', ARGOPT, argTBool, __ &ZFlag, "Zflag (toggle Z flag)",
  590. X
  591. X   't', ARGOPT,   argChar, __ &TabChar, "TABchar (field delimiter)",
  592. X   'r', ARGNOVAL, argMine, __ NULL,     "raw (trigger raw-mode \
  593. before processing any more arguments on the command-line)",
  594. X
  595. X   ' ', ARGLIST, listStr, __ &Argv, "file (list of files)",
  596. X
  597. X   ENDOFARGS
  598. };
  599. X
  600. X
  601. /***************************************************************************
  602. ** ^FUNCTION: reset_args - reset argument values for another pass
  603. **
  604. ** ^SYNOPSIS:
  605. */
  606. #ifndef __ANSI_C__
  607. X   static VOID reset_args()
  608. #endif
  609. /*  
  610. ** ^PARAMETERS:
  611. **    None.
  612. **
  613. ** ^DESCRIPTION:
  614. **    Reset_args resets all the argument values to their corresponding
  615. **    default values so that we can (re)test the parseargs library.
  616. **
  617. ** ^REQUIREMENTS:
  618. **    None.
  619. **
  620. ** ^SIDE-EFECTS:
  621. **    All the static-global argument variables are rewritten.
  622. **
  623. ** ^RETURN-VALUE:
  624. **    None.
  625. **
  626. ** ^ALGORITHM:
  627. **    Trivial.
  628. ***^^**********************************************************************/
  629. #ifdef __ANSI_C__
  630. X   static void reset_args( void )
  631. #endif
  632. {
  633. X   RepCount = 0;
  634. X   Name     = CHARNULL;
  635. X   Str      = DEF_STR;
  636. X   DirName  = ".";
  637. X   XRated   = FALSE;
  638. X   XFlag    = FALSE;
  639. X   YFlag    = TRUE;
  640. X   ZFlag    = FALSE;
  641. X   TabChar  = ':';
  642. X
  643. X   vecFree(Integers, int);
  644. X   vecDeepFree(Groups, char *);
  645. X   listFree( Argv );
  646. X   Argv = ARGLISTNULL;
  647. }
  648. X
  649. X
  650. /***************************************************************************
  651. ** ^FUNCTION: print_args - print current argument values
  652. **
  653. ** ^SYNOPSIS:
  654. */
  655. #ifndef __ANSI_C__
  656. X   static void print_args( argd )
  657. /*
  658. ** ^PARAMETERS:
  659. */
  660. X   ARGDESC *argd;
  661. /*    -- the command whose arg-values are to be printed
  662. */
  663. #endif  /* !__ANSI_C__ */
  664. X
  665. /* ^DESCRIPTION:
  666. **    Print the current values of all the command-line settings
  667. **
  668. ** ^REQUIREMENTS:
  669. **    The command-line should have already been parsed by one of the
  670. **    Xparseargs functions.
  671. **
  672. ** ^SIDE-EFECTS:
  673. **    Prints on stdout.
  674. **
  675. ** ^RETURN-VALUE:
  676. **    None.
  677. **
  678. ** ^ALGORITHM:
  679. **    Trivial.
  680. ***^^**********************************************************************/
  681. #ifdef __ANSI_C__
  682. X   static void print_args( const ARGDESC *argd )
  683. #endif
  684. {
  685. X   int  i, flags;
  686. X   ArgList *ls;
  687. X
  688. X   printf( "Name = \"%s\", DirName = \"%s\", RepCount = %d,\n",
  689. X           Name, DirName, RepCount );
  690. X
  691. X   printf( "XFlag = %d, YFlag = %d, ZFlag = %d, TabChar='%c'(%03o);\n",
  692. X           XFlag, YFlag, ZFlag, TabChar, TabChar );
  693. X
  694. X   printf( "XRated=%d, Raw-Mode = \"%s\"\n", XRated, Mode );
  695. X
  696. X      /* to call parsecntl() to see if the optional value was supplied */
  697. X   (VOID) parsecntl( (ARGDESC *)argd, pc_ARGFLAGS, pc_READ, "string", &flags);
  698. X
  699. X   if ( BTEST(flags, ARGGIVEN) && !BTEST(flags, ARGVALGIVEN) ) {
  700. X      printf("String=!No Value Given on CmdLine!\n" );
  701. X   }
  702. X   else {
  703. X      printf("String=\"%s\"\n", Str);
  704. X   }
  705. X
  706. X   if (Groups.count) {
  707. X      printf("Newsgroups:");
  708. X      for (i = 0 ; i < Groups.count ; i++ ) {
  709. X         printf(" %s", Groups.array[i]);
  710. X      }
  711. X      putchar('\n');
  712. X   }
  713. X
  714. X   if (Integers.count) {
  715. X      printf("Integers:");
  716. X      for (i = 0 ; i < Integers.count ; i++ ) {
  717. X         printf(" %d", Integers.array[i]);
  718. X      }
  719. X      putchar('\n');
  720. X   }
  721. X
  722. X   if (Argv)  printf("Remaining args: ");
  723. X   for ( ls = Argv ; ls ; L_ADVANCE(ls) ) {
  724. X      printf("%s", L_STRING(ls));
  725. X      if ( L_NEXT(ls) ) {
  726. X         putchar(' ');
  727. X      }
  728. X      else {
  729. X         putchar('\n');
  730. X      }
  731. X   }/*for*/
  732. }
  733. X
  734. X
  735. /*ARGSUSED*/
  736. MAIN(argc, argv)
  737. {
  738. X   parseargs(argv, Cmd);   /* parse the command-line */
  739. X   print_args(Cmd);        /* print what we found */
  740. X
  741. X   putchar('\n');
  742. X   reset_args();           /* reset args for another pass */
  743. X
  744. X   parseargs(argv, Args);  /* parse same command-line using old-style argd */
  745. X   print_args(Args);       /* print what we found (should be same as before) */
  746. X
  747. X   exit(0);  /* wave bye-bye */
  748. }
  749. SHAR_EOF
  750. chmod 0664 parseargs/stest.c ||
  751. echo 'restore of parseargs/stest.c failed'
  752. Wc_c="`wc -c < 'parseargs/stest.c'`"
  753. test 9196 -eq "$Wc_c" ||
  754.     echo 'parseargs/stest.c: original size 9196, current size' "$Wc_c"
  755. rm -f _shar_wnt_.tmp
  756. fi
  757. # ============= parseargs/strfuncs.c ==============
  758. if test -f 'parseargs/strfuncs.c' -a X"$1" != X"-c"; then
  759.     echo 'x - skipping parseargs/strfuncs.c (File already exists)'
  760.     rm -f _shar_wnt_.tmp
  761. else
  762. > _shar_wnt_.tmp
  763. echo 'x - extracting parseargs/strfuncs.c (Text)'
  764. sed 's/^X//' << 'SHAR_EOF' > 'parseargs/strfuncs.c' &&
  765. /**************************************************************************
  766. ** ^FILE: strfuncs.c - Miscellaneous string functions for parseargs
  767. **
  768. ** ^DESCRIPTION:
  769. **    This file implements a wide variety of functions to manipulate
  770. **    strings in way way or another. Some of the functions may already
  771. **    be included in the standard library of some C compilers.
  772. **
  773. **    The following functions are implemented:
  774. **
  775. **       strucpy() -- copy a string and map to uppercase
  776. **       strlcpy() -- copy a string and map to lowercase
  777. **       strupr() -- convert a string to uppercase
  778. **       strlwr() -- convert a string to lowercase
  779. **       strdup() -- return a (newly allocated) copy of a string
  780. **       strpbrk() -- return first occurrence of character in a set
  781. **       strspn() -- return length of initial prefix of a character set
  782. **       strcspn() -- return length of initial prefix of a character set
  783. **       strltrim() -- trim leftmost (leading) characters in a string
  784. **       strrtrim() -- trim rightmost (trailing) characters in a string
  785. **       strtrim() -- trim leading and trailing characters in a string
  786. **       strsplit() -- split a string up into a vector of tokens
  787. **       strjoin() -- join a vector of token into a single string
  788. **       get_name() -- return the aname (argument-name) of an argument
  789. **       get_keyword() -- return the sname (keyword-name) of an argument
  790. **       match() -- match two keywords (case insensitive) upto a unique prefix
  791. **       stricmp() -- case insensitive comparison of strings
  792. **       strnicmp() -- case insensitive length-limited comparison of strings
  793. **       basename() -- remove the leading directories (and disks) from a path
  794. **       indent_para() -- print an indented hanging paragraph
  795. **
  796. ** ^HISTORY:
  797. **    01/02/91     Brad Appleton     <brad@ssd.csd.harris.com>     Created
  798. **    - changed from file misc.c to this name and added all of the strxxx
  799. **      functions (plus got rid of some unused functions).
  800. **
  801. **    --/--/--    Peter da Silva    <peter@ferranti.com>    
  802. **
  803. **    --/--/--    Eric P. Allman    <eric@Berkeley.EDU>     Created
  804. ***^^**********************************************************************/
  805. X
  806. #include <stdio.h>
  807. #include <ctype.h>
  808. #include <useful.h>
  809. X
  810. EXTERN  VOID   syserr  ARGS((const char *, ...));
  811. X
  812. static CONST char WhiteSpace[] = " \t\n\r\v\f";
  813. X
  814. X
  815. #if ( defined(unix_style)  ||  defined(ibm_style) )
  816. # define  TO_KWDCASE(c)  TOLOWER(c)
  817. #else
  818. # define  TO_KWDCASE(c)  TOUPPER(c)
  819. #endif
  820. X
  821. X
  822. /***************************************************************************
  823. ** ^FUNCTION: strucpy, strlcpy - copy dest to src, mapping to upper/lower case
  824. **
  825. ** ^SYNOPSIS:
  826. **
  827. **    char *strucpy( dest, src )
  828. **    char *strlcpy( dest, src )
  829. **
  830. ** ^PARAMETERS:
  831. **    char *dest;
  832. **    -- the address to start copying to
  833. **
  834. **    char *src;
  835. **    -- the address to start copying from
  836. **
  837. ** ^DESCRIPTION:
  838. **    Strlcpy (strucpy) copies src into dest (upto and including the
  839. **    terminating NUL byte) and all uppercase (lowercase) characters in
  840. **    src are mapped to lowercase (uppercase) before being copied into dest.
  841. **
  842. ** ^REQUIREMENTS:
  843. **    Dest must be non-null, and large enough to hold the copied result.
  844. **
  845. ** ^SIDE-EFECTS:
  846. **    Dest is (re)written
  847. **
  848. ** ^RETURN-VALUE:
  849. **    Address of dest.
  850. **
  851. ** ^ALGORITHM:
  852. **    Trivial.
  853. ***^^**********************************************************************/
  854. #ifdef __ANSI_C__
  855. X   char *strucpy( char *dest, const char *src )
  856. #else
  857. X   char *strucpy( dest, src )  char *dest, *src;
  858. #endif
  859. {
  860. X   register char  *s1 = dest;
  861. X   register CONST char  *s2 = src;
  862. X
  863. X   if ( !s2 )  return  CHARNULL;
  864. X
  865. X   for ( ; *s2 ; s1++, s2++ ) {
  866. X      *s1 = TOUPPER( *s2 );
  867. X   }
  868. X   *s1 = '\0';
  869. X
  870. X   return   s1;
  871. }
  872. X
  873. X
  874. #ifdef __ANSI_C__
  875. X   char *strlcpy( char *dest, const char *src )
  876. #else
  877. X   char *strlcpy( dest, src )  char *dest, *src;
  878. #endif
  879. {
  880. X   register char  *s1 = dest;
  881. X   register CONST char  *s2 = src;
  882. X
  883. X   if ( !s2 )  return  CHARNULL;
  884. X
  885. X   for ( ; *s2 ; s1++, s2++ ) {
  886. X      *s1 = TOLOWER( *s2 );
  887. X   }
  888. X   *s1 = '\0';
  889. X
  890. X   return   s1;
  891. }
  892. X
  893. X
  894. /***************************************************************************
  895. ** ^FUNCTION: strupr, strlwr - convert a string to all upper/lower case
  896. **
  897. ** ^SYNOPSIS:
  898. **    char *strupr( str )
  899. **    char *strlwr( str )
  900. **
  901. ** ^PARAMETERS:
  902. **    char *str;
  903. **    -- the string to be converted
  904. **
  905. ** ^DESCRIPTION:
  906. **    Strupr (strlwr) converts all lowercase (uppercase) characters in <str>
  907. **    to uppercase (lowercase) and returns the address of <str>.
  908. **
  909. ** ^REQUIREMENTS:
  910. **    str should be non-null and non-empty.
  911. **
  912. ** ^SIDE-EFECTS:
  913. **    str is overwritten with the uppercase (lowercase) result.
  914. **
  915. ** ^RETURN-VALUE:
  916. **    Address of str.
  917. **
  918. ** ^ALGORITHM:
  919. **    Trivial.
  920. ***^^**********************************************************************/
  921. #ifdef __ANSI_C__
  922. X   char *strupr( char *str )
  923. #else
  924. X   char *strupr( str )  char *str;
  925. #endif
  926. {
  927. X   char *p = str;
  928. X
  929. X   for ( ; p && *p ; p++ ) {
  930. X      if ( islower(*p) )  *p = toupper(*p);
  931. X   }
  932. X
  933. X   return   str;
  934. }
  935. X
  936. X
  937. #ifdef __ANSI_C__
  938. X   char *strlwr( char *str )
  939. #else
  940. X   char *strlwr( str )  char *str;
  941. #endif
  942. {
  943. X   char *p = str;
  944. X
  945. X   for ( ; p && *p ; p++ ) {
  946. X      if ( isupper(*p) )  *p = tolower(*p);
  947. X   }
  948. X
  949. X   return   str;
  950. }
  951. X
  952. X
  953. /***************************************************************************
  954. ** ^FUNCTION: stricmp, strnicmp - case insensitive string comparison
  955. **
  956. ** ^SYNOPSIS:
  957. **    int stricmp( s1, s2 )
  958. **    int strnicmp( s1, s2, n )
  959. **
  960. ** ^PARAMETERS:
  961. **    char *s1;
  962. **    -- first string to compare
  963. **
  964. **    char *s2;
  965. **    -- second string to compare
  966. **
  967. **    size_t  n;
  968. **    -- The number of characters to compare
  969. **
  970. ** ^DESCRIPTION:
  971. **    Stricmp (strnicmp) is identical to strcmp (strncmp) except that it
  972. **    it performs a case-insensitive comparison of characters.
  973. **
  974. ** ^REQUIREMENTS:
  975. **    Both s1 and s2 should be non-null and non-empty
  976. **
  977. ** ^SIDE-EFECTS:
  978. **    None.
  979. **
  980. ** ^RETURN-VALUE:
  981. **    < 0    if s1 < s2
  982. **    = 0    if s1 matches s2
  983. **    > 0    if s1 > s2
  984. **
  985. ** ^ALGORITHM:
  986. **    Trivial.
  987. ***^^**********************************************************************/
  988. #ifdef __ANSI_C__
  989. X   int stricmp( const char *str1, const char *str2 )
  990. #else
  991. X   int stricmp( str1, str2 ) char *str1, *str2;
  992. #endif
  993. {
  994. X   register  CONST char *s1 = str1, *s2 = str2;
  995. X   register  char  c1, c2;
  996. X
  997. X   if ( s1 == s2 )  return   0;
  998. X   if ( !s1 )       return  -1;
  999. X   if ( !s2 )       return   1;
  1000. X
  1001. X   for ( ; *s1 && *s2 ; s1++ , s2++ ) {
  1002. X      c1 = TOLOWER( *s1 );
  1003. X      c2 = TOLOWER( *s2 );
  1004. X
  1005. X      if (c1 != c2)  return  (int)(c1 -c2);
  1006. X   }
  1007. X   return   (*s1 == *s2) ? 0 : (int)(*s1 - *s2);
  1008. }
  1009. X
  1010. X
  1011. #ifdef __ANSI_C__
  1012. X   int strnicmp( const char *str1, const char *str2, size_t len )
  1013. #else
  1014. X   int strnicmp( str1, str2, len ) char *str1, *str2; size_t  len;
  1015. #endif
  1016. {
  1017. X   register  CONST char *s1 = str1, *s2 = str2;
  1018. X   register  char  c1, c2;
  1019. X
  1020. X   if ( s1 == s2 )  return   0;
  1021. X   if ( !s1 )       return  -1;
  1022. X   if ( !s2 )       return   1;
  1023. X
  1024. X   for ( ; *s1 && *s2 && len ; s1++ , s2++ , len-- ) {
  1025. X      c1 = TOLOWER( *s1 );
  1026. X      c2 = TOLOWER( *s2 );
  1027. X
  1028. X      if (c1 != c2)  return  (int)(c1 -c2);
  1029. X   }
  1030. X   return   (*s1 == *s2) ? 0 : (int)(*s1 - *s2);
  1031. }
  1032. X
  1033. X
  1034. #ifdef BSD
  1035. X
  1036. /***************************************************************************
  1037. ** ^FUNCTION: strdup - copy a string
  1038. **
  1039. ** ^SYNOPSIS:
  1040. */
  1041. # ifndef __ANSI_C__
  1042. X   char *strdup( str )
  1043. /*
  1044. ** ^PARAMETERS:
  1045. */
  1046. X   char *str;
  1047. /*    -- the string to replicate
  1048. */
  1049. # endif  /* !__ANSI_C__ */
  1050. X
  1051. /* ^DESCRIPTION:
  1052. **    Strdup allocates storrage and copies the given string into the
  1053. **    newly acquired space (returning its address). The returned result
  1054. **    should be deallocated using free().
  1055. **
  1056. ** ^REQUIREMENTS:
  1057. **    str should be non-null
  1058. **
  1059. ** ^SIDE-EFFECTS:
  1060. **    None.
  1061. **
  1062. ** ^RETURN-VALUE:
  1063. **    Address of the newly allocated string.
  1064. **
  1065. ** ^ALGORITHM:
  1066. **    Trivial.
  1067. ***^^**********************************************************************/
  1068. # ifdef __ANSI_C__
  1069. X   char *strdup( const char *str )
  1070. # endif
  1071. {
  1072. X  unsigned len = strlen(str) + 1;
  1073. X  char *p = malloc( len * sizeof(char) );
  1074. X
  1075. X  if ( !p )  syserr( "Fatal Error -- out of memory" );
  1076. X  strcpy(p, str);
  1077. X
  1078. X  return p;
  1079. }
  1080. X
  1081. X
  1082. /***************************************************************************
  1083. ** ^FUNCTION: strpbrk - return the first occurrence of characters in a string
  1084. **
  1085. ** ^SYNOPSIS:
  1086. */
  1087. #ifndef __ANSI_C__
  1088. X   char *strpbrk( str1, str2 )
  1089. /*
  1090. ** ^PARAMETERS:
  1091. */
  1092. X   char *str1;
  1093. /*    -- the string to be searched
  1094. */
  1095. X   char *str2;
  1096. /*    -- the set of characters to be located
  1097. */
  1098. #endif  /* !__ANSI_C__ */
  1099. X
  1100. /* ^DESCRIPTION:
  1101. **    Strpbrk will attempt to locate the first occurence in str1 of any 
  1102. **    character from str2 and return the address of the first such
  1103. **    occurrence. If str1 contains NO characters from str2, then NULL
  1104. **    is returned.
  1105. **
  1106. ** ^REQUIREMENTS:
  1107. **    Both str1 and str2 should be non-null and non-empty
  1108. **
  1109. ** ^SIDE-EFECTS:
  1110. **    None.
  1111. **
  1112. ** ^RETURN-VALUE:
  1113. **    A pointer to the first occurence in str1 of any char from str2.
  1114. **
  1115. ** ^ALGORITHM:
  1116. **    - foreach char in str1
  1117. **       - if char is in str2, return the address of char
  1118. **      end-for
  1119. **    - if we have reached the end of str1, return NULL
  1120. ***^^**********************************************************************/
  1121. #ifdef __ANSI_C__
  1122. X   char *strpbrk( const char *str1, const char *str2 )
  1123. #endif
  1124. {
  1125. X   register CONST char *s1 =  str1, *s2 = str2;
  1126. X
  1127. X   if ( !s1 || !*s1 || !s2 || !*s2 )  return  CHARNULL;
  1128. X
  1129. X   for ( ; *s1 ; s1++ )  {
  1130. X      if ( strchr(s2, *s1) )  return (char *)s1;
  1131. X   }
  1132. X
  1133. X   return  CHARNULL;
  1134. }
  1135. X
  1136. X
  1137. /***************************************************************************
  1138. ** ^FUNCTION: strspn, strcspn - identify leading runs of characters
  1139. **
  1140. ** ^SYNOPSIS:
  1141. **    char *strspn( str1, str2 )
  1142. **    char *strcspn( str1, str2 )
  1143. **
  1144. ** ^PARAMETERS:
  1145. **    char *str1;
  1146. **    -- the string to be searched
  1147. **
  1148. **    char *str2;
  1149. **    -- the string to be searched
  1150. **
  1151. ** ^DESCRIPTION:
  1152. **    Strspn (strcspn) attempts to determine the length of the longest
  1153. **    leading prefix of str1 that consists entirely of character from
  1154. **    (not from) str2.
  1155. **
  1156. ** ^REQUIREMENTS:
  1157. **    Both str1 and str2 should be non-null and non-empty.
  1158. **
  1159. ** ^SIDE-EFECTS:
  1160. **    None.
  1161. **
  1162. ** ^RETURN-VALUE:
  1163. **    The length of the initial prefix in str1 consisting entirely
  1164. **    of characters from (not from) str2.
  1165. **
  1166. ** ^ALGORITHM:
  1167. **    - length = 0
  1168. **    - for each char in str1
  1169. **       - if char is in str2 (for strcspn) or not in str2 (for strcspn)
  1170. **            then return length
  1171. **       - else
  1172. **            add 1 to length
  1173. **         end-if
  1174. **      end-for
  1175. **    - if end-of-string then return length
  1176. **
  1177. ***^^**********************************************************************/
  1178. #ifdef __ANSI_C__
  1179. X   int strspn( const char *str1, const char *str2 )
  1180. #else
  1181. X   int strspn( str1, str2 )  char *str1, *str2;
  1182. #endif
  1183. {
  1184. X   register CONST char  *s1 = str1, *s2 = str2;
  1185. X   int len = 0;
  1186. X
  1187. X   if ( !s1 || !*s1 || !s2 || !*s2 )  return  0;
  1188. X   while ( *s1  &&  strchr(s2, *s1++) )  ++len;
  1189. X   return  len;
  1190. }
  1191. X
  1192. X
  1193. #ifdef __ANSI_C__
  1194. X   int strcspn( const char *str1, const char *str2 )
  1195. #else
  1196. X   int strcspn( str1, str2 )  char *str1, *str2;
  1197. #endif
  1198. {
  1199. X   register CONST char  *s1 = str1, *s2 = str2;
  1200. X   int len = 0;
  1201. X
  1202. X   if ( !s1 || !*s1 || !s2 || !*s2 )  return  0;
  1203. X   while ( *s1  &&  !strchr(s2, *s1++) )  ++len;
  1204. X   return  len;
  1205. }
  1206. X
  1207. #endif  /* BSD */
  1208. X
  1209. X
  1210. /***************************************************************************
  1211. ** ^FUNCTION: strltrim, strrtrim, strtrim - trim leading/trailing characters
  1212. **
  1213. ** ^SYNOPSIS:
  1214. **    char *strltrim( str, charset )
  1215. **    char *strrtrim( str, charset )
  1216. **    char *strtrim( str, charset )
  1217. **
  1218. ** ^PARAMETERS:
  1219. **    char *str;
  1220. **    -- the string to be trimmed
  1221. **
  1222. **    char *charset;
  1223. **    -- the set of characters to be trimmed
  1224. **
  1225. ** ^DESCRIPTION:
  1226. **    Strltrim removes from str, all leftmost (leading) characters occurring
  1227. **    in charset.
  1228. **
  1229. **    Strrtrim removes from str, all rightmost (trailing) characters occurring
  1230. **    in charset.
  1231. **
  1232. **    Strtrim removes from str, all leading and trailing characters occurring
  1233. **    in charset.
  1234. **
  1235. **    For each of these functions, if charset is NULL or empty, then the set
  1236. **    of whitespace characters (space, tab, newline, carriage-return, form-feed
  1237. **    and vertical-tab) is assumed.
  1238. **
  1239. ** ^REQUIREMENTS:
  1240. **    str should be non-null and non-empty.
  1241. **
  1242. ** ^SIDE-EFECTS:
  1243. **    characters may be removed from the beginning and/or end of str.
  1244. **
  1245. ** ^RETURN-VALUE:
  1246. **    Address of str.
  1247. **
  1248. ** ^ALGORITHM:
  1249. **    Trivial.
  1250. ***^^**********************************************************************/
  1251. #ifdef __ANSI_C__
  1252. X   char *strltrim( char *str, const char *charset )
  1253. #else
  1254. X   char *strltrim( str, charset )  char *str, *charset;
  1255. #endif
  1256. {
  1257. X   register   int   i;
  1258. X
  1259. X   if ( !str  ||  !*str )   return   str;
  1260. X      /* if delim-string is NULL, whitespace is used */
  1261. X   if ( !charset )   charset = WhiteSpace;
  1262. X
  1263. X   i = strspn( str, charset );
  1264. X   if ( i > 0 )  strcpy( str, &(str[i]) );
  1265. X
  1266. X   return   str;
  1267. }
  1268. X
  1269. X
  1270. #ifdef __ANSI_C__
  1271. X   char *strrtrim( char *str, const char *charset )
  1272. #else
  1273. X   char *strrtrim( str, charset )  char *str, *charset;
  1274. #endif
  1275. {
  1276. X   register   int   i;
  1277. X
  1278. X   if ( !str  ||  !*str )   return   str;
  1279. X   if ( !charset )   charset = WhiteSpace;
  1280. X   for ( i = strlen(str) - 1 ;
  1281. X            ( i >= 0 ) && (strchr( charset, str[i] )) ;
  1282. X            i--
  1283. X         ) ;
  1284. X
  1285. X   str[i+1] = '\0';
  1286. X
  1287. X   return   str;
  1288. }
  1289. X
  1290. X
  1291. #ifdef __ANSI_C__
  1292. X   char *strtrim( char *str, const char *charset )
  1293. #else
  1294. X   char *strtrim( str, charset )  char *str, *charset;
  1295. #endif
  1296. {
  1297. X   register   int   i;
  1298. X
  1299. X   if ( !str  ||  !*str )   return   str;
  1300. X   if ( !charset )   charset = WhiteSpace;
  1301. X   i = strspn( str, charset );
  1302. X   if ( i > 0 )  strcpy( str, &(str[i]) );
  1303. X
  1304. X   for ( i = strlen(str) - 1 ;
  1305. X            ( i >= 0 ) && (strchr( charset, str[i] )) ;
  1306. X            i--
  1307. X         ) ;
  1308. X
  1309. X   str[i+1] = '\0';
  1310. X
  1311. X   return   str;
  1312. }
  1313. X
  1314. X
  1315. /***************************************************************************
  1316. ** ^FUNCTION: strsplit - split a string into tokens
  1317. **
  1318. ** ^SYNOPSIS:
  1319. */
  1320. #ifndef __ANSI_C__
  1321. X   int  strsplit( vec, token_str, separators )
  1322. /*
  1323. ** ^PARAMETERS:
  1324. */
  1325. X   char **vec[];
  1326. /*    -- pointer to the string vector to be allocated
  1327. */
  1328. X   char token_str[];
  1329. /*    -- the string to be split up
  1330. */
  1331. X   char separators[];
  1332. /*    -- the delimiters that separate tokens
  1333. */
  1334. #endif  /* !__ANSI_C__ */
  1335. X
  1336. /* ^DESCRIPTION:
  1337. **    Strsplit will split token_str up into  a vector of tokens that are
  1338. **    separated by one or more characters from <separators>. The number
  1339. **    of tokens found is returned and storage is allocated for the given
  1340. **    vector (which may later be deallocated using free()).
  1341. **
  1342. **    If <separators> is NULL or empty, then the set of whitespace characters
  1343. **    is used as the token delimiters.
  1344. **
  1345. ** ^REQUIREMENTS:
  1346. **    vec must be non-NULL (it must be a valid address).
  1347. **    token_str should be non-null and non-empty
  1348. **
  1349. ** ^SIDE-EFECTS:
  1350. **    All leading and trailing characters from <separators> are removed
  1351. **    from token_str. Furthermore, all remaining sequences in token_str
  1352. **    of characters from <separators> are replaced with a single NUL-byte.
  1353. **
  1354. **    Token_str holds the actual storage for all the strings in the newly
  1355. **    created vector.
  1356. **
  1357. ** ^RETURN-VALUE:
  1358. **    The number of tokens parsed.
  1359. **
  1360. ** ^ALGORITHM:
  1361. **    - count the number of tokens present while at the same time removing
  1362. **      all leading and trailing delimiters, and replacing all other sequences
  1363. **      of delimiters with the NUL character.
  1364. **    - allocate a vector large enough to point to all the token strings.
  1365. **    - for i in 0 .. (numtokens - 1) do
  1366. **         - vector[i] = token_str
  1367. **         - advance token_str to point at the next character past the
  1368. **           righmost NUL-byte (which should be the start of the next token).
  1369. **      end-for
  1370. **    - return the number of tokens parsed.
  1371. ***^^**********************************************************************/
  1372. #ifdef __ANSI_C__
  1373. X   int strsplit( char **vec[], char token_str[], const char separators[] )
  1374. #endif
  1375. {
  1376. X   register   char c, *pread, *pwrite;
  1377. X   int   i, count = 0;
  1378. X
  1379. X   if ( !token_str )    return   0;
  1380. X      /* if delim-string is NULL, whitespace is used */
  1381. X   if ( !separators )   separators = WhiteSpace;
  1382. X
  1383. X      /* trim leading separators */
  1384. X   pread = token_str;
  1385. X   while ( strchr(separators, *pread) )   ++pread;
  1386. X   token_str = pwrite = pread;
  1387. X
  1388. X      /*
  1389. X      ** make first pass through string, counting # of tokens and
  1390. X      ** separating all tokens by a single '\0'
  1391. X      */
  1392. X   while ( c = *pread++ ) {
  1393. X      if ( !strchr(separators, c) )   {
  1394. X         *pwrite++ = c;
  1395. X      }
  1396. X      else {
  1397. X         *pwrite++ = '\0';   /* null terminate this token */
  1398. X         ++count;                /* update token count */
  1399. X         while ( strchr(separators, *pread) )   ++pread;
  1400. X      }
  1401. X   }/*while*/
  1402. X   if ( *(pwrite - 1) )  {
  1403. X      ++count;         /* dont forget last token */
  1404. X      *pwrite = '\0';   /* null-terminate */
  1405. X   }
  1406. X
  1407. X      /* allocate space for the caller's vector (remember NULL at the end) */
  1408. X   (*vec) = (char **)malloc( (1 + count) * sizeof( char * ) );
  1409. X   if ( !*vec ) {
  1410. X      fprintf( stderr, "out of memory in strsplit() - aborting\n" );
  1411. X      exit( -1 );
  1412. X   }
  1413. X
  1414. X      /* now go thru token-string again assigning pointers from vector */
  1415. X   pread = token_str;
  1416. X   for ( i = 0 ; i < count ; i++ ) {
  1417. X      (*vec)[i] = pread;   /* assign pointer */
  1418. X      pread += strlen( pread ) + 1;
  1419. X   }/* end-for */
  1420. X
  1421. X      /* set up the trailing pointer to NULL at the end */
  1422. X   (*vec)[ count ] = CHARNULL;
  1423. X   return   count;
  1424. }
  1425. X
  1426. X
  1427. /***************************************************************************
  1428. ** ^FUNCTION: strjoin - join a vector of tokens together
  1429. **
  1430. ** ^SYNOPSIS:
  1431. */
  1432. #ifndef __ANSI_C__
  1433. X   char  *strjoin( argv, separator )
  1434. /*
  1435. ** ^PARAMETERS:
  1436. */
  1437. X   char *argv[];
  1438. /*    -- pointer to the string vector to join together
  1439. */
  1440. X   char separator[];
  1441. /*    -- the the string to use to separate tokens (if NULL, " " is used)
  1442. */
  1443. #endif  /* !__ANSI_C__ */
  1444. X
  1445. /* ^DESCRIPTION:
  1446. **    Strjoin will make a single string out of the given vector by copying
  1447. **    all the tokens from the given vector (in order) toa newly allocated
  1448. **    string. Each token will be separated by an occurence of <separator>.
  1449. **
  1450. **    If <separator> is NULL then a single space is used as the separator.
  1451. **    If <separator> is empty, then no separator is used and the tokens are
  1452. **    simply concatenated together.
  1453. **
  1454. ** ^REQUIREMENTS:
  1455. **    argv must be non-NULL (it must be a valid address), and must be terminated
  1456. **    by a pointer to NULL (argv[last+1] == NULL).
  1457. **
  1458. ** ^SIDE-EFECTS:
  1459. **    Storage is allocated.
  1460. **
  1461. ** ^RETURN-VALUE:
  1462. **    The addres of the newly-joined results (which should be deallocated
  1463. **    using free()). Returns NULL if nothing was joined.
  1464. **
  1465. ** ^ALGORITHM:
  1466. **    - count the number of characters to place in the joined-result.
  1467. **    - allocate a string large-enough to copy the joined-result into.
  1468. **    - copy each string into the string (with <separator> between tokens).
  1469. **    - 0 return the result.
  1470. ***^^**********************************************************************/
  1471. #ifdef __ANSI_C__
  1472. X   char *strjoin( const char *argv[], const char separator[] )
  1473. #endif
  1474. {
  1475. X   size_t  sz = 0;
  1476. X   register char *p;
  1477. X   register CONST char *a, **av;
  1478. X   register int  seplen;
  1479. X   char *result;
  1480. X
  1481. X      /* if argv is NULL, nothing to do */
  1482. X   if ( !argv )  return  CHARNULL;
  1483. X   if ( !separator )  separator = " ";
  1484. X   seplen = strlen( separator );
  1485. X
  1486. X      /* figure out how much space we need */
  1487. X   for ( av = argv ; *av ; av++ ) {
  1488. X      if ( !**av )  continue;
  1489. X      sz += strlen( *av );
  1490. X      if ( seplen  &&  *(av + 1) )  sz += seplen;
  1491. X   }
  1492. X
  1493. X      /* allocate space */
  1494. X   result = (char *)malloc( (sz + 1) * sizeof(char) );
  1495. X   if ( !result )  syserr( "malloc failed in strjoin()" );
  1496. X
  1497. X      /* join the strings together */
  1498. X   *result = '\0';
  1499. X   for ( av = argv, p = result ; (a = *av) ; av++ ) {
  1500. X      if ( !*a )  continue;
  1501. X      while ( (*p = *a++) ) ++p;  /* copy token */
  1502. X      if ( seplen  &&  *(av + 1) ) {
  1503. X         a = separator;
  1504. X         while ( (*p = *a++) ) ++p;  /* copy separator */
  1505. X      }/*end-if*/
  1506. X   }/*end-for*/
  1507. X
  1508. X   return  result;
  1509. }
  1510. X
  1511. X
  1512. /***************************************************************************
  1513. ** ^FUNCTION: get_name - return the aname (argument-name) of an argument
  1514. **
  1515. ** ^SYNOPSIS:
  1516. */
  1517. #ifndef __ANSI_C__
  1518. X   char  *get_name( s, buf )
  1519. /*
  1520. ** ^PARAMETERS:
  1521. */
  1522. X   char *s;
  1523. /*    -- the ad_prompt field of an ARGDESC struct
  1524. */
  1525. X   char *buf;
  1526. /*    -- address to which the aname should be copied
  1527. */
  1528. #endif  /* !__ANSI_C__ */
  1529. X
  1530. /* ^DESCRIPTION:
  1531. **    Get_name will get the full argument name of the given argument
  1532. **    (not just the keyword name) and copy it to buf.
  1533. **
  1534. ** ^REQUIREMENTS:
  1535. **    Both s and buf must be non-null and non-empty.
  1536. **    buf must be large enough to hold the result.
  1537. **
  1538. ** ^SIDE-EFECTS:
  1539. **    buf is overwritten.
  1540. **
  1541. ** ^RETURN-VALUE:
  1542. **    Address of the buffer containing the name.
  1543. **
  1544. ** ^ALGORITHM:
  1545. **    determine the name of an argument from its prompt
  1546. **    and copy the result in the given buffer
  1547. ***^^**********************************************************************/
  1548. #ifdef __ANSI_C__
  1549. X   char *get_name( const char *s, char *buf )
  1550. #endif
  1551. {
  1552. X      /* <buf> must be large enough to hold the result! */
  1553. X   strlcpy(buf, s);
  1554. X   return   buf;
  1555. }
  1556. X
  1557. X
  1558. /***************************************************************************
  1559. ** ^FUNCTION: get_keyword - get the sname (keyword name) of an argument
  1560. **
  1561. ** ^SYNOPSIS:
  1562. */
  1563. #ifndef __ANSI_C__
  1564. X   char  *get_keyword( s, buf )
  1565. /*
  1566. ** ^PARAMETERS:
  1567. */
  1568. X   char *s;
  1569. /*    -- the ad_prompt field of an ARGDESC struct
  1570. */
  1571. X   char *buf;
  1572. /*    -- address to which the sname should be copied
  1573. */
  1574. #endif  /* !__ANSI_C__ */
  1575. X
  1576. /* ^DESCRIPTION:
  1577. **    Get_name will get the keyword name of the given argument
  1578. **    (not the entire argument name) and copy it to buf.
  1579. **
  1580. **    The sname (keyword-name) consists only of all uppercase characters
  1581. **    from the ad_prompt field (in the order they occur). If the ad_prompt
  1582. **    field contains NO uppercase characters, than the aname and the sname
  1583. **    are equivalent (the entire string).
  1584. **
  1585. ** ^REQUIREMENTS:
  1586. **    Both s and buf must be non-null and non-empty.
  1587. **    buf must be large enough to hold the result.
  1588. **
  1589. ** ^SIDE-EFECTS:
  1590. **    buf is overwritten.
  1591. *
  1592. ** ^RETURN-VALUE:
  1593. **    Address of the buffer containing the keyword.
  1594. **
  1595. ** ^ALGORITHM:
  1596. **    determine the keyword of an argument from its prompt
  1597. **    and copy the result in the given buffer
  1598. ***^^**********************************************************************/
  1599. #ifdef __ANSI_C__
  1600. X   char *get_keyword( const char *s, char *buf )
  1601. #endif
  1602. {
  1603. X   register char *p1 = (char *)s, *p2;
  1604. X   register int   i, len = 0;
  1605. X   char *caps = CHARNULL;
  1606. X
  1607. X   if ( !p1 )  return  CHARNULL;
  1608. X
  1609. X      /* find size to copy (use all caps if possible) */
  1610. X   for ( p1 = (char *)s ; *p1 ; p1++ )   {
  1611. X     if ( !caps  &&  isupper( *p1 ) )  caps = p1;
  1612. X         if ( caps   &&   isupper( *p1 ) )   ++len;
  1613. X   }
  1614. X   if ( !caps )   len = (int) (p1 - (char *)s);
  1615. X
  1616. X      /* copy string into buffer and convert it to desired case */
  1617. X      /* <buf> must be large enough to hold the result! */
  1618. X   p1 = buf;
  1619. X   if ( len )   {
  1620. X     if ( !caps ) {
  1621. X        for ( p1 = buf, p2 = (char *)s, i = 0 ; i < len ; p1++, p2++, i++ ) {
  1622. X            *p1 = TO_KWDCASE(*p2);
  1623. X        }
  1624. X     }/*if*/
  1625. X
  1626. X     else {
  1627. X        for ( p2 = caps, i = 0 ; i < len ; p2++ ) {
  1628. X           if ( isupper( *p2 ) )   {
  1629. X              *(p1++) = TO_KWDCASE(*p2);
  1630. X              ++i;
  1631. X           }
  1632. X        }/*for*/
  1633. X     }/*else*/
  1634. X   }/*if*/
  1635. X   *p1 = '\0';
  1636. X
  1637. X   return   buf;   /* return buffer address */
  1638. }
  1639. #ifndef amiga_style
  1640. X
  1641. /***************************************************************************
  1642. ** ^FUNCTION: match - match a keyword against a prospective argument
  1643. **
  1644. ** ^SYNOPSIS:
  1645. */
  1646. #ifndef __ANSI_C__
  1647. X   int match( candidate, target )
  1648. /*
  1649. ** ^PARAMETERS:
  1650. */
  1651. X   char *candidate;
  1652. /*    -- the possible keyword argument
  1653. */
  1654. X   char *target;
  1655. /*    -- the keyword to be matched
  1656. */
  1657. #endif  /* !__ANSI_C__ */
  1658. X
  1659. /* ^DESCRIPTION:
  1660. **    Match will attempt to see if the candidate string matches the
  1661. **    target string (case insensitive). First a match is tried on the
  1662. **    sname of the keyword, then on the aname.  Candidate may be only
  1663. **    a partial leading portion of the target as long as it is at least
  1664. **    two characters long (unless the keyword is 1 character long).
  1665. **
  1666. **    No "partial" matching is accepted for AmigaDOS command-lines.
  1667. **
  1668. ** ^REQUIREMENTS:
  1669. **    Both candidate and target should be non-null and non-empty.
  1670. **    target should be the ad_prompt field of an ARGDESC structure.
  1671. **
  1672. ** ^SIDE-EFECTS:
  1673. **    None.
  1674. **
  1675. ** ^RETURN-VALUE:
  1676. *     < 0  if candidate < target
  1677. **    = 0  if candidate matches target
  1678. **    > 0  if candidate > target
  1679. **
  1680. ** ^ALGORITHM:
  1681. **    - attempt a partial match against the sname and return 0 if we succeed
  1682. **    - attempt a partial match against the aname and return 0 if we succeed
  1683. **    - if both the above fail return non-zero (no match).
  1684. **    
  1685. ***^^**********************************************************************/
  1686. X
  1687. /* rewritten 8/20/90 --BDA */
  1688. #define MINLEN  2     /* minimum # of characters to match */
  1689. X
  1690. #ifdef __ANSI_C__
  1691. X   int match ( const char *candidate, const char *target )
  1692. #endif
  1693. {
  1694. X   int  i, clen, tlen, too_short=0;
  1695. X   CONST char *full_targ;
  1696. X   char *up_targ;
  1697. X
  1698. X
  1699. X   full_targ = target;
  1700. X
  1701. X      /* make up_targ the uppercase portion of target */
  1702. X   up_targ = strdup( full_targ );
  1703. X   (VOID) get_keyword( full_targ, up_targ );
  1704. X
  1705. X      /* match at least MINLEN characters if possible */
  1706. X   tlen = strlen( up_targ );
  1707. X   clen = strlen( candidate );
  1708. X   if ( (tlen >= MINLEN)   &&   (clen < MINLEN) ) {
  1709. X      ++too_short;      /* not long enough -- no match */
  1710. X   }
  1711. X
  1712. #ifdef vms_style
  1713. X      /* if first two chars are NO then match at least MINLEN+2 chars */
  1714. X   if ( !strnicmp(up_targ, "NO", 2) ) {
  1715. X      if ( (tlen >= (MINLEN + 2))   &&   (clen < (MINLEN + 2)) ) {
  1716. X         ++too_short;      /* not long enough -- no match */
  1717. X      }
  1718. X   }
  1719. #endif
  1720. X
  1721. X      /* first try to match prefix of the uppercase portion */
  1722. X   i = (too_short) ? -1 : strnicmp(up_targ, candidate, clen);
  1723. X
  1724. X   free( up_targ );
  1725. X
  1726. X      /* did we match? */
  1727. X   if ( !i )  return  0;   /* yes! */
  1728. X
  1729. X   /* no! : compare the whole target
  1730. X   **       match at least MINLEN characters if possible
  1731. X   */
  1732. X   tlen = strlen(full_targ);
  1733. X   if ( (tlen >= MINLEN)   &&   (clen < MINLEN) ) {
  1734. X      return   -1;      /* not long enough -- no match */
  1735. X   }
  1736. X
  1737. #ifdef vms_style
  1738. X   /* if first two chars are NO then match at least MINLEN+2 chars */
  1739. X   if ( !strnicmp(full_targ, "no", 2) ) {
  1740. X      if ( (tlen >= (MINLEN + 2))   &&   (clen < (MINLEN + 2)) ) {
  1741. X         return   -1;      /* not long enough -- no match */
  1742. X      }
  1743. X   }
  1744. #endif
  1745. X
  1746. X   return   strnicmp(full_targ, candidate, clen);
  1747. }
  1748. X
  1749. X
  1750. /* here is the AmigaDOS version of match() */
  1751. #else
  1752. X
  1753. # ifdef __ANSI_C__
  1754. X   int match( const char *candidate, const char *target )
  1755. # else
  1756. X   int match( candidate, target) char *candidate, *target;
  1757. # endif
  1758. {
  1759. X   int i, j;
  1760. X   char c;
  1761. X
  1762. X   i = j = 0;
  1763. X
  1764. X   while ( isgraph(target[i]) || isgraph(candidate[i]) ) {
  1765. X      while ( islower(target[i]) ) i++;
  1766. X      if ( !isgraph(target[i]) ) {
  1767. X         if ( !isgraph(candidate[j]) )  return 0;
  1768. X         return  stricmp(target, candidate);
  1769. X      }
  1770. X      c = islower( candidate[j] ) ? toupper(candidate[j]) : candidate[j];
  1771. X      if (target[i] != c)  return  stricmp(target, candidate);
  1772. X      i++;
  1773. X      j++;
  1774. X   }
  1775. X   return 0;
  1776. }
  1777. X
  1778. #endif
  1779. X
  1780. X
  1781. /***************************************************************************
  1782. ** ^FUNCTION: basename - return the last component of a pathname
  1783. **
  1784. ** ^SYNOPSIS:
  1785. **    char *basename( path )
  1786. **
  1787. ** ^PARAMETERS:
  1788. **    path;
  1789. **    -- the pathname to be truncated.
  1790. **
  1791. ** ^DESCRIPTION:
  1792. **    Basename takes a pathname and strips of all leading components
  1793. **    (except for the very last one) which refer to directories or
  1794. **    disk-drives.
  1795. **
  1796. ** ^REQUIREMENTS:
  1797. **    path should be non-null, non-empty, and should correspond to a valid
  1798. **    pathname (absolute or relative).
  1799. **
  1800. ** ^SIDE-EFECTS:
  1801. **    None under Unix and AmigaDOS.
  1802. **
  1803. **    Under VMS, the file version is removed and any .COM or .EXE extension
  1804. **    is also removed.
  1805. **
  1806. **    Under MS-DOS, any .EXE, .COM, or .BAT extension is removed.
  1807. **
  1808. **    Under OS/2, any .EXE, .COM, or .CMD extension is removed.
  1809. **    
  1810. ** ^RETURN-VALUE:
  1811. **    The address of the basename of the path.
  1812. **
  1813. ** ^ALGORITHM:
  1814. **    Trivial.
  1815. ***^^**********************************************************************/
  1816. X   /* should use '\\' for MS-DOS & OS/2 and use ']' for VMS */
  1817. #ifdef vms
  1818. #define PATH_SEP ']'
  1819. X
  1820. X      /* VAX/VMS version of basename */
  1821. # ifdef __ANSI_C__
  1822. X   char *basename( char  path[] )
  1823. # else
  1824. X   char *basename( path ) char  path[];
  1825. # endif
  1826. X   {
  1827. X      char *base = strrchr( path, PATH_SEP );
  1828. X      char *vers = strrchr( path, ';' );
  1829. X      char *ext  = strrchr( path, '.' );
  1830. X
  1831. X      if ( !base ) {
  1832. X         if ( !(base = strrchr( path, ':' )) ) {
  1833. X            base = path;
  1834. X         }
  1835. X         else {
  1836. X            ++base;
  1837. X         }
  1838. X      }
  1839. X      else {
  1840. X         ++base;
  1841. X      }
  1842. X
  1843. X      if ( vers )  *vers ='\0';
  1844. X      if ( ext  &&  (!stricmp(ext, ".COM") || !stricmp(ext, ".EXE")) ) {
  1845. X          ext = '\0';
  1846. X      }
  1847. X
  1848. X      return  base;
  1849. X   }
  1850. X
  1851. #else
  1852. #ifdef AmigaDOS
  1853. X      /* amiga version of basename() */
  1854. # ifdef __ANSI_C__
  1855. X   char *basename( char  path[] )
  1856. # else
  1857. X   char *basename( path ) char  path[];
  1858. # endif
  1859. X   {
  1860. X      return   path;
  1861. X   }
  1862. #else
  1863. #define PATH_SEP  '/'     /* default path-separator character */
  1864. X
  1865. X      /* default version of basename() */
  1866. # ifdef __ANSI_C__
  1867. X   char *basename( char  path[] )
  1868. # else
  1869. X   char *basename( path ) char  path[];
  1870. # endif
  1871. X   {
  1872. X      char *base = strrchr( path, PATH_SEP );
  1873. X
  1874. #if ( defined(MSDOS) || defined(OS2) )
  1875. X      /* remove the extension from .EXE, .COM, .BAT, and .CMD files */
  1876. # ifdef OS2
  1877. X      if ( ext  &&  (!stricmp(ext, ".CMD") )  *ext = '\0';
  1878. # else
  1879. X      if ( ext  &&  (!stricmp(ext, ".BAT") )  *ext = '\0';
  1880. # endif
  1881. X
  1882. X      if ( ext  &&  (!stricmp(ext, ".COM") || !stricmp(ext, ".EXE")) ) {
  1883. X          ext = '\0';
  1884. X      }
  1885. #endif
  1886. X
  1887. X      if ( !base ) {
  1888. #if ( defined(MSDOS) || defined(OS2) )
  1889. X         base = strrchr( path, '\\' );
  1890. X         if ( base )  return  (base + 1);
  1891. X         if ( path[ 1 ] == ':' )  return  (path + 2);  /* just remove drive */
  1892. X         return  (base + 1);
  1893. #endif
  1894. X         return  path;
  1895. X      }
  1896. X      else {
  1897. X         return  (base + 1);
  1898. X      }
  1899. X   }
  1900. #endif
  1901. #endif
  1902. X
  1903. X
  1904. /***************************************************************************
  1905. ** ^FUNCTION: indent_para - print a hanging indented paragraph
  1906. **
  1907. ** ^SYNOPSIS:
  1908. */
  1909. #ifndef __ANSI_C__
  1910. X   VOID indent_para(fp, maxcols, margin, title, indent, text)
  1911. /*
  1912. ** ^PARAMETERS:
  1913. */
  1914. X   FILE *fp;
  1915. /*    -- the stream to which output is sent
  1916. */
  1917. X   int maxcols;
  1918. /*    -- the maximum width (in characters) of the output
  1919. */
  1920. X   int margin;
  1921. /*    -- the number of spaces to use as the left margin
  1922. */
  1923. X   char *title;
  1924. /*    -- the paragraph title
  1925. */
  1926. X   int indent;
  1927. /*    -- the distance between the title and the paragraph body
  1928. */
  1929. X   char *text;
  1930. /*    -- the body of the paragraph
  1931. */
  1932. #endif  /* !__ANSI_C__ */
  1933. X
  1934. /* ^DESCRIPTION:
  1935. **    Indent_para will print on fp, a titled, indented paragraph as follows:
  1936. **
  1937. **    <----------------------- maxcols --------------------------->
  1938. **    <--- margin -->     <-- indent -->
  1939. **                   title              This is the first sentence
  1940. **                                      of the paragraph. Etc ...
  1941. **
  1942. ** ^REQUIREMENTS:
  1943. **    maxcols and indent must be positive numbers with maxcols > indent
  1944. **
  1945. ** ^SIDE-EFECTS:
  1946. **    Output is printed to fp.
  1947. **
  1948. ** ^RETURN-VALUE:
  1949. **    None.
  1950. **
  1951. ** ^ALGORITHM:
  1952. **    Print the paragraph title and then print the text.
  1953. **    Lines are automatically adjusted so that each one starts in the
  1954. **    appropriate column.
  1955. ***^^**********************************************************************/
  1956. #ifdef __ANSI_C__
  1957. X   void indent_para( FILE *fp, int maxcols, int margin,
  1958. X                     const char *title, int indent, const char *text )
  1959. #endif
  1960. {
  1961. X   register int idx = 0;
  1962. X   BOOL first_line = TRUE;
  1963. X   int  text_len = strlen(text);
  1964. X   char ch;
  1965. X
  1966. X   /* print the title */
  1967. X      fprintf( fp, "%*s%-*s", margin, "", indent, title );
  1968. X
  1969. X   idx = maxcols - margin - indent;
  1970. X
  1971. X   if ( text_len <= idx )
  1972. X      fprintf(fp, "%s\n", text);
  1973. X   else
  1974. X      do {
  1975. X               /* backup to end of previous word */
  1976. X         while (idx  &&  !isspace(text[idx]))  --idx;
  1977. X         while (idx  &&  isspace(text[idx]))   --idx;
  1978. X
  1979. X            /* print leading whitespace */
  1980. X         if (!first_line)
  1981. X            fprintf(fp, "%*s%-*s", margin, "", indent, "");
  1982. X
  1983. X         ch = text[ ++idx ];
  1984. X         *((char *)text + idx) = '\0';
  1985. X         fprintf(fp, "%s\n", text);
  1986. X         *((char *)text + idx) = ch;
  1987. X         first_line = FALSE;
  1988. X         text = &(text[idx+1]);
  1989. X         text_len -= (idx+1);
  1990. X
  1991. X         while (isspace(*text)) {  /* goto next word */
  1992. X            ++text;
  1993. X            --text_len;
  1994. X         }
  1995. X
  1996. X         idx = maxcols - margin - indent;
  1997. X
  1998. X         if ( text_len <= idx )  /* print-last line */
  1999. X            fprintf(fp, "%*s%-*s%s\n", margin, "", indent, "", text);
  2000. X      } while ( text_len > idx );
  2001. }
  2002. X
  2003. X
  2004. #ifdef STRTEST
  2005. X
  2006. #define WS " \t\n\v\r\f\"'"
  2007. X
  2008. static char string2[] =  "      oh what      a beautiful -    morning!        ";
  2009. X
  2010. static char string[] =  "\n\
  2011. \t' ',  ARGREQ,          argStr,   Name,     'Name',\n\
  2012. \t'n',  ARGOPT|ARGLIST,  listStr,  Groups,   'newsGROUP (newsgroups test)',\n\
  2013. \t'c',  ARGOPT,          argInt,   RepCount, 'REPcount (number of reps)',\n\
  2014. \t'd',  ARGOPT,          argStr,   DirName,  'DIRname',\n\
  2015. \t'x',  ARGOPT,          argBool,  XFlag,    'Xflag (expand in X direction)',\n\
  2016. \t' ',  ARGOPT|ARGLIST,  listStr,  Argv,     'File',\n\
  2017. \tENDOFARGS\n\
  2018. ";
  2019. X
  2020. static char word_str[] = "HELP (print help and quit)";
  2021. X
  2022. main()
  2023. #ifdef __ANSI_C__
  2024. #endif
  2025. {
  2026. X   char **vector;
  2027. X   unsigned i, numtoks;
  2028. X
  2029. X   printf( "test of strtrim() and strsplit():\n\n" );
  2030. X
  2031. X   printf( "unparsed string='%s'\n", string2 );
  2032. X   printf( "ltrimmed string='%s'\n", strltrim( string2, WS ) );
  2033. X   printf( "rtrimmed string='%s'\n", strrtrim( string2, WS ) );
  2034. X
  2035. X   numtoks = strsplit( &vector, string, "," );
  2036. X   printf( "number of tokens=%d\n", numtoks );
  2037. X   for ( i = 0 ; i < numtoks ; i++ ) {
  2038. X      printf( "trimmed token[%d] = '%s'\n", i, strtrim( vector[i], WS ) );
  2039. X   }
  2040. X
  2041. X   exit( 0 );
  2042. }
  2043. X
  2044. #endif
  2045. SHAR_EOF
  2046. chmod 0664 parseargs/strfuncs.c ||
  2047. echo 'restore of parseargs/strfuncs.c failed'
  2048. Wc_c="`wc -c < 'parseargs/strfuncs.c'`"
  2049. test 34399 -eq "$Wc_c" ||
  2050.     echo 'parseargs/strfuncs.c: original size 34399, current size' "$Wc_c"
  2051. rm -f _shar_wnt_.tmp
  2052. fi
  2053. # ============= parseargs/strfuncs.h ==============
  2054. if test -f 'parseargs/strfuncs.h' -a X"$1" != X"-c"; then
  2055.     echo 'x - skipping parseargs/strfuncs.h (File already exists)'
  2056.     rm -f _shar_wnt_.tmp
  2057. else
  2058. > _shar_wnt_.tmp
  2059. echo 'x - extracting parseargs/strfuncs.h (Text)'
  2060. sed 's/^X//' << 'SHAR_EOF' > 'parseargs/strfuncs.h' &&
  2061. /***************************************************************************
  2062. ** ^FILE: strfuncs.h - string functions
  2063. **
  2064. ** ^DESCRIPTION:
  2065. **    External declarations for the functions implemented in strfuncs.c
  2066. **
  2067. ** ^HISTORY:
  2068. **    01/07/91    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  2069. ***^^**********************************************************************/
  2070. X
  2071. #ifndef STRFUNCS_H
  2072. #define STRFUNCS_H
  2073. X
  2074. #include <useful.h>
  2075. X
  2076. EXTERN  char  *strucpy      ARGS(( char *, const char * ));
  2077. EXTERN  char  *strlcpy      ARGS(( char *, const char * ));
  2078. EXTERN  char  *strupr       ARGS(( char * ));
  2079. EXTERN  char  *strlwr       ARGS(( char * ));
  2080. EXTERN  int    stricmp      ARGS(( const char *, const char * ));
  2081. EXTERN  int    strnicmp     ARGS(( const char *, const char *, size_t ));
  2082. X
  2083. #ifdef BSD
  2084. X   EXTERN  char  *strdup    ARGS(( const char * ));
  2085. X   EXTERN  char  *strpbrk   ARGS(( const char *, const char * ));
  2086. X   EXTERN  int    strspn    ARGS(( const char *, const char * ));
  2087. X   EXTERN  int    strcspn   ARGS(( const char *, const char * ));
  2088. #endif
  2089. X
  2090. EXTERN  char  *strltrim     ARGS(( char *, const char * ));
  2091. EXTERN  char  *strrtrim     ARGS(( char *, const char * ));
  2092. EXTERN  char  *strtrim      ARGS(( char *, const char * ));
  2093. EXTERN  int    strsplit     ARGS(( char ***, char *, const char * ));
  2094. EXTERN  char  *strjoin      ARGS(( const char **, const char * ));
  2095. EXTERN  char  *get_name     ARGS(( const char *, char * ));
  2096. EXTERN  char  *get_keyword  ARGS(( const char *, char * ));
  2097. EXTERN  int    match        ARGS(( const char *, const char * ));
  2098. EXTERN  char  *basename     ARGS(( char * ));
  2099. EXTERN  VOID   indent_para  ARGS(( FILE *, int, int,
  2100. X                                   const char *, int, const char * ));
  2101. X
  2102. #endif
  2103. SHAR_EOF
  2104. chmod 0664 parseargs/strfuncs.h ||
  2105. echo 'restore of parseargs/strfuncs.h failed'
  2106. Wc_c="`wc -c < 'parseargs/strfuncs.h'`"
  2107. test 1729 -eq "$Wc_c" ||
  2108.     echo 'parseargs/strfuncs.h: original size 1729, current size' "$Wc_c"
  2109. rm -f _shar_wnt_.tmp
  2110. fi
  2111. # ============= parseargs/syserr.c ==============
  2112. if test -f 'parseargs/syserr.c' -a X"$1" != X"-c"; then
  2113.     echo 'x - skipping parseargs/syserr.c (File already exists)'
  2114.     rm -f _shar_wnt_.tmp
  2115. else
  2116. > _shar_wnt_.tmp
  2117. echo 'x - extracting parseargs/syserr.c (Text)'
  2118. sed 's/^X//' << 'SHAR_EOF' > 'parseargs/syserr.c' &&
  2119. /*************************************************************************
  2120. ** ^FILE: syserr.c - error-message printing routines
  2121. **
  2122. ** ^DESCRIPTION:
  2123. **    This fill implements various routines for printing diagnostic
  2124. **    messages on standard diagnostic output (stderr). The routines are:
  2125. **
  2126. **       usrerr()  --  print message and any system message(s) and return
  2127. **       syserr()  --  print message and any system message(s) and exit
  2128. **       eprintf() --  print to stderr and return
  2129. **
  2130. ** ^HISTORY:
  2131. **    01/02/91    Brad Appleton    <brad@ssd.csd.harris.com>
  2132. **       - Changed to use varargs/stdargs
  2133. **       - Added structured comment blocks
  2134. **       - Added eprintf()
  2135. **
  2136. **    --/--/--    Peter da Silva    <peter@ferranti.com>
  2137. **
  2138. **    --/--/--    Eric P. Allman    <eric@Berkeley.EDU>     Created
  2139. ***^^**********************************************************************/
  2140. X
  2141. #include <stdio.h>
  2142. #include <useful.h>
  2143. /* #include <funclist.h> */
  2144. X
  2145. VERSIONID("$Header: syserr.c,v 2.0 89/12/24 00:56:31 eric Exp $");
  2146. X
  2147. extern  char *ProgName;
  2148. extern  int   errno;
  2149. EXTERN  int   vfprintf  ARGS((FILE *, const char *, va_list));
  2150. X
  2151. X
  2152. /***************************************************************************
  2153. ** ^FUNCTION: _error_message - generic message printing routine.
  2154. **
  2155. ** ^SYNOPSIS:
  2156. */
  2157. #ifndef __ANSI_C__
  2158. X   static VOID _error_message( format, ap )
  2159. /*
  2160. ** ^PARAMETERS:
  2161. */
  2162. X   char *format;
  2163. SHAR_EOF
  2164. true || echo 'restore of parseargs/syserr.c failed'
  2165. fi
  2166. echo 'End of  part 9'
  2167. echo 'File parseargs/syserr.c is continued in part 10'
  2168. echo 10 > _shar_seq_.tmp
  2169. exit 0
  2170. exit 0 # Just in case...
  2171. -- 
  2172. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2173. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2174. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2175. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2176.