home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume36 / cmdline / patch01b / PATCH01.B
Encoding:
Text File  |  1993-04-04  |  30.8 KB  |  988 lines
  1. *** src/lib/cmdline.h.OLD    Fri Mar 26 10:50:26 1993
  2. --- src/lib/cmdline.h    Tue Mar 23 17:02:47 1993
  3. ***************
  4. *** 9,14 ****
  5. --- 9,21 ----
  6.   //
  7.   // ^HISTORY:
  8.   //    03/19/92    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  9. + //
  10. + //    03/01/93    Brad Appleton    <brad@ssd.csd.harris.com>
  11. + //    - Added arg_sequence field to CmdArg
  12. + //    - Added cmd_nargs_parsed field to CmdLine
  13. + //    - Added cmd_description field to CmdLine
  14. + //    - Added exit_handler() and quit() member-functions to CmdLine
  15. + //    - Added ALLOW_PLUS to list of CmdLine configuration flags
  16.   //-^^---------------------------------------------------------------------
  17.   
  18.   #ifndef _usr_include_cmdline_h
  19. ***************
  20. *** 68,78 ****
  21. --- 75,93 ----
  22.         isLIST      = 0x20,  // argument is a list
  23.         isPOS       = 0x40,  // argument is positional
  24.         isHIDDEN    = 0x80,  // argument is not to be printed in usage
  25. + #ifndef __gplusplus
  26.         isVALTAKEN  = (isVALREQ | isVALOPT),    // argument takes a value
  27.         isOPTVALOPT = (isOPT | isVALOPT),
  28.         isOPTVALREQ = (isOPT | isVALREQ),
  29.         isPOSVALOPT = (isPOS | isVALOPT),
  30.         isPOSVALREQ = (isPOS | isVALREQ),
  31. + #else
  32. +       isVALTAKEN  = 0x06,     // g++ doesnt seem to recognize enums that
  33. +       isOPTVALOPT = 0x02,     // are defined in terms of previous values
  34. +       isOPTVALREQ = 0x04,     // so I have to hard code the values instead.
  35. +       isPOSVALOPT = 0x42,     //
  36. +       isPOSVALREQ = 0x44,     // If this ever changes -- remove this stuff!
  37. + #endif
  38.      } ;
  39.   
  40.        // Flags that say how the argument was specied on the command-line
  41. ***************
  42. *** 204,209 ****
  43. --- 219,234 ----
  44.      unsigned
  45.      flags(void) const  { return  arg_flags; }
  46.   
  47. +       // Get the sequence number corresponding to the last
  48. +       // time this argument was matched on the command-line.
  49. +       //
  50. +       // If this argument was not matched, the sequence number
  51. +       // will be zero, otherwise it will be 'N' where the last
  52. +       // time this argument was matched, it was the 'N'th argument
  53. +       // encountered.
  54. +    unsigned
  55. +    sequence(void) const { return arg_sequence; }
  56. + 
  57.         // Get the character (short-option) name of this argument.
  58.         // Returns '\0' if there isnt one.
  59.      char
  60. ***************
  61. *** 248,253 ****
  62. --- 273,281 ----
  63.      void
  64.      clear(unsigned flags =~0)  { arg_flags &= ~flags; }
  65.   
  66. +       // set sequence number
  67. +    void
  68. +    sequence(unsigned  num) { arg_sequence = num; }
  69.   
  70.      // Private data members
  71.   
  72. ***************
  73. *** 256,261 ****
  74. --- 284,291 ----
  75.      unsigned     arg_flags : 8 ;
  76.      unsigned     arg_syntax : 8 ;
  77.   
  78. +    unsigned     arg_sequence;
  79. + 
  80.      char         arg_char_name;
  81.      const char * arg_keyword_name;
  82.      const char * arg_value_name;
  83. ***************
  84. *** 309,314 ****
  85. --- 339,345 ----
  86.      virtual const char *
  87.      operator()(void);
  88.   
  89. +       // is_temporary returns 0 for CmdArgvIter
  90.      virtual int
  91.      is_temporary(void) const;
  92.   
  93. ***************
  94. *** 361,366 ****
  95. --- 392,398 ----
  96.      void
  97.      delimiters(const char * new_delimiters)  { seps = new_delimiters; }
  98.   
  99. +       // is_temporary returns 1 for CmdStrTokIter
  100.      virtual int
  101.      is_temporary(void) const;
  102.   
  103. ***************
  104. *** 387,392 ****
  105. --- 419,432 ----
  106.      //
  107.   class  CmdIstreamIter : public CmdLineArgIter {
  108.   public:
  109. +    static const unsigned  MAX_LINE_LEN ;
  110. + 
  111. + #ifdef vms
  112. +    enum { c_COMMENT = '!' } ;
  113. + #else
  114. +    enum { c_COMMENT = '#' } ;
  115. + #endif
  116. + 
  117.      CmdIstreamIter(istream & input);
  118.   
  119.      virtual ~CmdIstreamIter(void);
  120. ***************
  121. *** 394,399 ****
  122. --- 434,440 ----
  123.      virtual const char *
  124.      operator()(void);
  125.   
  126. +       // is_temporary returns 1 for CmdIstreamIter
  127.      virtual int
  128.      is_temporary(void) const;
  129.   
  130. ***************
  131. *** 420,426 ****
  132.      enum CmdFlags {
  133.         ANY_CASE_OPTS = 0x001, // Ignore character-case for short-options
  134.         PROMPT_USER   = 0x002, // Prompt the user for missing required args
  135. !       NO_ABORT      = 0x004, // Dont exit upon syntax error
  136.         OPTS_FIRST    = 0x008, // No options after positional parameters
  137.         OPTS_ONLY     = 0x010, // Dont accept short-options
  138.         KWDS_ONLY     = 0x020, // Dont accept long-options
  139. --- 461,467 ----
  140.      enum CmdFlags {
  141.         ANY_CASE_OPTS = 0x001, // Ignore character-case for short-options
  142.         PROMPT_USER   = 0x002, // Prompt the user for missing required args
  143. !       NO_ABORT      = 0x004, // Dont quit upon syntax error
  144.         OPTS_FIRST    = 0x008, // No options after positional parameters
  145.         OPTS_ONLY     = 0x010, // Dont accept short-options
  146.         KWDS_ONLY     = 0x020, // Dont accept long-options
  147. ***************
  148. *** 431,436 ****
  149. --- 472,479 ----
  150.                                   // when we see an unmatched option,
  151.                                   // we will try to see if it matches
  152.                                   // a keyword (and vice-versa).
  153. +       ALLOW_PLUS    = 0x200, // Allow "+" (as well as "--") as a prefix
  154. +                                 // indicating long-options.
  155.      } ;
  156.   
  157.         // Flags to convey parsing-status
  158. ***************
  159. *** 477,482 ****
  160. --- 520,535 ----
  161.      void
  162.      name(const char * progname);
  163.   
  164. +       // Get the command description.
  165. +    const char *
  166. +    description(void)  const  { return  cmd_description; }
  167. + 
  168. +       // Specify a command description.
  169. +    void
  170. +    description(const char * the_description) {
  171. +       cmd_description = the_description;
  172. +    }
  173. + 
  174.         // Append an argument
  175.      CmdLine &
  176.      append(CmdArg * cmdarg);
  177. ***************
  178. *** 615,620 ****
  179. --- 668,708 ----
  180.      epilogue(void) ;
  181.   
  182.      //
  183. +    // Find out the number of arguments parsed so far
  184. +    //
  185. + 
  186. +    unsigned
  187. +    nargs_parsed(void) const { return cmd_nargs_parsed; }
  188. + 
  189. +    //
  190. +    // Exception handling (well -- not really)
  191. +    //
  192. + 
  193. +    typedef  void (* quit_func_t)(int);
  194. + 
  195. +       // When a fatal error is encounteredi or when parsing needs to
  196. +       // terminate immediately, the quit() member function is called.
  197. +       // If the programmer has used quit_handler() to setup his own
  198. +       // handler-function, that that function is called; otherwise
  199. +       // exit() is called with the given status.
  200. +       // 
  201. +    void
  202. +    quit(int status);
  203. + 
  204. +       // Set the quit-handler. The quit-handler is a pointer to
  205. +       // a function that has no return value and takes a single
  206. +       // integer parameter.
  207. +       //
  208. +    void
  209. +    quit_handler(quit_func_t  quit_func) { cmd_quit_handler = quit_func ; }
  210. + 
  211. +       // Get the current quit-handler (returns NULL if there isnt one)
  212. +       //
  213. +    quit_func_t
  214. +    quit_handler(void) const { return  cmd_quit_handler; }
  215. + 
  216. + 
  217. +    //
  218.      // Retrieve a specific argument
  219.      //
  220.   
  221. ***************
  222. *** 704,713 ****
  223. --- 792,804 ----
  224.      unsigned          cmd_state  : 8 ;
  225.      unsigned          cmd_flags  : 16 ;
  226.      unsigned          cmd_status : 16 ;
  227. +    unsigned          cmd_nargs_parsed ;
  228.      const char      * cmd_name ;
  229. +    const char      * cmd_description ;
  230.      CmdArg          * cmd_matched_arg ;
  231.      CmdArgListList  * cmd_args ;
  232.      ostream         * cmd_err ;
  233. +    quit_func_t       cmd_quit_handler ;
  234.   
  235.         // Disallow copying and assignment
  236.      CmdLine(const CmdLine & );
  237. *** src/lib/cmdtest.c.OLD    Fri Mar 26 10:50:31 1993
  238. --- src/lib/cmdtest.c    Wed Mar  3 14:11:57 1993
  239. ***************
  240. *** 6,11 ****
  241. --- 6,14 ----
  242.   //
  243.   // ^HISTORY:
  244.   //    03/18/92    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  245. + //
  246. + //    03/01/93    Brad Appleton    <brad@ssd.csd.harris.com>
  247. + //    - Attached a description to the command.
  248.   //-^^---------------------------------------------------------------------
  249.   
  250.   #include <stdlib.h>
  251. ***************
  252. *** 74,79 ****
  253. --- 77,84 ----
  254.   
  255.            case 'g' : new_flags |= CmdLine::NO_GUESSING;    break;
  256.   
  257. +          case '+' : new_flags |= CmdLine::ALLOW_PLUS;     break;
  258. + 
  259.            default  : break;
  260.         } //switch
  261.      } //for
  262. ***************
  263. *** 100,105 ****
  264. --- 105,111 ----
  265.      't' = Temporary-args\n\
  266.      'q' = Quiet!\n\
  267.      'g' = no-Guessing\n\
  268. +    '+' = allow-plus\n\
  269.   This-is-a-very-long-line-containing-no-whitespace-\
  270.   characters-and-I-just-want-to-see-if-it-gets-\
  271.   formatted-appropriately!"
  272. ***************
  273. *** 200,207 ****
  274. --- 206,219 ----
  275.                   & name,
  276.                   & files,
  277.                   NULL);
  278. + 
  279.      CmdArgvIter  argv_iter(--argc, ++argv);
  280.   
  281. +    cmd.description(
  282. + "This program is intended to statically and dynamically test \
  283. + the CmdLine(3C++) class library."
  284. +    );
  285. + 
  286.      cout << "Test of " << CmdLine::ident() << endl ;
  287.   
  288.      xflag = 0;
  289. ***************
  290. *** 226,232 ****
  291.      int  parse_cin = infile;
  292.   
  293.      // Parse arguments from a string
  294. !    if (str) {
  295.         CmdStrTokIter  tok_iter(str);
  296.   
  297.         xflag = 0;
  298. --- 238,244 ----
  299.      int  parse_cin = infile;
  300.   
  301.      // Parse arguments from a string
  302. !    if (! str.isNULL()) {
  303.         CmdStrTokIter  tok_iter(str);
  304.   
  305.         xflag = 0;
  306. *** src/lib/dump.c.OLD    Fri Mar 26 10:50:35 1993
  307. --- src/lib/dump.c    Mon Mar  1 11:01:33 1993
  308. ***************
  309. *** 8,13 ****
  310. --- 8,18 ----
  311.   //
  312.   // ^HISTORY:
  313.   //    04/01/92    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  314. + //
  315. + //    03/01/93    Brad Appleton    <brad@ssd.csd.harris.com>
  316. + //    - Added arg_sequence field to CmdArg
  317. + //    - Added cmd_nargs_parsed field to CmdLine
  318. + //    - Added cmd_description field to CmdLine
  319.   //-^^---------------------------------------------------------------------
  320.   
  321.   #include  "cmdline.h"
  322. ***************
  323. *** 295,300 ****
  324. --- 300,307 ----
  325.      ::indent(os, level + 1) << "flags=" ;
  326.      dump_arg_flags(os, arg_flags) << "\n";
  327.   
  328. +    ::indent(os, level + 1) << "sequence=" << arg_sequence << "\n";
  329. + 
  330.      ::indent(os, level) << "}" << endl;
  331.   #endif
  332.   }
  333. ***************
  334. *** 309,314 ****
  335. --- 316,323 ----
  336.   
  337.      ::indent(os, level + 1) << "name=\"" << cmd_name << "\"\n";
  338.   
  339. +    ::indent(os, level + 1) << "description=\"" << cmd_description << "\"\n";
  340. + 
  341.      ::indent(os, level + 1) << "flags=" ;
  342.      dump_cmd_flags(os, cmd_flags) << "\n";
  343.   
  344. ***************
  345. *** 327,332 ****
  346. --- 336,344 ----
  347.      } else {
  348.         os << "matched_arg=" << (void *)cmd_matched_arg << "\n";
  349.      }
  350. + 
  351. +    ::indent(os, level + 1) << "# valid-args-parsed="
  352. +                            << cmd_nargs_parsed << "\n" ;
  353.   
  354.      ::indent(os, level) << "}" << endl;
  355.   #endif
  356. *** src/lib/parse.c.OLD    Fri Mar 26 10:50:41 1993
  357. --- src/lib/parse.c    Wed Mar  3 10:02:21 1993
  358. ***************
  359. *** 10,15 ****
  360. --- 10,19 ----
  361.   //
  362.   // ^HISTORY:
  363.   //    12/05/91    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  364. + //
  365. + //    03/01/93    Brad Appleton    <brad@ssd.csd.harris.com>
  366. + //    - Added cmd_nargs_parsed field to CmdLine
  367. + //    - Added exit_handler() and quit() member-functions to CmdLine
  368.   //-^^---------------------------------------------------------------------
  369.   
  370.   #include <stdlib.h>
  371. ***************
  372. *** 58,63 ****
  373. --- 62,68 ----
  374.      cmd_parse_state = cmd_START_STATE ;
  375.      cmd_state = 0 ;
  376.      cmd_status = NO_ERROR ;
  377. +    cmd_nargs_parsed = 0 ;
  378.   
  379.      // reset parse-specific attributes for each argument
  380.      CmdArgListListIter  list_iter(cmd_args);
  381. ***************
  382. *** 94,100 ****
  383.   //
  384.   //    Prints a usage message if there were syntax error.
  385.   //
  386. ! //    Terminates program execution by calling ::exit(e_SYNTAX) if
  387.   //    (NO_ABORT is NOT set and the command-status is NOT NO_ERROR).
  388.   //
  389.   // ^RETURN-VALUE:
  390. --- 99,105 ----
  391.   //
  392.   //    Prints a usage message if there were syntax error.
  393.   //
  394. ! //    Terminates program execution by calling quit(e_SYNTAX) if
  395.   //    (NO_ABORT is NOT set and the command-status is NOT NO_ERROR).
  396.   //
  397.   // ^RETURN-VALUE:
  398. ***************
  399. *** 121,130 ****
  400.      // print usage if necessary
  401.      if (cmd_status & ARG_MISSING) {
  402.         usage();
  403. !       ::exit(e_SYNTAX);
  404.      } else if (cmd_status && (! (cmd_flags & NO_ABORT))) {
  405.         usage();
  406. !       ::exit(e_SYNTAX);
  407.      }
  408.   
  409.      return  cmd_status ;
  410. --- 126,135 ----
  411.      // print usage if necessary
  412.      if (cmd_status & ARG_MISSING) {
  413.         usage();
  414. !       quit(e_SYNTAX);
  415.      } else if (cmd_status && (! (cmd_flags & NO_ABORT))) {
  416.         usage();
  417. !       quit(e_SYNTAX);
  418.      }
  419.   
  420.      return  cmd_status ;
  421. *** src/lib/patchlevel.c.OLD    Fri Mar 26 10:50:46 1993
  422. --- src/lib/patchlevel.c    Wed Mar  3 14:41:41 1993
  423. ***************
  424. *** 9,14 ****
  425. --- 9,17 ----
  426.   //
  427.   // ^HISTORY:
  428.   //    04/03/92    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  429. + //
  430. + //    03/03/93    Brad Appleton    <brad@ssd.csd.harris.com>
  431. + //    - Modified for patch 1
  432.   //-^^---------------------------------------------------------------------
  433.   
  434.   #include "cmdline.h"
  435. ***************
  436. *** 21,33 ****
  437.      // file that makes up this version of the project.
  438.      //
  439.   static const char ident[] =
  440. !    "@(#)SMS  task: cmdline-1.00" ;
  441.   
  442.   
  443.      // Release and patchlevel information
  444.   #define  CMDLINE_RELEASE     1
  445. ! #define  CMDLINE_PATCHLEVEL  0
  446. ! #define  CMDLINE_IDENT       "@(#)CmdLine    1.00"
  447.   
  448.   unsigned
  449.   CmdLine::release(void)  { return  CMDLINE_RELEASE; }
  450. --- 24,36 ----
  451.      // file that makes up this version of the project.
  452.      //
  453.   static const char ident[] =
  454. !    "@(#)SMS  task: cmdline-1.01" ;
  455.   
  456.   
  457.      // Release and patchlevel information
  458.   #define  CMDLINE_RELEASE     1
  459. ! #define  CMDLINE_PATCHLEVEL  1
  460. ! #define  CMDLINE_IDENT       "@(#)CmdLine    1.01"
  461.   
  462.   unsigned
  463.   CmdLine::release(void)  { return  CMDLINE_RELEASE; }
  464. *** src/lib/private.c.OLD    Fri Mar 26 10:50:51 1993
  465. --- src/lib/private.c    Wed Mar  3 10:03:01 1993
  466. ***************
  467. *** 15,20 ****
  468. --- 15,23 ----
  469.   //
  470.   // ^HISTORY:
  471.   //    01/09/92    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  472. + //
  473. + //    03/03/93    Brad Appleton    <brad@ssd.csd.harris.com>
  474. + //    - Added exit_handler() and quit() member-functions to CmdLine
  475.   //-^^---------------------------------------------------------------------
  476.   
  477.   #include <iostream.h>
  478. ***************
  479. *** 96,102 ****
  480.   //    with the argument "cmdarg".
  481.   //
  482.   // ^ALGORITHM:
  483. ! //    - if this is a cmdargUsage argument then print usage and call exit(3C)
  484.   //    - call the operator() of "cmdarg" and save the result.
  485.   //    - if the above call returned SUCCESS then set the GIVEN and VALGIVEN
  486.   //      flags of the argument.
  487. --- 99,105 ----
  488.   //    with the argument "cmdarg".
  489.   //
  490.   // ^ALGORITHM:
  491. ! //    - if this is a cmdargUsage argument then print usage and call quit()
  492.   //    - call the operator() of "cmdarg" and save the result.
  493.   //    - if the above call returned SUCCESS then set the GIVEN and VALGIVEN
  494.   //      flags of the argument.
  495. ***************
  496. *** 107,119 ****
  497.   int
  498.   CmdLine::handle_arg(CmdArg * cmdarg, const char * & arg)
  499.   {
  500. !    int  bad_val ;
  501.   
  502.      // call the argument compiler
  503.      const char * save_arg = arg ;  // just in case someone forgets to set it
  504. !    bad_val = (*cmdarg)(arg, *this);
  505.      if (! bad_val) {
  506.         cmdarg->set(CmdArg::GIVEN) ;
  507.         if (arg != save_arg) {
  508.            cmdarg->set(CmdArg::VALGIVEN) ;
  509.         }
  510. --- 110,123 ----
  511.   int
  512.   CmdLine::handle_arg(CmdArg * cmdarg, const char * & arg)
  513.   {
  514. !    ++cmd_nargs_parsed;  // update the number of parsed args
  515.   
  516.      // call the argument compiler
  517.      const char * save_arg = arg ;  // just in case someone forgets to set it
  518. !    int  bad_val = (*cmdarg)(arg, *this);
  519.      if (! bad_val) {
  520.         cmdarg->set(CmdArg::GIVEN) ;
  521. +       cmdarg->sequence(cmd_nargs_parsed) ;
  522.         if (arg != save_arg) {
  523.            cmdarg->set(CmdArg::VALGIVEN) ;
  524.         }
  525. ***************
  526. *** 397,403 ****
  527.   //
  528.   // ^SIDE-EFFECTS:
  529.   //    - modifies the status of "cmd".
  530. ! //    - terminates execution by calling exit(3C) if cmd_NOABORT is NOT
  531.   //      set and a required argument (that was not properly supplied by
  532.   //      the user) is not given.
  533.   //    - prints on stderr if an argument is missing and cmd_QUIET is NOT set.
  534. --- 401,407 ----
  535.   //
  536.   // ^SIDE-EFFECTS:
  537.   //    - modifies the status of "cmd".
  538. ! //    - terminates execution by calling quit() if cmd_NOABORT is NOT
  539.   //      set and a required argument (that was not properly supplied by
  540.   //      the user) is not given.
  541.   //    - prints on stderr if an argument is missing and cmd_QUIET is NOT set.
  542. *** src/lib/states.h.OLD    Fri Mar 26 10:50:57 1993
  543. --- src/lib/states.h    Mon Feb 22 14:24:12 1993
  544. ***************
  545. *** 56,69 ****
  546. --- 56,81 ----
  547.      cmd_TOK_REQUIRED = 0x01,  // is the "wanted" token required?
  548.   
  549.      cmd_WANT_VAL     = 0x02,  // are we expecting a value?
  550. + #ifndef __gplusplus
  551.      cmd_NEED_VAL     = (cmd_WANT_VAL | cmd_TOK_REQUIRED),
  552. + #else
  553. +    cmd_NEED_VAL     = 0x03,
  554. + #endif
  555.   
  556.   #ifdef vms_style
  557.      cmd_WANT_VALSEP  = 0x04,  // are we expecting ':' or '='
  558. + # ifndef __gplusplus
  559.      cmd_NEED_VALSEP  = (cmd_WANT_VALSEP | cmd_TOK_REQUIRED),
  560. + # else
  561. +    cmd_NEED_VALSEP  = 0x05,
  562. + # endif
  563.   
  564.      cmd_WANT_LISTSEP = 0x08,  // are we expecting ',' or '+'
  565. + # ifndef __gplusplus
  566.      cmd_NEED_LISTSEP = (cmd_WANT_LISTSEP | cmd_TOK_REQUIRED),
  567. + # else
  568. +    cmd_NEED_LISTSEP = 0x09,
  569. + # endif
  570.   #endif
  571.   } ;
  572.   
  573. *** src/lib/unix.c.OLD    Fri Mar 26 10:51:03 1993
  574. --- src/lib/unix.c    Wed Mar  3 14:20:20 1993
  575. ***************
  576. *** 16,21 ****
  577. --- 16,24 ----
  578.   //
  579.   // ^HISTORY:
  580.   //    01/09/92    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  581. + //
  582. + //    03/01/93    Brad Appleton    <brad@ssd.csd.harris.com>
  583. + //    - Added ALLOW_PLUS to list of CmdLine configuration flags
  584.   //-^^---------------------------------------------------------------------
  585.   
  586.   #include <iostream.h>
  587. ***************
  588. *** 27,34 ****
  589.   #include "cmdline.h"
  590.   #include "states.h"
  591.   
  592. !   // Prefix string used for short options
  593. ! static const char OPT_PFX[] = "-" ;
  594.   
  595.     // Function to tell us if an argument looks like an option
  596.   inline static int
  597. --- 30,38 ----
  598.   #include "cmdline.h"
  599.   #include "states.h"
  600.   
  601. ! //
  602. ! // Some Helper function for getting and recognizing prefixes
  603. ! //
  604.   
  605.     // Function to tell us if an argument looks like an option
  606.   inline static int
  607. ***************
  608. *** 36,60 ****
  609.      return  ((*(s) == '-') && ((*((s)+1) != '-')) && ((*((s)+1) != '\0'))) ;
  610.   }
  611.   
  612. !   // Need a prefix string for a long-option and a function to tell us
  613. !   // if an argument looks like a long-option as well.
  614. !   //
  615. ! #ifdef  USE_PLUS
  616. !    static const char KWD_PFX[] = "+" ;
  617.   
  618. -    inline static int
  619. -    isKEYWORD(const char *s) {
  620. -       return   ((*(s) == '+') && ((*((s)+1) != '\0'))) ;
  621. -    }
  622. - #else
  623. -    static const char KWD_PFX[] = "--" ;
  624.   
  625. !    inline static int
  626. !    isKEYWORD(const char *s) {
  627. !       return  ((*(s) == '-') && (*((s)+1) == '-')  && (*((s)+2) != '\0')) ;
  628. !    }
  629. ! #endif
  630.   
  631.      // Need to know when an argument means "end-of-options"
  632.   inline static int
  633.   isENDOPTIONS(const char *s) {
  634. --- 40,64 ----
  635.      return  ((*(s) == '-') && ((*((s)+1) != '-')) && ((*((s)+1) != '\0'))) ;
  636.   }
  637.   
  638. !    // Function to return the option-prefix
  639. ! inline static const char *
  640. ! OptionPrefix(void) { return  "-" ; }
  641.   
  642.   
  643. !    // Function to tell us if an argument looks like a long-option.
  644. !    //
  645. !    // NOTE: allowing "+" does not preclude the use of "--"
  646. !    //
  647. ! inline static int
  648. ! isKEYWORD(const char *s, int allow_plus) {
  649. !    return  (((*(s) == '-') && (*((s)+1) == '-')  && (*((s)+2) != '\0')) ||
  650. !             (allow_plus && (*(s) == '+') && ((*((s)+1) != '\0')))) ;
  651. ! }
  652.   
  653. +    // Function to return the long-option prefix
  654. + inline static const char *
  655. + KeywordPrefix(int allow_plus) { return  (allow_plus) ? "+" : "--" ; }
  656. + 
  657.      // Need to know when an argument means "end-of-options"
  658.   inline static int
  659.   isENDOPTIONS(const char *s) {
  660. ***************
  661. *** 61,67 ****
  662. --- 65,75 ----
  663.      return  ((*(s) == '-') && (*((s)+1) == '-')  && (*((s)+2) == '\0')) ;
  664.   }
  665.   
  666. +    // Function to return the "end-of-options" string
  667. + inline static const char *
  668. + EndOptions(void) { return "--" ; }
  669.   
  670. + 
  671.   //-------
  672.   // ^FUNCTION: CmdLine::parse_option - parse a Unix option
  673.   //
  674. ***************
  675. *** 140,146 ****
  676.               }
  677.            }
  678.            if (! (cmd_flags & QUIET)) {
  679. !             error() << "unknown option \"" << OPT_PFX << char(*arg)
  680.                       << "\"." << endl ;
  681.            }
  682.            rc |= BAD_OPTION ;
  683. --- 148,154 ----
  684.               }
  685.            }
  686.            if (! (cmd_flags & QUIET)) {
  687. !             error() << "unknown option \"" << OptionPrefix() << char(*arg)
  688.                       << "\"." << endl ;
  689.            }
  690.            rc |= BAD_OPTION ;
  691. ***************
  692. *** 164,170 ****
  693.               if (cmdarg->syntax() & CmdArg::isVALREQ) {
  694.                  if (! (cmd_flags & QUIET)) {
  695.                     error() << "value required in same argument for "
  696. !                           << OPT_PFX << char(cmdarg->char_name())
  697.                             << " option." << endl;
  698.                  }
  699.                  rc |= (VAL_MISSING | VAL_NOTSTICKY) ;
  700. --- 172,178 ----
  701.               if (cmdarg->syntax() & CmdArg::isVALREQ) {
  702.                  if (! (cmd_flags & QUIET)) {
  703.                     error() << "value required in same argument for "
  704. !                           << OptionPrefix() << char(cmdarg->char_name())
  705.                             << " option." << endl;
  706.                  }
  707.                  rc |= (VAL_MISSING | VAL_NOTSTICKY) ;
  708. ***************
  709. *** 204,210 ****
  710.             (cmdarg->syntax() & CmdArg::isVALSEP)) {
  711.            if (! (cmd_flags & QUIET)) {
  712.               error() << "value required in separate argument for "
  713. !                     << OPT_PFX << char(cmdarg->char_name())
  714.                       << " option." << endl;
  715.            }
  716.            rc |= (VAL_MISSING | VAL_NOTSEP) ;
  717. --- 212,218 ----
  718.             (cmdarg->syntax() & CmdArg::isVALSEP)) {
  719.            if (! (cmd_flags & QUIET)) {
  720.               error() << "value required in separate argument for "
  721. !                     << OptionPrefix() << char(cmdarg->char_name())
  722.                       << " option." << endl;
  723.            }
  724.            rc |= (VAL_MISSING | VAL_NOTSEP) ;
  725. ***************
  726. *** 285,290 ****
  727. --- 293,300 ----
  728.      int  ambiguous = 0, len = -1, bad_val;
  729.      const char * val = NULL ;
  730.   
  731. +    int  plus = (cmd_flags & ALLOW_PLUS) ;  // Can we use "+"?
  732. + 
  733.      // see if we left an argument dangling without a value
  734.      ck_need_val() ;
  735.   
  736. ***************
  737. *** 312,318 ****
  738.         }
  739.         if (! (cmd_flags & QUIET)) {
  740.            error() << ((ambiguous) ? "ambiguous" : "unknown") << " option "
  741. !                  << "\"" << ((cmd_flags & KWDS_ONLY) ? OPT_PFX : KWD_PFX)
  742.                    << arg << "\"." << endl ;
  743.         }
  744.         rc |= ((ambiguous) ? KWD_AMBIGUOUS : BAD_KEYWORD) ;
  745. --- 322,329 ----
  746.         }
  747.         if (! (cmd_flags & QUIET)) {
  748.            error() << ((ambiguous) ? "ambiguous" : "unknown") << " option "
  749. !                  << "\"" << ((cmd_flags & KWDS_ONLY) ? OptionPrefix()
  750. !                                                      : KeywordPrefix(plus))
  751.                    << arg << "\"." << endl ;
  752.         }
  753.         rc |= ((ambiguous) ? KWD_AMBIGUOUS : BAD_KEYWORD) ;
  754. ***************
  755. *** 334,340 ****
  756.            if (cmdarg->syntax() & CmdArg::isVALREQ) {
  757.               if (! (cmd_flags & QUIET)) {
  758.                  error() << "value required in same argument for "
  759. !                        << ((cmd_flags & KWDS_ONLY) ? OPT_PFX : KWD_PFX)
  760.                          << cmdarg->keyword_name() << " option." << endl;
  761.               }
  762.               rc |= (VAL_MISSING | VAL_NOTSTICKY) ;
  763. --- 345,352 ----
  764.            if (cmdarg->syntax() & CmdArg::isVALREQ) {
  765.               if (! (cmd_flags & QUIET)) {
  766.                  error() << "value required in same argument for "
  767. !                        << ((cmd_flags & KWDS_ONLY) ? OptionPrefix()
  768. !                                                    : KeywordPrefix(plus))
  769.                          << cmdarg->keyword_name() << " option." << endl;
  770.               }
  771.               rc |= (VAL_MISSING | VAL_NOTSTICKY) ;
  772. ***************
  773. *** 374,380 ****
  774.          (cmdarg->syntax() & CmdArg::isVALSEP)) {
  775.         if (! (cmd_flags & QUIET)) {
  776.            error() << "value required in separate argument for "
  777. !                  << ((cmd_flags & KWDS_ONLY) ? OPT_PFX : KWD_PFX)
  778.                    << cmdarg->keyword_name() << " option." << endl;
  779.         }
  780.         rc |= (VAL_MISSING | VAL_NOTSEP) ;
  781. --- 386,393 ----
  782.          (cmdarg->syntax() & CmdArg::isVALSEP)) {
  783.         if (! (cmd_flags & QUIET)) {
  784.            error() << "value required in separate argument for "
  785. !                  << ((cmd_flags & KWDS_ONLY) ? OptionPrefix()
  786. !                                              : KeywordPrefix(plus))
  787.                    << cmdarg->keyword_name() << " option." << endl;
  788.         }
  789.         rc |= (VAL_MISSING | VAL_NOTSEP) ;
  790. ***************
  791. *** 544,549 ****
  792. --- 557,564 ----
  793.   {
  794.      if (arg == NULL)  return  cmd_status ;
  795.   
  796. +    int  plus = (cmd_flags & ALLOW_PLUS) ;  // Can we use "+"?
  797. + 
  798.      if (cmd_parse_state & cmd_TOK_REQUIRED) {
  799.         // If a required value is expected, then this argument MUST be
  800.         // the value (even if it looks like an option
  801. ***************
  802. *** 559,570 ****
  803.            cmd_status |=  parse_option(arg) ;
  804.         }
  805.      } else if ((! (cmd_flags & OPTS_ONLY))
  806. !               && isKEYWORD(arg) && (! (cmd_state & cmd_END_OF_OPTIONS))) {
  807.         cmd_state |= cmd_KEYWORDS_USED ;
  808. !       ++arg ;  // skip over '+' keyword prefix
  809. ! #ifndef USE_PLUS
  810. !       ++arg ;  // skip over '--' keyword prefix
  811. ! #endif
  812.         cmd_status |= parse_keyword(arg) ;
  813.      } else if (isENDOPTIONS(arg) && (! (cmd_state & cmd_END_OF_OPTIONS))) {
  814.         cmd_state |= cmd_END_OF_OPTIONS ;
  815. --- 574,586 ----
  816.            cmd_status |=  parse_option(arg) ;
  817.         }
  818.      } else if ((! (cmd_flags & OPTS_ONLY))
  819. !               && isKEYWORD(arg, plus) && (! (cmd_state & cmd_END_OF_OPTIONS))) {
  820.         cmd_state |= cmd_KEYWORDS_USED ;
  821. !       if (*arg == '+') {
  822. !          ++arg ;  // skip over '+' keyword prefix
  823. !       } else {
  824. !          arg += 2 ;  // skip over '--' keyword prefix
  825. !       }
  826.         cmd_status |= parse_keyword(arg) ;
  827.      } else if (isENDOPTIONS(arg) && (! (cmd_state & cmd_END_OF_OPTIONS))) {
  828.         cmd_state |= cmd_END_OF_OPTIONS ;
  829. ***************
  830. *** 611,624 ****
  831.   ostream &
  832.   CmdLine::arg_error(const char * error_str, const CmdArg * cmdarg) const
  833.   {
  834.      ostream & os = error() << error_str << char(' ') ;
  835.   
  836.      if (cmdarg->flags() & CmdArg::GIVEN) {
  837.          if (cmdarg->flags() & CmdArg::KEYWORD) {
  838. !           os << ((cmd_flags & KWDS_ONLY) ? OPT_PFX : KWD_PFX)
  839.                << cmdarg->keyword_name() << " option" ;
  840.          } else if (cmdarg->flags() & CmdArg::OPTION) {
  841. !           os << OPT_PFX << (char)cmdarg->char_name() << " option" ;
  842.          } else {
  843.             os << cmdarg->value_name() << " argument" ;
  844.          }
  845. --- 627,643 ----
  846.   ostream &
  847.   CmdLine::arg_error(const char * error_str, const CmdArg * cmdarg) const
  848.   {
  849. +    int  plus = (cmd_flags & ALLOW_PLUS) ;  // Can we use "+"?
  850. + 
  851.      ostream & os = error() << error_str << char(' ') ;
  852.   
  853.      if (cmdarg->flags() & CmdArg::GIVEN) {
  854.          if (cmdarg->flags() & CmdArg::KEYWORD) {
  855. !           os << ((cmd_flags & KWDS_ONLY) ? OptionPrefix()
  856. !                                          : KeywordPrefix(plus))
  857.                << cmdarg->keyword_name() << " option" ;
  858.          } else if (cmdarg->flags() & CmdArg::OPTION) {
  859. !           os << OptionPrefix() << (char)cmdarg->char_name() << " option" ;
  860.          } else {
  861.             os << cmdarg->value_name() << " argument" ;
  862.          }
  863. ***************
  864. *** 627,635 ****
  865.             os << cmdarg->value_name() << " argument" ;
  866.          } else {
  867.             if (cmd_flags & KWDS_ONLY) {
  868. !              os << OPT_PFX << cmdarg->keyword_name() << " option" ;
  869.             } else {
  870. !              os << OPT_PFX << (char)cmdarg->char_name() << " option" ;
  871.             }
  872.          }
  873.      }
  874. --- 646,654 ----
  875.             os << cmdarg->value_name() << " argument" ;
  876.          } else {
  877.             if (cmd_flags & KWDS_ONLY) {
  878. !              os << OptionPrefix() << cmdarg->keyword_name() << " option" ;
  879.             } else {
  880. !              os << OptionPrefix() << (char)cmdarg->char_name() << " option" ;
  881.             }
  882.          }
  883.      }
  884. ***************
  885. *** 686,691 ****
  886. --- 705,711 ----
  887.      ostrstream  oss(buf, bufsize);
  888.      *buf = '\0';
  889.   
  890. +    int  plus = (cmd_flags & ALLOW_PLUS) ;  // Can we use "+"?
  891.      char optchar = cmdarg->char_name();
  892.      const char * keyword = cmdarg->keyword_name();
  893.   
  894. ***************
  895. *** 723,734 ****
  896.          (cmdarg->syntax() & CmdArg::isVALSTICKY))
  897.      {
  898.         if (cmdarg->syntax() & CmdArg::isVALOPT) {
  899. !          oss << OPT_PFX << char(optchar) << char('[') << cmdarg->value_name()
  900. !              << "]|" << KWD_PFX << keyword << "[=" << cmdarg->value_name()
  901. !              << char(']') ;
  902.         } else {
  903. !          oss << OPT_PFX << optchar << cmdarg->value_name() << char('|')
  904. !              << KWD_PFX << keyword << char('=') << cmdarg->value_name() ;
  905.         }
  906.         if ((level == VERBOSE_USAGE) && (cmdarg->syntax() & CmdArg::isLIST)) {
  907.            oss << " ..." ;
  908. --- 743,755 ----
  909.          (cmdarg->syntax() & CmdArg::isVALSTICKY))
  910.      {
  911.         if (cmdarg->syntax() & CmdArg::isVALOPT) {
  912. !          oss << OptionPrefix() << char(optchar) << char('[')
  913. !              << cmdarg->value_name() << "]|" << KeywordPrefix(plus)
  914. !              << keyword << "[=" << cmdarg->value_name() << char(']') ;
  915.         } else {
  916. !          oss << OptionPrefix() << optchar << cmdarg->value_name()
  917. !              << char('|') << KeywordPrefix(plus) << keyword << char('=')
  918. !              << cmdarg->value_name() ;
  919.         }
  920.         if ((level == VERBOSE_USAGE) && (cmdarg->syntax() & CmdArg::isLIST)) {
  921.            oss << " ..." ;
  922. ***************
  923. *** 743,758 ****
  924.      if (! (cmdarg->syntax() & CmdArg::isPOS)) {
  925.         switch(syntax) {
  926.            case cmd_OPTS_ONLY :
  927. !             oss << OPT_PFX << char(optchar) ;
  928.               break ;
  929.   
  930.            case cmd_KWDS_ONLY :
  931. !             oss << ((cmd_flags & KWDS_ONLY) ? OPT_PFX : KWD_PFX) << keyword ;
  932.               break ;
  933.   
  934.            case cmd_BOTH :
  935. !             oss << OPT_PFX << char(optchar) << char('|')
  936. !                 << KWD_PFX << keyword ;
  937.               break ;
  938.   
  939.            default :
  940. --- 764,780 ----
  941.      if (! (cmdarg->syntax() & CmdArg::isPOS)) {
  942.         switch(syntax) {
  943.            case cmd_OPTS_ONLY :
  944. !             oss << OptionPrefix() << char(optchar) ;
  945.               break ;
  946.   
  947.            case cmd_KWDS_ONLY :
  948. !             oss << ((cmd_flags & KWDS_ONLY) ? OptionPrefix()
  949. !                                             : KeywordPrefix(plus)) << keyword ;
  950.               break ;
  951.   
  952.            case cmd_BOTH :
  953. !             oss << OptionPrefix() << char(optchar) << char('|')
  954. !                 << KeywordPrefix(plus) << keyword ;
  955.               break ;
  956.   
  957.            default :
  958. *** src/lib/usage.c.OLD    Fri Mar 26 10:51:13 1993
  959. --- src/lib/usage.c    Mon Mar  1 10:48:48 1993
  960. ***************
  961. *** 8,13 ****
  962. --- 8,16 ----
  963.   //
  964.   // ^HISTORY:
  965.   //    01/09/92    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  966. + //
  967. + //    03/01/93    Brad Appleton    <brad@ssd.csd.harris.com>
  968. + //    - Added cmd_description field to CmdLine
  969.   //-^^---------------------------------------------------------------------
  970.   
  971.   #include <iostream.h>
  972. ***************
  973. *** 304,309 ****
  974. --- 307,319 ----
  975.      // now print argument descriptions
  976.      os << "\n" ;
  977.      print_descriptions(cmd_syntax, os, max_cols, longest) ;
  978. + 
  979. +    // now print the command-description if there is one
  980. +    if (cmd_description && *cmd_description) {
  981. +       os << "\nDescription:" << endl;
  982. +       strindent(os, max_cols, 8, "", 0, cmd_description);
  983. +    }
  984. + 
  985.      return  os;
  986.   }
  987.   
  988.