home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume26 / parseargs / patch09b < prev    next >
Encoding:
Text File  |  1991-11-25  |  19.5 KB  |  611 lines
  1. Newsgroups: comp.sources.misc
  2. From: Brad Appleton <brad@hcx1.ssd.csd.harris.com>
  3. Subject:  v26i066:  parseargs - functions to parse command line arguments, Patch09b/2
  4. Message-ID: <1991Nov26.023515.26816@sparky.imd.sterling.com>
  5. X-Md4-Signature: 02ad4830d62790c0e43b254f7b67c5be
  6. Date: Tue, 26 Nov 1991 02:35:15 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 66
  11. Archive-name: parseargs/patch09b
  12. Environment: UNIX, VMS, MS-DOS, OS/2, Amiga
  13. Patch-To: parseargs: Volume 17, Issue 46-57
  14.  
  15. #!/bin/sh
  16. # do not concatenate these parts, unpack them in order with /bin/sh
  17. # file PATCH09 continued
  18. #
  19. if test ! -r _shar_seq_.tmp; then
  20.     echo 'Please unpack part 1 first!'
  21.     exit 1
  22. fi
  23. (read Scheck
  24.  if test "$Scheck" != 2; then
  25.     echo Please unpack part "$Scheck" next!
  26.     exit 1
  27.  else
  28.     exit 0
  29.  fi
  30. ) < _shar_seq_.tmp || exit 1
  31. if test ! -f _shar_wnt_.tmp; then
  32.     echo 'x - still skipping PATCH09'
  33. else
  34. echo 'x - continuing file PATCH09'
  35. sed 's/^X//' << 'SHAR_EOF' >> 'PATCH09' &&
  36. X  **    ProgName (which is initially NULL) will be used to point to the
  37. X  **    command-name (specified on the command-line) of the command that
  38. X  **    has most recently invoked a function in the parseargs library.
  39. + **    ProgNameLen will be set to the length of the string.
  40. X  ***^^**********************************************************************/
  41. X  CONST char *ProgName = CHARNULL;
  42. + int ProgNameLen = 0;
  43. X  
  44. X  EXTERN  VOID  syserr   ARGS((const char *, ...));
  45. X  EXTERN  VOID  usrerr   ARGS((const char *, ...));
  46. ***************
  47. *** 195,201 ****
  48. X  
  49. X  
  50. X  /* override argument descriptor, if none given by user */
  51. ! static ARGDESC    Empty_ArgDesc[] = { START_ARGUMENTS, END_ARGUMENTS };
  52. X  
  53. X  /***************************************************************************
  54. X  ** ^SECTION: DEFAULT-ARGUMENTS
  55. --- 206,212 ----
  56. X  
  57. X  
  58. X  /* override argument descriptor, if none given by user */
  59. ! static ARGDESC  Empty_ArgDesc[] = { START_ARGUMENTS, END_ARGUMENTS };
  60. X  
  61. X  /***************************************************************************
  62. X  ** ^SECTION: DEFAULT-ARGUMENTS
  63. ***************
  64. *** 387,479 ****
  65. X  
  66. X  
  67. X  /***************************************************************************
  68. - ** ^FUNCTION: get_description - get the description portion of a string
  69. - **
  70. - ** ^SYNOPSIS:
  71. - */
  72. - #ifndef __ANSI_C__
  73. -    static char *get_description( str )
  74. - /*
  75. - ** ^PARAMETERS:
  76. - */
  77. -    char *str;
  78. - /*    -- the string to parse for a description
  79. - */
  80. - #endif  /* !__ANSI_C__ */
  81. - 
  82. - /* ^DESCRIPTION:
  83. - **    Get_description null terminates the first portion of the string and
  84. - **    returns a pointer to the second portion.
  85. - **
  86. - **    Two "portions" must be either separated by whitespace or the second
  87. - **    portion may be within "(),{},[], or <>" delimiters. The second
  88. - **    portion is assumed to begin with the first alphabetic following
  89. - **    separator.
  90. - **
  91. - ** ^REQUIREMENTS:
  92. - **    str should be non-null and non-empty
  93. - **
  94. - ** ^SIDE-EFFECTS:
  95. - **    The characters which separated the two portions of <str> are
  96. - **    replaced with a single '\0'.
  97. - **
  98. - ** ^RETURN-VALUE:
  99. - **    Address of the description (or NULL if the string has no description).
  100. - **
  101. - ** ^ALGORITHM:
  102. - **    - locate the end of the first portion by scanning for whitespace or
  103. - **      balanced delimiters.
  104. - **    - locate the beginning of the second portion by scanning for the first
  105. - **      alpha-numeric following the end of the first portion.
  106. - **    - return the address of the description.
  107. - ***^^**********************************************************************/
  108. - #ifdef __ANSI_C__
  109. -    static char *get_description( char *str )
  110. - #endif
  111. - {
  112. -    register char  *description = CHARNULL;
  113. -    BOOL  is_end = FALSE, is_balanced = FALSE;
  114. -    char  *p;
  115. -    static CONST char  whitespace[]  = " \t\n\r\f\v";
  116. -    static CONST char  beg_portion[] = "(<{[";
  117. -    static CONST char  end_portion[] = ")>}]";
  118. - 
  119. -    description = strpbrk( str, whitespace );
  120. -    if ( description ) {
  121. -       is_end = TRUE;
  122. -       *description++ = '\0';  /* null terminate the 1st portion */
  123. -       while ( isspace(*description) )  ++description;  /* trim leading ' ' */
  124. -    }
  125. - 
  126. -    if ( !is_end ) {
  127. -        p = strpbrk( str, beg_portion );
  128. -        if ( p )  description = p;
  129. -    }
  130. - 
  131. -    if ( description ) {
  132. -       if ( !is_end ) {  /* null terminate and skip leading '(' */
  133. -          is_end = is_balanced = TRUE;
  134. -          *description++ = '\0';
  135. -       }
  136. -       else if ( strchr(beg_portion, *description) ) {
  137. -             is_balanced = TRUE;
  138. -             ++description;
  139. -       }
  140. -       if ( is_balanced ) {  /* remove trailing ')' */
  141. -          p = description + (strlen( description ) - 1);
  142. -          if ( strchr(end_portion, *p) )  *p = '\0';
  143. -       }
  144. -    }/*end-if*/
  145. - 
  146. -    if ( description  &&  !is_balanced ) {
  147. -       while ( !isalnum(*description) )  ++description;
  148. -    }
  149. - 
  150. -    return  description;
  151. - }
  152. - 
  153. - 
  154. - /***************************************************************************
  155. X  ** ^FUNCTION: init_args - Initialize the command object
  156. X  **
  157. X  ** ^SYNOPSIS:
  158. --- 398,403 ----
  159. ***************
  160. *** 522,527 ****
  161. --- 446,452 ----
  162. X     int  ad_count = 0;
  163. X     BOOL old_style = FALSE;
  164. X     char *description = CHARNULL, *purpose = CHARNULL;
  165. +    int  desclen;
  166. X  
  167. X     if ( !argd )  return;
  168. X  
  169. ***************
  170. *** 542,556 ****
  171. X        if (ARG_isBOOLEAN(ad) || ARG_isPSEUDOARG(ad))
  172. X           BSET( arg_flags(ad), ARGNOVAL );
  173. X  
  174. ! #ifdef UNWRITABLE_STRING_LITERALS
  175. !       ad->ad_prompt = strdup( ad->ad_prompt );
  176. ! #endif
  177. ! 
  178. !       description = get_description( (char *)arg_sname(ad) );
  179. !       if ( description )  {
  180. X           BSET(arg_flags(ad), ARGDESCRIBED);
  181. -          strcpy( (char *)arg_sdesc(ad), description );
  182. -       }
  183. X     }
  184. X  
  185. X        /* shift all the entries down one to make room for a new 1st-entry
  186. --- 467,474 ----
  187. X        if (ARG_isBOOLEAN(ad) || ARG_isPSEUDOARG(ad))
  188. X           BSET( arg_flags(ad), ARGNOVAL );
  189. X  
  190. !       if ( get_argdesc( (char *)arg_sname(ad), &desclen ) )
  191. X           BSET(arg_flags(ad), ARGDESCRIBED);
  192. X     }
  193. X  
  194. X        /* shift all the entries down one to make room for a new 1st-entry
  195. ***************
  196. *** 580,592 ****
  197. X     }
  198. X  #endif
  199. X  
  200. ! #ifdef UNWRITABLE_STRING_LITERALS
  201. !    cmd_name(argd) = strdup( cmd_name(argd) );
  202. ! #endif
  203. ! 
  204. X       /* if new-style, get the purpose from the command name */
  205. X     if ( !old_style  &&  cmd_name(argd) ) {
  206. !       purpose = get_description( (char *)cmd_name(argd) );
  207. X     }
  208. X  
  209. X        /* set the program name */
  210. --- 498,507 ----
  211. X     }
  212. X  #endif
  213. X  
  214. !    if ( cmd_name(argd) )  cmd_name(argd) = strdup( cmd_name(argd) );
  215. X       /* if new-style, get the purpose from the command name */
  216. X     if ( !old_style  &&  cmd_name(argd) ) {
  217. !       purpose = cmd_name(argd);
  218. X     }
  219. X  
  220. X        /* set the program name */
  221. ***************
  222. *** 1244,1250 ****
  223. X  
  224. X     /* the combination of parse-flags that may be set via $PARSECNTL */
  225. X  #define  pa_USRFLAGS \
  226. !     (pa_PROMPT|pa_IGNORE|pa_ANYCASE|pa_OPTSONLY|pa_KWDSONLY|pa_FLAGS1ST)
  227. X  
  228. X  #ifdef __ANSI_C__
  229. X     static void get_parse_flags( ARGDESC *cmd )
  230. --- 1159,1165 ----
  231. X  
  232. X     /* the combination of parse-flags that may be set via $PARSECNTL */
  233. X  #define  pa_USRFLAGS \
  234. !    (pa_PROMPT|pa_IGNORE|pa_ANYCASE|pa_OPTSONLY|pa_KWDSONLY|pa_FLAGS1ST)
  235. X  
  236. X  #ifdef __ANSI_C__
  237. X     static void get_parse_flags( ARGDESC *cmd )
  238. ***************
  239. *** 1379,1385 ****
  240. X     if ( BTEST(cmd_state(cmd), ps_NOCMDENV) )  return;
  241. X  
  242. X        /* build the name of the environment variable */
  243. !    strucpy( env_name, ProgName );
  244. X     strcat( env_name, ENV_SUFFIX );
  245. X  
  246. X        /* get the value of the environment variable,
  247. --- 1294,1302 ----
  248. X     if ( BTEST(cmd_state(cmd), ps_NOCMDENV) )  return;
  249. X  
  250. X        /* build the name of the environment variable */
  251. !    strncpy( env_name, ProgName, ProgNameLen );
  252. !    env_name[ProgNameLen] = 0;
  253. !    (VOID) strupr( env_name );
  254. X     strcat( env_name, ENV_SUFFIX );
  255. X  
  256. X        /* get the value of the environment variable,
  257. ***************
  258. *** 1400,1405 ****
  259. --- 1317,1326 ----
  260. X           return;
  261. X        }
  262. X  
  263. + #ifdef vms_style
  264. +       BSET( cmd_state(cmd), ps_NOTCMDLINE );
  265. + #endif
  266. + 
  267. X        rc = parse_argv_style( argv, cmd );
  268. X        free( argv );
  269. X        cmd_list(cmd) = ARGDESCNULL;  /* dont allow lists to continue on */
  270. ***************
  271. *** 1407,1416 ****
  272. X        cmd_prev(cmd) = ARGDESCNULL;
  273. X  #endif
  274. X  
  275. X           /* check for errors */
  276. X        if ( rc  &&  !BTEST(cmd_flags(cmd), pa_IGNORE) ) {
  277. !          eprintf( "%s: syntax-error in %s \"%s\".\n",
  278. !                   ProgName, USER_VARIABLE, env_name );
  279. X           eprintf( "\t%s = \"%s\"\n\n", env_name, env_args );
  280. X           free( env_val );
  281. X           usage( cmd );
  282. --- 1328,1341 ----
  283. X        cmd_prev(cmd) = ARGDESCNULL;
  284. X  #endif
  285. X  
  286. + #ifdef vms_style
  287. +       BCLEAR( cmd_state(cmd), ps_NOTCMDLINE );
  288. + #endif
  289. + 
  290. X           /* check for errors */
  291. X        if ( rc  &&  !BTEST(cmd_flags(cmd), pa_IGNORE) ) {
  292. !          eprintf( "%.*s: syntax-error in %s \"%s\".\n",
  293. !                   ProgNameLen, ProgName, USER_VARIABLE, env_name );
  294. X           eprintf( "\t%s = \"%s\"\n\n", env_name, env_args );
  295. X           free( env_val );
  296. X           usage( cmd );
  297. ***************
  298. *** 1451,1457 ****
  299. X  **    macros or with the ENDOFARGS (and possible STARTOFARGS) macros.
  300. X  **
  301. X  ** ^SIDE-EFFECTS:
  302. ! **      Initialize argd and parses any default arguments.
  303. X  **
  304. X  ** ^RETURN-VALUE:
  305. X  **    pointer to the arg-descriptors
  306. --- 1376,1382 ----
  307. X  **    macros or with the ENDOFARGS (and possible STARTOFARGS) macros.
  308. X  **
  309. X  ** ^SIDE-EFFECTS:
  310. ! **    Initialize argd and parses any default arguments.
  311. X  **
  312. X  ** ^RETURN-VALUE:
  313. X  **    pointer to the arg-descriptors
  314. ***************
  315. *** 1481,1489 ****
  316. --- 1406,1416 ----
  317. X        /* save the name of this program (for error messages) */
  318. X     if ( cmd_argv0(cmd)  &&  *(cmd_argv0(cmd)) ) {
  319. X        ProgName = cmd_argv0(cmd);
  320. +       ProgNameLen = get_argpfx(ProgName);
  321. X     }
  322. X     else if ( cmd_name(cmd)  &&  *(cmd_name(cmd)) ) {
  323. X        ProgName = cmd_name(cmd);
  324. +       ProgNameLen = get_argpfx(ProgName);
  325. X     }
  326. X     else {
  327. X        unnamed = TRUE;
  328. ***************
  329. *** 1559,1567 ****
  330. --- 1486,1496 ----
  331. X  
  332. X     if ( cmd_argv0(cmd) && *(cmd_argv0(cmd)) ) {
  333. X        ProgName = cmd_argv0(cmd);
  334. +       ProgNameLen = get_argpfx(ProgName);
  335. X     }
  336. X     else if ( cmd_name(cmd) && *(cmd_name(cmd)) ) {
  337. X        ProgName = cmd_name(cmd);
  338. +       ProgNameLen = get_argpfx(ProgName);
  339. X     }
  340. X  
  341. X     usg_ctl = get_usage_flags(cmd);
  342. ***************
  343. *** 1700,1706 ****
  344. X           {
  345. X              register ARGDESC *ad, *args;
  346. X              char *name = VA_ARG( ap, char * );
  347. !             int  *argflags;
  348. X              BOOL  is_match = FALSE;
  349. X  
  350. X                 /* first we have to find the argument whose flags we need */
  351. --- 1629,1635 ----
  352. X           {
  353. X              register ARGDESC *ad, *args;
  354. X              char *name = VA_ARG( ap, char * );
  355. !             argMask_t  *argflags;
  356. X              BOOL  is_match = FALSE;
  357. X  
  358. X                 /* first we have to find the argument whose flags we need */
  359. ***************
  360. *** 1722,1729 ****
  361. X  
  362. X                 /* now that we found it - retrieve the argument flags */
  363. X              if ( isREADING(mode) ) {
  364. !               argflags = VA_ARG( ap, int * );
  365. !               *argflags = (int) arg_flags(ad);
  366. X              }
  367. X              else {
  368. X                rc = pe_BADMODE;  /* parsecntl() wont set ARGFLAGS */
  369. --- 1651,1658 ----
  370. X  
  371. X                 /* now that we found it - retrieve the argument flags */
  372. X              if ( isREADING(mode) ) {
  373. !               argflags = VA_ARG( ap, argMask_t * );
  374. !               *argflags = arg_flags(ad);
  375. X              }
  376. X              else {
  377. X                rc = pe_BADMODE;  /* parsecntl() wont set ARGFLAGS */
  378. ***************
  379. *** 1733,1752 ****
  380. X  
  381. X        case  pc_PARSEFLAGS : /* get/set the parse-flags */
  382. X           {
  383. !             int *pflags, flags;
  384. X  
  385. X                 /* get value from call-stack (dependent on the mode) */
  386. X              if ( isREADING(mode) ) {
  387. !               pflags = VA_ARG( ap, int * );
  388. !               flags = (int) cmd_flags(cmd);
  389. X              }
  390. X              else {
  391. !               flags = VA_ARG( ap, int );
  392. X                pflags = &flags;
  393. X              }
  394. X  
  395. X                 /* perform the desired action(s) */
  396. !             if ( isWRITING(mode) )  cmd_flags(cmd) = (argMask_t) *pflags;
  397. X              if ( isREADING(mode) )  *pflags = flags;
  398. X           }/*block*/
  399. X           break;
  400. --- 1662,1681 ----
  401. X  
  402. X        case  pc_PARSEFLAGS : /* get/set the parse-flags */
  403. X           {
  404. !             argMask_t *pflags, flags;
  405. X  
  406. X                 /* get value from call-stack (dependent on the mode) */
  407. X              if ( isREADING(mode) ) {
  408. !               pflags = VA_ARG( ap, argMask_t * );
  409. !               flags = cmd_flags(cmd);
  410. X              }
  411. X              else {
  412. !               flags = (argMask_t) VA_ARG( ap, int );
  413. X                pflags = &flags;
  414. X              }
  415. X  
  416. X                 /* perform the desired action(s) */
  417. !             if ( isWRITING(mode) )  cmd_flags(cmd) = *pflags;
  418. X              if ( isREADING(mode) )  *pflags = flags;
  419. X           }/*block*/
  420. X           break;
  421. ***************
  422. *** 1793,1800 ****
  423. X                 /* get value from call-stack (dependent on the mode) */
  424. X              if ( isREADING(mode) ) {
  425. X                 pstr = VA_ARG( ap, CONST char ** );
  426. !                if      ( cntl == pc_NAME )        str = cmd_name(cmd);
  427. !                else if ( cntl == pc_PURPOSE )     str = cmd_purpose(cmd);
  428. X                 else /* cntl == pc_DESCRIPTION */  str = cmd_description(cmd);
  429. X              }
  430. X              else {
  431. --- 1722,1768 ----
  432. X                 /* get value from call-stack (dependent on the mode) */
  433. X              if ( isREADING(mode) ) {
  434. X                 pstr = VA_ARG( ap, CONST char ** );
  435. !                if      ( cntl == pc_NAME ) {
  436. !                   if ( !BTEST(cmd_state(cmd), ps_USERNAME|ps_FREENAME) ) {
  437. !                      if ( cmd_name(argd) ) {
  438. !                         int  n;
  439. !                         char  *p;
  440. ! 
  441. !                         n = get_argpfx( (char *)cmd_name(argd) );
  442. !                         p = (char *)malloc( n+1 );
  443. !                         if ( !p ) {
  444. !                            syserr( "malloc failed in parsecntl()" );
  445. !                         }
  446. !                         strncpy(p, (char *)cmd_name(argd), n);
  447. !                         p[n] = 0;
  448. !                         cmd_name(argd) = p;
  449. !                         BSET(cmd_state(cmd), ps_FREENAME);
  450. !                      }
  451. !                   }
  452. !                   str = cmd_name(cmd);
  453. !                }
  454. !                else if ( cntl == pc_PURPOSE ) {
  455. !                   if ( !BTEST(cmd_state(cmd), ps_USERPURPOSE|ps_FREEPURPOSE) ) {
  456. !                      if ( cmd_purpose(argd) ) {
  457. !                         int  n;
  458. !                         char  *p, *q;
  459. ! 
  460. !                         p = get_argdesc( (char *)cmd_purpose(argd), &n );
  461. !                         if ( p ) {
  462. !                            q = (char *)malloc( n+1 );
  463. !                            if ( !q ) {
  464. !                               syserr( "malloc failed in parsecntl()" );
  465. !                            }
  466. !                            strncpy(q, p, n);
  467. !                            q[n] = 0;
  468. !                            p = q;
  469. !                            BSET(cmd_state(cmd), ps_FREEPURPOSE);
  470. !                         }
  471. !                         cmd_purpose(cmd) = p;
  472. !                      }
  473. !                   }
  474. !                   str = cmd_purpose(cmd);
  475. !                }
  476. X                 else /* cntl == pc_DESCRIPTION */  str = cmd_description(cmd);
  477. X              }
  478. X              else {
  479. ***************
  480. *** 1804,1811 ****
  481. X  
  482. X                 /* perform the desired action(s) */
  483. X              if ( isWRITING(mode) )  {
  484. !                if      ( cntl == pc_NAME )        cmd_name(cmd) = *pstr;
  485. !                else if ( cntl == pc_PURPOSE )     cmd_purpose(cmd) = *pstr;
  486. X                 else /* cntl == pc_DESCRIPTION */  cmd_description(cmd) = *pstr;
  487. X              }
  488. X              if ( isREADING(mode) )  *pstr = str;
  489. --- 1772,1792 ----
  490. X  
  491. X                 /* perform the desired action(s) */
  492. X              if ( isWRITING(mode) )  {
  493. !                if ( cntl == pc_NAME ) {
  494. !                   if ( BTEST(cmd_state(cmd), ps_FREENAME) )
  495. !                      free( cmd_name(cmd) );
  496. !                      BCLEAR( cmd_state(cmd), ps_FREENAME );
  497. !                      BSET( cmd_state(cmd), ps_USERNAME );
  498. !                      cmd_name(cmd) = *pstr;
  499. !                   }
  500. !                else if ( cntl == pc_PURPOSE ) {
  501. !                   if ( BTEST(cmd_state(cmd), ps_FREEPURPOSE) ) {
  502. !                      free( cmd_purpose(cmd) );
  503. !                   }
  504. !                   BCLEAR( cmd_state(cmd), ps_FREEPURPOSE );
  505. !                   BSET( cmd_state(cmd), ps_USERPURPOSE );
  506. !                   cmd_purpose(cmd) = *pstr;
  507. !                }
  508. X                 else /* cntl == pc_DESCRIPTION */  cmd_description(cmd) = *pstr;
  509. X              }
  510. X              if ( isREADING(mode) )  *pstr = str;
  511. ***************
  512. *** 1896,1909 ****
  513. X     BSET(cmd_flags(argd), pa_ARGV0);
  514. X  
  515. X        /* split line up into whitespace separated tokens */
  516. !    if ( !strsplit( &argv, str, CHARNULL ) ) {
  517. !       free( argv );
  518. !       return  rc;
  519. !    }
  520. X  
  521. X     rc = parse_argv_style( argv, parse_init( &argd ) );
  522. X     free( argv );
  523. X  
  524. X        /* scan for missing required arguments */
  525. X     if ( SYNTAX_ERROR(rc, argd) ) {
  526. X        fputc( '\n', stderr );
  527. --- 1877,1895 ----
  528. X     BSET(cmd_flags(argd), pa_ARGV0);
  529. X  
  530. X        /* split line up into whitespace separated tokens */
  531. !    (void) strsplit( &argv, str, CHARNULL );
  532. X  
  533. + #ifdef vms_style
  534. +    BSET( cmd_state(argd), ps_NOTCMDLINE );
  535. + #endif
  536. + 
  537. X     rc = parse_argv_style( argv, parse_init( &argd ) );
  538. X     free( argv );
  539. X  
  540. + #ifdef vms_style
  541. +    BCLEAR( cmd_state(argd), ps_NOTCMDLINE );
  542. + #endif
  543. + 
  544. X        /* scan for missing required arguments */
  545. X     if ( SYNTAX_ERROR(rc, argd) ) {
  546. X        fputc( '\n', stderr );
  547. ***************
  548. *** 2131,2136 ****
  549. --- 2117,2126 ----
  550. X        argv[i] = L_STRING(ls);
  551. X     }
  552. X  
  553. + #ifdef vms_style
  554. +    BSET( cmd_state(argd), ps_NOTCMDLINE );
  555. + #endif
  556. + 
  557. X        /* parse the list */
  558. X     saveflags = cmd_flags(argd);
  559. X     BSET(cmd_flags(argd), pa_ARGV0);
  560. ***************
  561. *** 2137,2142 ****
  562. --- 2127,2136 ----
  563. X     rc = parse_argv_style( argv, parse_init( &argd ) );
  564. X     free( argv );
  565. X  
  566. + #ifdef vms_style
  567. +    BCLEAR( cmd_state(argd), ps_NOTCMDLINE );
  568. + #endif
  569. + 
  570. X        /* scan for missing required arguments */
  571. X     if ( SYNTAX_ERROR(rc, argd) ) {
  572. X        fputc( '\n', stderr );
  573. ***************
  574. *** 2239,2247 ****
  575. --- 2233,2249 ----
  576. X     }
  577. X     VA_END(ap);
  578. X  
  579. + #ifdef vms_style
  580. +    BSET( cmd_state(argd), ps_NOTCMDLINE );
  581. + #endif
  582. + 
  583. X        /* parse the arguments */
  584. X     rc = parse_argv_style( argv, parse_init( &argd ) );
  585. X     free( argv );
  586. + 
  587. + #ifdef vms_style
  588. +    BCLEAR( cmd_state(argd), ps_NOTCMDLINE );
  589. + #endif
  590. X  
  591. X        /* scan for missing required arguments */
  592. X     if ( SYNTAX_ERROR(rc, argd) ) {
  593. SHAR_EOF
  594. echo 'File PATCH09 is complete' &&
  595. chmod 0664 PATCH09 ||
  596. echo 'restore of PATCH09 failed'
  597. Wc_c="`wc -c < 'PATCH09'`"
  598. test 66669 -eq "$Wc_c" ||
  599.     echo 'PATCH09: original size 66669, current size' "$Wc_c"
  600. rm -f _shar_wnt_.tmp
  601. fi
  602. rm -f _shar_seq_.tmp
  603. echo You have unpacked the last part
  604. exit 0
  605. exit 0 # Just in case...
  606. -- 
  607. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  608. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  609. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  610. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  611.