home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / cmdline.lha / cmdline / src / cmd / shells.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-03  |  16.1 KB  |  774 lines
  1. //------------------------------------------------------------------------
  2. // ^FILE: shells.c - implement classes for the various Unix shells
  3. //
  4. // ^DESCRIPTION:
  5. //     This file packages all the information we need to know about each
  6. //  of the shells that cmdparse(1) will support into a set of (sub)classes.
  7. //
  8. // ^HISTORY:
  9. //    04/19/92    Brad Appleton    <brad@ssd.csd.harris.com>    Created
  10. //-^^---------------------------------------------------------------------
  11.  
  12. #include <stdlib.h>
  13. #include <iostream.h>
  14. #include <string.h>
  15. #include <ctype.h>
  16.  
  17. #include <fifolist.h>
  18.  
  19. #include "shells.h"
  20. #include "argtypes.h"
  21.  
  22. //--------------------------------------------------------------- ShellVariable
  23.  
  24. ShellVariable::ShellVariable(const char * name)
  25.    : var_name(name), var_value(NULL)
  26. {
  27. }
  28.  
  29. ShellVariable::~ShellVariable(void)
  30. {
  31. }
  32.  
  33. //------------------------------------------------------------ ShellArrayValues
  34.  
  35. DECLARE_FIFO_LIST(CharPtrList, char *);
  36.  
  37. struct  ShellArrayValues {
  38.    CharPtrList       list;
  39.    CharPtrListArray  array;
  40.  
  41.    ShellArrayValues(void);
  42. } ;
  43.  
  44. ShellArrayValues::ShellArrayValues(void)
  45.    : array(list)
  46. {
  47.    list.self_cleaning(1);
  48. }
  49.  
  50. //------------------------------------------------------------------ ShellArray
  51.  
  52. ShellArray::ShellArray(const char * name)
  53.    : array_name(name), array_value(NULL)
  54. {
  55. }
  56.  
  57. ShellArray::~ShellArray(void)
  58. {
  59.    delete  array_value ;
  60. }
  61.  
  62. void
  63. ShellArray::append(const char * value)
  64. {
  65.    if (array_value == NULL) {
  66.       array_value = new ShellArrayValues ;
  67.    }
  68.    char ** valptr = new char* ;
  69.    if (valptr) {
  70.       *valptr = (char *)value;
  71.       array_value->list.add(valptr);
  72.    }
  73. }
  74.  
  75. unsigned
  76. ShellArray::count(void) const
  77. {
  78.    return  ((array_value) ? array_value->list.count() : 0);
  79. }
  80.  
  81. const char *
  82. ShellArray::operator[](unsigned  index) const
  83. {
  84.    return  ((array_value) ? array_value->array[index] : NULL);
  85. }
  86.  
  87. //----------------------------------------------------------- AbstractUnixShell
  88.  
  89. AbstractUnixShell::~AbstractUnixShell(void)
  90. {
  91. }
  92.  
  93. //------------------------------------------------------------------- UnixShell
  94.  
  95. UnixShell::UnixShell(const char * shell_name)
  96.    : shell(NULL), valid(1)
  97. {
  98.    if (::strcmp(BourneShell::NAME, shell_name) == 0) {
  99.       shell = new BourneShell ;
  100.    } else if (::strcmp("ash", shell_name) == 0) {
  101.       shell = new BourneShell ;
  102.    } else if (::strcmp(KornShell::NAME, shell_name) == 0) {
  103.       shell = new KornShell ;
  104.    } else if (::strcmp(BourneAgainShell::NAME, shell_name) == 0) {
  105.       shell = new BourneAgainShell ;
  106.    } else if (::strcmp(CShell::NAME, shell_name) == 0) {
  107.       shell = new CShell ;
  108.    } else if (::strcmp("tcsh", shell_name) == 0) {
  109.       shell = new CShell ;
  110.    } else if (::strcmp("itcsh", shell_name) == 0) {
  111.       shell = new CShell ;
  112.    } else if (::strcmp(ZShell::NAME, shell_name) == 0) {
  113.       shell = new ZShell ;
  114.    } else if (::strcmp(Plan9Shell::NAME, shell_name) == 0) {
  115.       shell = new Plan9Shell ;
  116.    } else if (::strcmp(PerlShell::NAME, shell_name) == 0) {
  117.       shell = new PerlShell ;
  118.    } else if (::strcmp(TclShell::NAME, shell_name) == 0) {
  119.       shell = new TclShell ;
  120.    } else {
  121.       valid = 0;
  122.    }
  123. }
  124.  
  125. UnixShell::~UnixShell(void)
  126. {
  127.    delete  shell;
  128. }
  129.  
  130. const char *
  131. UnixShell::name(void) const
  132. {
  133.    return  ((shell) ? shell->name() : NULL);
  134. }
  135.  
  136. void
  137. UnixShell::unset_args(const char * name) const
  138. {
  139.    if (shell)  shell->unset_args(name);
  140. }
  141.  
  142. int
  143. UnixShell::is_positionals(const char * name) const
  144. {
  145.    return  ((shell) ? shell->is_positionals(name) : 0);
  146. }
  147.  
  148. void
  149. UnixShell::set(const ShellVariable & variable) const
  150. {
  151.    if (shell)  shell->set(variable);
  152. }
  153.  
  154. void
  155. UnixShell::set(const ShellArray & array, int variant) const
  156. {
  157.    if (shell)  shell->set(array, variant);
  158. }
  159.  
  160. //----------------------------------------------------------------- varname
  161.  
  162. // Remove any "esoteric" portions of a vraible name (such as a leading '$')
  163. //
  164. inline  static  const char *
  165. varname(const char * name, char skip)
  166. {
  167.    return  ((*name == skip) && (*(name + 1))) ? (name + 1): name ;
  168. }
  169.  
  170. //----------------------------------------------------------------- BourneShell
  171.  
  172. const char * BourneShell::NAME = "sh" ;
  173.  
  174. BourneShell::BourneShell(void)
  175. {
  176. }
  177.  
  178. BourneShell::~BourneShell(void)
  179. {
  180. }
  181.  
  182. const char *
  183. BourneShell::name(void) const
  184. {
  185.    return  BourneShell::NAME ;
  186. }
  187.  
  188. void
  189. BourneShell::unset_args(const char *) const
  190. {
  191.    cout << "shift $# ;" << endl ;
  192. }
  193.  
  194. int
  195. BourneShell::is_positionals(const char * name) const
  196. {
  197.    name = varname(name, '$');
  198.    return  ((::strcmp(name, "--") == 0) || (::strcmp(name, "-") == 0) ||
  199.             (::strcmp(name, "@") == 0)  || (::strcmp(name, "*") == 0)) ;
  200. }
  201.  
  202. void
  203. BourneShell::set(const ShellVariable & variable) const
  204. {
  205.    const char * name = varname(variable.name(), '$');
  206.    if (is_positionals(name)) {
  207.       cout << "set -- '" ;
  208.    } else {
  209.       cout << name << "='" ;
  210.    }
  211.    escape_value(variable.value());
  212.    cout << "';" << endl ;
  213. }
  214.  
  215. void
  216. BourneShell::set(const ShellArray & array, int variant) const
  217. {
  218.    int  ndx;
  219.    const char * name = varname(array.name(), '$');
  220.  
  221.    if (is_positionals(name)) {
  222.       // set -- 'arg1' 'arg2' ...
  223.       cout << "set -- ";
  224.       for (ndx = 0 ; ndx < array.count() ; ndx++) {
  225.          if (ndx)  cout << ' ' ;
  226.          cout << '\'' ;
  227.          escape_value(array[ndx]);
  228.          cout << '\'' ;
  229.       }
  230.       cout << ';' << endl ;
  231.    } else if (variant) {
  232.       // argname_count=N
  233.       // argname1='arg1'
  234.       //   ...
  235.       // argnameN='argN'
  236.       cout << name << "_count=" << array.count() << ';' << endl ;
  237.       for (ndx = 0 ; ndx < array.count() ; ndx++) {
  238.          cout << name << (ndx + 1) << "='";
  239.          escape_value(array[ndx]);
  240.          cout << "';" << endl ;
  241.       }
  242.    } else {
  243.       // argname='arg1 arg2 ...'
  244.       cout << name << "='";
  245.       for (ndx = 0 ; ndx < array.count() ; ndx++) {
  246.          if (ndx)  cout << ' ' ;
  247.          escape_value(array[ndx]);
  248.       }
  249.       cout << "';" << endl ;
  250.    }
  251. }
  252.  
  253. void
  254. BourneShell::escape_value(const char * value) const
  255. {
  256.    for ( ; *value ; value++) {
  257.       switch (*value) {
  258.       case '\'' :
  259.          cout << "'\\''" ;
  260.          break ;
  261.  
  262.       case '\\' :
  263.       case '\b' :
  264.       case '\r' :
  265.       case '\v' :
  266.       case '\f' :
  267.          cout << '\\' ;    // fall thru to default case
  268.       default :
  269.          cout << char(*value) ;
  270.       }
  271.    } //for
  272. }
  273.  
  274. //------------------------------------------------------------------- KornShell
  275.  
  276. const char * KornShell::NAME = "ksh" ;
  277.  
  278. KornShell::KornShell(void)
  279. {
  280. }
  281.  
  282. KornShell::~KornShell(void)
  283. {
  284. }
  285.  
  286. const char *
  287. KornShell::name(void) const
  288. {
  289.    return  KornShell::NAME ;
  290. }
  291.  
  292. void
  293. KornShell::unset_args(const char *) const
  294. {
  295.    cout << "set -- ;" << endl ;
  296. }
  297.  
  298. void
  299. KornShell::set(const ShellVariable & variable) const
  300. {
  301.    BourneShell::set(variable);
  302. } 
  303.  
  304. void
  305. KornShell::set(const ShellArray & array, int variant) const
  306. {
  307.    const char * name = varname(array.name(), '$');
  308.    if (is_positionals(name)) {
  309.       cout << "set -- " ;
  310.    } else {
  311.       cout << "set " << (variant ? '+' : '-') << "A " << name << ' ' ;
  312.    }
  313.    for (int  ndx = 0 ; ndx < array.count() ; ndx++) {
  314.       if (ndx)  cout << ' ' ;
  315.       cout << '\'' ;
  316.       escape_value(array[ndx]);
  317.       cout << '\'' ;
  318.    }
  319.    cout << ';' << endl ;
  320. }
  321.  
  322. //------------------------------------------------------------ BourneAgainShell
  323.  
  324. const char * BourneAgainShell::NAME = "bash" ;
  325.  
  326. BourneAgainShell::BourneAgainShell(void)
  327. {
  328. }
  329.  
  330. BourneAgainShell::~BourneAgainShell(void)
  331. {
  332. }
  333.  
  334. const char *
  335. BourneAgainShell::name(void) const
  336. {
  337.    return  BourneAgainShell::NAME ;
  338. }
  339.  
  340. void
  341. BourneAgainShell::set(const ShellVariable & variable) const
  342. {
  343.    BourneShell::set(variable);
  344. } 
  345.  
  346. void
  347. BourneAgainShell::set(const ShellArray & array, int variant) const
  348. {
  349.    BourneShell::set(array, variant);
  350. }
  351.  
  352. //---------------------------------------------------------------------- CShell
  353.  
  354. const char * CShell::NAME = "csh" ;
  355.  
  356. CShell::CShell(void)
  357. {
  358. }
  359.  
  360. CShell::~CShell(void)
  361. {
  362. }
  363.  
  364. const char *
  365. CShell::name(void) const
  366. {
  367.    return  CShell::NAME ;
  368. }
  369.  
  370. void
  371. CShell::unset_args(const char *) const
  372. {
  373.    cout << "set argv=();" << endl ;
  374. }
  375.  
  376. int
  377. CShell::is_positionals(const char * name) const
  378. {
  379.    name = varname(name, '$');
  380.    return  (::strcmp(name, "argv") == 0);
  381. }
  382.  
  383. void
  384. CShell::set(const ShellVariable & variable) const
  385. {
  386.    const char * name = varname(variable.name(), '$');
  387.    int  posl = is_positionals(name);
  388.    cout << "set " << name << '=' ;
  389.    if (posl)  cout << '(' ;
  390.    cout << '\'' ;
  391.    escape_value(variable.value());
  392.    cout << '\'' ;
  393.    if (posl)  cout << ')' ;
  394.    cout << ';' << endl ;;
  395. }
  396.  
  397. void
  398. CShell::set(const ShellArray & array, int ) const
  399. {
  400.    cout << "set " << varname(array.name(), '$') << "=(" ;
  401.    for (int  ndx = 0 ; ndx < array.count() ; ndx++) {
  402.       if (ndx)  cout << ' ' ;
  403.       cout << '\'' ;
  404.       escape_value(array[ndx]);
  405.       cout << '\'' ;
  406.    }
  407.    cout << ");" << endl ;
  408. }
  409.  
  410. void
  411. CShell::escape_value(const char * value) const
  412. {
  413.    for ( ; *value ; value++) {
  414.       switch (*value) {
  415.       case '\'' :
  416.          cout << "'\\''" ;
  417.          break ;
  418.  
  419.       case '!' :
  420.       case '\n' :
  421.       case '\b' :
  422.       case '\r' :
  423.       case '\v' :
  424.       case '\f' :
  425.          cout << '\\' ;    // fall thru to default case
  426.       default :
  427.          cout << char(*value) ;
  428.       }
  429.    } //for
  430. }
  431.  
  432. //---------------------------------------------------------------------- ZShell
  433.  
  434. const char * ZShell::NAME = "zsh" ;
  435.  
  436. ZShell::ZShell(void)
  437. {
  438. }
  439.  
  440. ZShell::~ZShell(void)
  441. {
  442. }
  443.  
  444. const char *
  445. ZShell::name(void) const
  446. {
  447.    return  ZShell::NAME ;
  448. }
  449.  
  450. void
  451. ZShell::unset_args(const char *) const
  452. {
  453.    cout << "argv=();" << endl ;
  454. }
  455.  
  456. int
  457. ZShell::is_positionals(const char * name) const
  458. {
  459.    name = varname(name, '$');
  460.    return  ((::strcmp(name, "--") == 0) || (::strcmp(name, "-") == 0) ||
  461.             (::strcmp(name, "@") == 0)  || (::strcmp(name, "*") == 0) ||
  462.             (::strcmp(name, "argv") == 0));
  463. }
  464.  
  465. void
  466. ZShell::set(const ShellVariable & variable) const
  467. {
  468.    const char * name = varname(variable.name(), '$');
  469.    int  posl = is_positionals(name);
  470.    cout << name << '=' ;
  471.    if (posl)  cout << '(' ;
  472.    cout << '\'' ;
  473.    escape_value(variable.value());
  474.    cout << '\'' ;
  475.    if (posl)  cout << ')' ;
  476.    cout << ';' << endl ;;
  477. }
  478.  
  479. void
  480. ZShell::set(const ShellArray & array, int ) const
  481. {
  482.    cout << varname(array.name(), '$') << "=(" ;
  483.    for (int  ndx = 0 ; ndx < array.count() ; ndx++) {
  484.       if (ndx)  cout << ' ' ;
  485.       cout << '\'' ;
  486.       escape_value(array[ndx]);
  487.       cout << '\'' ;
  488.    }
  489.    cout << ");" << endl ;
  490. }
  491.  
  492. void
  493. ZShell::escape_value(const char * value) const
  494. {
  495.    for ( ; *value ; value++) {
  496.       switch (*value) {
  497.       case '\'' :
  498.          cout << "'\\''" ;
  499.          break ;
  500.  
  501.       case '!' :
  502.       case '\\' :
  503.       case '\b' :
  504.       case '\r' :
  505.       case '\v' :
  506.       case '\f' :
  507.          cout << '\\' ;    // fall thru to default case
  508.       default :
  509.          cout << char(*value) ;
  510.       }
  511.    } //for
  512. }
  513.  
  514. //------------------------------------------------------------------ Plan9Shell
  515.  
  516. const char * Plan9Shell::NAME = "rc" ;
  517.  
  518. Plan9Shell::Plan9Shell(void)
  519. {
  520. }
  521.  
  522. Plan9Shell::~Plan9Shell(void)
  523. {
  524. }
  525.  
  526. const char *
  527. Plan9Shell::name(void) const
  528. {
  529.    return  Plan9Shell::NAME ;
  530. }
  531.  
  532. void
  533. Plan9Shell::unset_args(const char *) const
  534. {
  535.    cout << "*=();" << endl ;
  536. }
  537.  
  538. int
  539. Plan9Shell::is_positionals(const char * name) const
  540. {
  541.    name = varname(name, '$');
  542.    return  (::strcmp(name, "*") == 0);
  543. }
  544.  
  545. void
  546. Plan9Shell::set(const ShellVariable & variable) const
  547. {
  548.    const char * name = varname(variable.name(), '$');
  549.    int  posl = is_positionals(name);
  550.    cout << name << '=' ;
  551.    if (posl)  cout << '(' ;
  552.    cout << '\'' ;
  553.    escape_value(variable.value());
  554.    cout << '\'' ;
  555.    if (posl)  cout << ')' ;
  556.    cout << ';' << endl ;;
  557. }
  558.  
  559. void
  560. Plan9Shell::set(const ShellArray & array, int ) const
  561. {
  562.    cout << varname(array.name(), '$') << "=(" ;
  563.    for (int  ndx = 0 ; ndx < array.count() ; ndx++) {
  564.       if (ndx)  cout << ' ' ;
  565.       cout << '\'' ;
  566.       escape_value(array[ndx]);
  567.       cout << '\'' ;
  568.    }
  569.    cout << ");" << endl ;
  570. }
  571.  
  572. void
  573. Plan9Shell::escape_value(const char * value) const
  574. {
  575.    for ( ; *value ; value++) {
  576.       switch (*value) {
  577.       case '\'' :
  578.          cout << "''" ;
  579.          break ;
  580.  
  581.       case '\\' :
  582.       case '\b' :
  583.       case '\r' :
  584.       case '\v' :
  585.       case '\f' :
  586.          cout << '\\' ;    // fall thru to default case
  587.       default :
  588.          cout << char(*value) ;
  589.       }
  590.    } //for
  591. }
  592.  
  593. //------------------------------------------------------------------- PerlShell
  594.  
  595. const char * PerlShell::NAME = "perl" ;
  596.  
  597. PerlShell::PerlShell(void)
  598. {
  599.    static const char perl_true[]  = "1" ;
  600.    static const char perl_false[] = "0" ;
  601.  
  602.       // use different defaults for TRUE and FALSE
  603.    ShellCmdArgBool::True(perl_true);
  604.    ShellCmdArgBool::False(perl_false);
  605. }
  606.  
  607. PerlShell::~PerlShell(void)
  608. {
  609. }
  610.  
  611. const char *
  612. PerlShell::name(void) const
  613. {
  614.    return  PerlShell::NAME ;
  615. }
  616.  
  617. void
  618. PerlShell::unset_args(const char *) const
  619. {
  620.    cout << "@ARGV = ();" << endl ;
  621. }
  622.  
  623. int
  624. PerlShell::is_positionals(const char * name) const
  625. {
  626.    name = varname(name, '@');
  627.    return  (::strcmp(name, "ARGV") == 0);
  628. }
  629.  
  630. void
  631. PerlShell::set(const ShellVariable & variable) const
  632. {
  633.    const char * name = varname(variable.name(), '$');
  634.    int array = (*name == '@') ;
  635.    cout << (array ? "" : "$") << name << " = " ;
  636.    if (array)  cout << '(' ;
  637.    cout << '\'' ;
  638.    escape_value(variable.value());
  639.    cout << '\'' ;
  640.    if (array)  cout << ')' ;
  641.    cout << ';' << endl ;;
  642. }
  643.  
  644. void
  645. PerlShell::set(const ShellArray & array, int ) const
  646. {
  647.    const char * name = varname(array.name(), '@');
  648.    int scalar = (*name == '$') ;
  649.    cout << (scalar ? "" : "@") << name << " = " ;
  650.    cout << (scalar ? '\'' : '(') ;
  651.    for (int  ndx = 0 ; ndx < array.count() ; ndx++) {
  652.       if (ndx)  cout << (scalar ? " " : ", ") ;
  653.       if (! scalar)  cout << '\'' ;
  654.       escape_value(array[ndx]);
  655.       if (! scalar)  cout << '\'' ;
  656.    }
  657.    cout << (scalar ? '\'' : ')') ;
  658.    cout << ";" << endl ;
  659. }
  660.  
  661. void
  662. PerlShell::escape_value(const char * value) const
  663. {
  664.    for ( ; *value ; value++) {
  665.       switch (*value) {
  666.       case '\t' :  cout << "\\t" ; break ;
  667.       case '\n' :  cout << "\\n" ; break ;
  668.       case '\b' :  cout << "\\b" ; break ;
  669.       case '\r' :  cout << "\\r" ; break ;
  670.       case '\v' :  cout << "\\v" ; break ;
  671.       case '\f' :  cout << "\\f" ; break ;
  672.  
  673.       case '\'' :
  674.       case '\\' :
  675.          cout << "\\" ;    // fall thru to default
  676.       default :
  677.          cout << char(*value) ;
  678.       }
  679.    } //for
  680. }
  681.  
  682. //------------------------------------------------------------------- TclShell
  683.  
  684. const char * TclShell::NAME = "tcl" ;
  685.  
  686. TclShell::TclShell(void)
  687. {
  688.    static const char tcl_true[]  = "1" ;
  689.    static const char tcl_false[] = "0" ;
  690.  
  691.       // use different defaults for TRUE and FALSE
  692.    ShellCmdArgBool::True(tcl_true);
  693.    ShellCmdArgBool::False(tcl_false);
  694. }
  695.  
  696. TclShell::~TclShell(void)
  697. {
  698. }
  699.  
  700. const char *
  701. TclShell::name(void) const
  702. {
  703.    return  TclShell::NAME ;
  704. }
  705.  
  706. void
  707. TclShell::unset_args(const char * name) const
  708. {
  709.    cout << "set " << varname(name, '$') << " {};" << endl ;
  710. }
  711.  
  712. int
  713. TclShell::is_positionals(const char * name) const
  714. {
  715.    name = varname(name, '$');
  716.    return  ((::strcmp(name, "argv") == 0) || (::strcmp(name, "args") == 0));
  717. }
  718.  
  719. void
  720. TclShell::set(const ShellVariable & variable) const
  721. {
  722.    const char * name = varname(variable.name(), '$');
  723.    cout << "set " << name << ' ' ;
  724.    cout << '"' ;
  725.    escape_value(variable.value());
  726.    cout << '"' ;
  727.    cout << ';' << endl ;;
  728. }
  729.  
  730. void
  731. TclShell::set(const ShellArray & array, int ) const
  732. {
  733.    const char * name = varname(array.name(), '@');
  734.    int scalar = (*name == '$') ;
  735.    cout << "set " << name << " [ list " ;
  736.    for (int  ndx = 0 ; ndx < array.count() ; ndx++) {
  737.       if (ndx)  cout << ' ' ;
  738.       cout << '"' ;
  739.       escape_value(array[ndx]);
  740.       cout << '"' ;
  741.    }
  742.    cout << " ]" ;
  743.    cout << ";" << endl ;
  744. }
  745.  
  746. void
  747. TclShell::escape_value(const char * value) const
  748. {
  749.    for ( ; *value ; value++) {
  750.       switch (*value) {
  751.       case '\t' :  cout << "\\t" ; break ;
  752.       case '\n' :  cout << "\\n" ; break ;
  753.       case '\b' :  cout << "\\b" ; break ;
  754.       case '\r' :  cout << "\\r" ; break ;
  755.       case '\v' :  cout << "\\v" ; break ;
  756.       case '\f' :  cout << "\\f" ; break ;
  757.  
  758.       case '\'' :
  759.       case '\\' :
  760.       case '{' :
  761.       case '}' :
  762.       case '[' :
  763.       case ']' :
  764.       case '$' :
  765.       case ';' :
  766.       case '"' :
  767.          cout << "\\" ;    // fall thru to default
  768.       default :
  769.          cout << char(*value) ;
  770.       }
  771.    } //for
  772. }
  773.  
  774.