home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Mint / Shells / bashsrc.zoo / flags.c < prev    next >
C/C++ Source or Header  |  1991-06-05  |  6KB  |  220 lines
  1. /* flags.c -- Everything about flags except the `set' command.   That
  2.    is in builtins.c */
  3.  
  4. /* Copyright (C) 1987,1989 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU Bash, the Bourne Again SHell.
  7.  
  8. Bash is free software; you can redistribute it and/or modify it under
  9. the terms of the GNU General Public License as published by the Free
  10. Software Foundation; either version 1, or (at your option) any later
  11. version.
  12.  
  13. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License along
  19. with Bash; see the file COPYING.  If not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  21.  
  22. /* Flags hacking. */
  23.  
  24. #define NULL 0x0
  25. #include "flags.h"
  26. #include "config.h"
  27. #include "general.h"
  28. #include "quit.h"
  29.  
  30. /* **************************************************************** */
  31. /*                                    */
  32. /*            The Standard Sh Flags.                */
  33. /*                                    */
  34. /* **************************************************************** */
  35.  
  36. /* Non-zero means automatically mark variables which are modified or created
  37.    as auto export variables. */
  38. int mark_modified_vars = 0;
  39.  
  40. /* Non-zero means exit immediately if a command exits with a non-zero
  41.    exit status. */
  42. int exit_immediately_on_error = 0;
  43.  
  44. /* Non-zero means disable filename globbing. */
  45. int disallow_filename_globbing = 0;
  46.  
  47. /* Non-zero means to locate and remember function commands as functions are
  48.    defined.  Function commands are normally located when the function is
  49.    executed. */
  50. int locate_commands_in_functions = 0;
  51.  
  52. /* Non-zero means that all keyword arguments are placed into the environment
  53.    for a command, not just those that appear on the line before the command
  54.    name. */
  55. int place_keywords_in_env = 0;
  56.  
  57. /* Non-zero means read commands, but don't execute tham.  This is useful
  58.    for debugging shell scripts that should do something hairy and possibly
  59.    desctructive. */
  60. int read_but_dont_execute = 0;
  61.  
  62. /* Non-zero means end of file is after one command. */
  63. int just_one_command = 0;
  64.  
  65. /* Non-zero means trying to get the value of $i where $i is undefined
  66.    causes an error, instead of a null substitution. */
  67. int unbound_vars_is_error = 0;
  68.  
  69. /* Non-zero means type out input lines after you read them. */
  70. int echo_input_at_read = 0;
  71.  
  72. /* Non-zero means type out the command definition after reading, but
  73.    before executing. */
  74. int echo_command_at_execute = 0;
  75.  
  76. /* Non-zero means turn off the job control features. */
  77. int jobs_m_flag = 0;
  78.  
  79. /* Non-zero means this shell is interactive, even if running under a
  80.    pipe. */
  81. int forced_interactive = 0;
  82.  
  83. /* **************************************************************** */
  84. /*                                    */
  85. /*             Non-Standard Flags Follow Here.            */
  86. /*                                    */
  87. /* **************************************************************** */
  88.  
  89.  
  90. /* Non-zero means do lexical scoping in the body of a FOR command. */
  91. int lexical_scoping = 0;
  92.  
  93. /* Non-zero means no such thing as invisible variables. */
  94. int no_invisible_vars = 0;
  95.  
  96. /* Non-zero means don't look up or remember command names in a hash table, */
  97. int hashing_disabled = 0;
  98.  
  99. /* Non-zero means that we are doing history expansion.  The default.
  100.    This means !22 gets the 22nd line of history. */
  101. int history_expansion = 1;
  102.  
  103. /* **************************************************************** */
  104. /*                                    */
  105. /*            The Flags ALIST.                */
  106. /*                                    */
  107. /* **************************************************************** */
  108.  
  109. struct flags_alist shell_flags[] = {
  110.  
  111.   /* Standard sh flags. */
  112.   {"a", &mark_modified_vars},
  113.   {"e", &exit_immediately_on_error},
  114.   {"f", &disallow_filename_globbing},
  115.   {"h", &locate_commands_in_functions},    /* Oh, yeah, good mnemonic. */
  116.   {"i", &forced_interactive},
  117.   {"k", &place_keywords_in_env},
  118.   {"n", &read_but_dont_execute},
  119.   {"t", &just_one_command},
  120.   {"u", &unbound_vars_is_error},
  121.   {"v", &echo_input_at_read},
  122.   {"x", &echo_command_at_execute},
  123.  
  124. #ifdef JOB_CONTROL
  125.   {"m", &jobs_m_flag},
  126. #endif
  127.  
  128.   /* New flags that control non-standard things. */
  129.   {"l", &lexical_scoping},
  130.   {"I", &no_invisible_vars},
  131.  
  132.   /* I want `h', but locate_commands_in_functions has it.  Great. */
  133.   {"d", &hashing_disabled},
  134.  
  135.   /* Once again, we don't have the right mnemonic. */
  136.   {"o", &history_expansion},
  137.  
  138.   {(char *)NULL, (int *)NULL}
  139. };
  140.  
  141.  
  142. int *
  143. find_flag (name)
  144.      char *name;
  145. {
  146.   int i = 0;
  147.   while (shell_flags[i].name) {
  148.     if (strcmp (shell_flags[i].name, name) == 0)
  149.       return (shell_flags[i].value);
  150.     i++;
  151.   }
  152.   return ((int *)FLAG_ERROR);
  153. }
  154.  
  155. /* Change the state of a flag, and return it's original value, or return
  156.    FLAG_ERROR if there is no flag called NAME.  ON_OR_OFF should be one
  157.    of FLAG_ON or FLAG_OFF. */
  158.  
  159. /* With FLAG being a character. */
  160. change_flag_char (flag, on_or_off)
  161.      int flag;
  162.      int on_or_off;
  163. {
  164.   char name[2];
  165.   name[0] = flag; name[1] = '\0';
  166.   return (change_flag (name, on_or_off));
  167. }
  168.  
  169. /* With FLAG being a string. */
  170. change_flag (flag, on_or_off)
  171.   char *flag;
  172.   int on_or_off;
  173. {
  174.   int *value = find_flag (flag);
  175.   int old_value;
  176.  
  177.   if (value == (int *)FLAG_ERROR) return (FLAG_ERROR);
  178.   else old_value = *value;
  179.  
  180.   if (on_or_off == FLAG_ON)
  181.     *value = 1;
  182.   else
  183.     {
  184.       if (on_or_off == FLAG_OFF)
  185.     *value = 0;
  186.       else
  187.     return (FLAG_ERROR);
  188.     }
  189.  
  190. #ifdef JOB_CONTROL
  191.   /* Special hack for the -m flag. */
  192.   if (value == &jobs_m_flag)
  193.     {
  194.       extern set_job_control ();
  195.       set_job_control (on_or_off == '-');
  196.     }
  197. #endif  /* JOB_CONTROL */
  198.     
  199.   return (old_value);
  200. }
  201.  
  202. /* Return a string which is the names of all the currently
  203.    set shell flags. */
  204. char *
  205. which_set_flags ()
  206. {
  207.   char *temp =
  208.     (char *)xmalloc (1 + sizeof (shell_flags) / (2 * sizeof (char *)));
  209.  
  210.   int index, string_index = 0;
  211.  
  212.   for (index = 0; shell_flags[index].name; index++)
  213.     if (*(shell_flags[index].value))
  214.       temp[string_index++] = *(shell_flags[index].name);
  215.  
  216.   temp[string_index] = '\0';
  217.   return (temp);
  218. }
  219.  
  220.