source: trunk/essentials/app-shells/bash/eval.c@ 3258

/* eval.c -- reading and evaluating commands. */

/* Copyright (C) 1996 Free Software Foundation, Inc.

   This file is part of GNU Bash, the Bourne Again SHell.

   Bash is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   Bash is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
   License for more details.

   You should have received a copy of the GNU General Public License
   along with Bash; see the file COPYING.  If not, write to the Free
   Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */

#include "config.h"

#if defined (HAVE_UNISTD_H)
#  ifdef _MINIX
#    include <sys/types.h>
#  endif
#  include <unistd.h>
#endif

#include "bashansi.h"
#include <stdio.h>

#include "bashintl.h"

#include "shell.h"
#include "flags.h"
#include "trap.h"

#include "builtins/common.h"

#include "input.h"
#include "execute_cmd.h"

#if defined (HISTORY)
#  include "bashhist.h"
#endif

extern int EOF_reached;
extern int indirection_level;
extern int posixly_correct;
extern int subshell_environment, running_under_emacs;
extern int last_command_exit_value, stdin_redir;
extern int need_here_doc;
extern int current_command_number, current_command_line_count, line_number;
extern int expand_aliases;

static void send_pwd_to_eterm __P((void));
static sighandler alrm_catcher __P((int));

/* Read and execute commands until EOF is reached.  This assumes that
   the input source has already been initialized. */
int
reader_loop ()
{
  int our_indirection_level;
  COMMAND * volatile current_command;

  current_command = (COMMAND *)NULL;
  USE_VAR(current_command);

  our_indirection_level = ++indirection_level;

  while (EOF_Reached == 0)
    {
      int code;

      code = setjmp (top_level);

#if defined (PROCESS_SUBSTITUTION)
      unlink_fifo_list ();
#endif /* PROCESS_SUBSTITUTION */

      if (interactive_shell && signal_is_ignored (SIGINT) == 0)
        set_signal_handler (SIGINT, sigint_sighandler);

      if (code != NOT_JUMPED)
        {
          indirection_level = our_indirection_level;

          switch (code)
            {
              /* Some kind of throw to top_level has occured. */
            case FORCE_EOF:
            case ERREXIT:
            case EXITPROG:
              current_command = (COMMAND *)NULL;
              if (exit_immediately_on_error)
                variable_context = 0;   /* not in a function */
              EOF_Reached = EOF;
              goto exec_done;

            case DISCARD:
              last_command_exit_value = 1;
              if (subshell_environment)
                {
                  current_command = (COMMAND *)NULL;
                  EOF_Reached = EOF;
                  goto exec_done;
                }
              /* Obstack free command elements, etc. */
              if (current_command)
                {
                  dispose_command (current_command);
                  current_command = (COMMAND *)NULL;
                }
              break;

            default:
              command_error ("reader_loop", CMDERR_BADJUMP, code, 0);
            }
        }

      executing = 0;
      if (temporary_env)
        dispose_used_env_vars ();

#if (defined (ultrix) && defined (mips)) || defined (C_ALLOCA)
      /* Attempt to reclaim memory allocated with alloca (). */
      (void) alloca (0);
#endif

      if (read_command () == 0)
        {
          if (interactive_shell == 0 && read_but_dont_execute)
            {
              last_command_exit_value = EXECUTION_SUCCESS;
              dispose_command (global_command);
              global_command = (COMMAND *)NULL;
            }
          else if (current_command = global_command)
            {
              global_command = (COMMAND *)NULL;
              current_command_number++;

              executing = 1;
              stdin_redir = 0;
              execute_command (current_command);

            exec_done:
              QUIT;

              if (current_command)
                {
                  dispose_command (current_command);
                  current_command = (COMMAND *)NULL;
                }
            }
        }
      else
        {
          /* Parse error, maybe discard rest of stream if not interactive. */
          if (interactive == 0)
            EOF_Reached = EOF;
        }
      if (just_one_command)
        EOF_Reached = EOF;
    }
  indirection_level--;
  return (last_command_exit_value);