source: patches/bash-4.0-branch_update-4.patch @ e6b4db2

clfs-1.2clfs-2.1clfs-3.0.0-systemdclfs-3.0.0-sysvinitsystemdsysvinit
Last change on this file since e6b4db2 was e6b4db2, checked in by Jim Gifford <clfs@…>, 13 years ago

Updated Bash Branch Update Patch to -4

  • Property mode set to 100644
File size: 25.0 KB
  • arrayfunc.c

    Submitted By: Jim Gifford (jim at cross-lfs dot org)
    Date: 04-09-2009
    Initial Package Version: 4.0
    Origin: Upstream
    Upstream Status: Applied
    Description: Contains all upstream patches up to 4.0-017
    
    diff -Naur bash-4.0.orig/arrayfunc.c bash-4.0/arrayfunc.c
    old new  
    604604    }
    605605}
    606606
    607 /* This function assumes s[i] == '['; returns with s[ret] == ']' if
    608    an array subscript is correctly parsed. */
    609 int
    610 skipsubscript (s, i)
    611      const char *s;
    612      int i;
    613 {
    614   int count, c;
    615 #if defined (HANDLE_MULTIBYTE)
    616   mbstate_t state, state_bak;
    617   size_t slength, mblength;
    618 #endif
    619 
    620 #if defined (HANDLE_MULTIBYTE)
    621   memset (&state, '\0', sizeof (mbstate_t));
    622   slength = strlen (s + i);
    623 #endif
    624  
    625   count = 1;
    626   while (count)
    627     {
    628       /* Advance one (possibly multibyte) character in S starting at I. */
    629 #if defined (HANDLE_MULTIBYTE)
    630       if (MB_CUR_MAX > 1)
    631         {
    632           state_bak = state;
    633           mblength = mbrlen (s + i, slength, &state);
    634 
    635           if (MB_INVALIDCH (mblength))
    636             {
    637               state = state_bak;
    638               i++;
    639               slength--;
    640             }
    641           else if (MB_NULLWCH (mblength))
    642             return i;
    643           else
    644             {
    645               i += mblength;
    646               slength -= mblength;
    647             }
    648         }
    649       else
    650 #endif
    651       ++i;
    652 
    653       c = s[i];
    654 
    655       if (c == 0)
    656         break;
    657       else if (c == '[')
    658         count++;
    659       else if (c == ']')
    660         count--;
    661     }
    662 
    663   return i;
    664 }
     607/* skipsubscript moved to subst.c to use private functions. 2009/02/24. */
    665608
    666609/* This function is called with SUB pointing to just after the beginning
    667610   `[' of an array subscript and removes the array element to which SUB
  • builtins/declare.def

    diff -Naur bash-4.0.orig/builtins/declare.def bash-4.0/builtins/declare.def
    old new  
    295295      subscript_start = (char *)NULL;
    296296      if (t = strchr (name, '['))       /* ] */
    297297        {
     298          /* If offset != 0 we have already validated any array reference */
     299          if (offset == 0 && valid_array_reference (name) == 0)
     300            {
     301              sh_invalidid (name);
     302              assign_error++;
     303              NEXT_VARIABLE ();
     304            }
    298305          subscript_start = t;
    299306          *t = '\0';
    300307          making_array_special = 1;
     
    484491            }
    485492          /* declare -a name[[n]] or declare name[n] makes name an indexed
    486493             array variable. */
    487           else if ((making_array_special || (flags_on & att_array)) && array_p (var) == 0)
     494          else if ((making_array_special || (flags_on & att_array)) && array_p (var) == 0 && assoc_p (var) == 0)
    488495            var = convert_var_to_array (var);
    489496#endif /* ARRAY_VARS */
    490497
  • builtins/exit.def

    diff -Naur bash-4.0.orig/builtins/exit.def bash-4.0/builtins/exit.def
    old new  
    113113      for (i = stopmsg = 0; i < js.j_jobslots; i++)
    114114        if (jobs[i] && STOPPED (i))
    115115          stopmsg = JSTOPPED;
    116         else if (check_jobs_at_exit && stopmsg == 0 && RUNNING (i))
     116        else if (check_jobs_at_exit && stopmsg == 0 && jobs[i] && RUNNING (i))
    117117          stopmsg = JRUNNING;
    118118
    119119      if (stopmsg == JSTOPPED)
  • builtins/fc.def

    diff -Naur bash-4.0.orig/builtins/fc.def bash-4.0/builtins/fc.def
    old new  
    8888extern int current_command_line_count;
    8989extern int literal_history;
    9090extern int posixly_correct;
     91extern int subshell_environment, interactive_shell;
    9192
    9293extern int unlink __P((const char *));
    9394
     
    172173  register int i;
    173174  register char *sep;
    174175  int numbering, reverse, listing, execute;
    175   int histbeg, histend, last_hist, retval, opt;
     176  int histbeg, histend, last_hist, retval, opt, rh;
    176177  FILE *stream;
    177178  REPL *rlist, *rl;
    178179  char *ename, *command, *newcom, *fcedit;
     
    275276
    276277      fprintf (stderr, "%s\n", command);
    277278      fc_replhist (command);    /* replace `fc -s' with command */
     279      /* Posix says that the re-executed commands should be entered into the
     280         history. */
    278281      return (parse_and_execute (command, "fc", SEVAL_NOHIST));
    279282    }
    280283
     
    293296     line was actually added (HISTIGNORE may have caused it to not be),
    294297     so we check hist_last_line_added. */
    295298
    296   last_hist = i - remember_on_history - hist_last_line_added;
     299  /* Even though command substitution through parse_and_execute turns off
     300     remember_on_history, command substitution in a shell when set -o history
     301     has been enabled (interactive or not) should use it in the last_hist
     302     calculation as if it were on. */
     303  rh = remember_on_history || ((subshell_environment & SUBSHELL_COMSUB) && enable_history_list);
     304  last_hist = i - rh - hist_last_line_added;
    297305
    298306  if (list)
    299307    {
     
    456464     char *command;
    457465     HIST_ENTRY **hlist;
    458466{
    459   int sign, n, clen;
     467  int sign, n, clen, rh;
    460468  register int i, j;
    461469  register char *s;
    462470
     
    472480     line was actually added (HISTIGNORE may have caused it to not be),
    473481     so we check hist_last_line_added.  This needs to agree with the
    474482     calculation of last_hist in fc_builtin above. */
    475   i -= remember_on_history + hist_last_line_added;
     483  /* Even though command substitution through parse_and_execute turns off
     484     remember_on_history, command substitution in a shell when set -o history
     485     has been enabled (interactive or not) should use it in the last_hist
     486     calculation as if it were on. */
     487  rh = remember_on_history || ((subshell_environment & SUBSHELL_COMSUB) && enable_history_list);
     488  i -= rh + hist_last_line_added;
    476489
    477490  /* No specification defaults to most recent command. */
    478491  if (command == NULL)
  • builtins/read.def

    diff -Naur bash-4.0.orig/builtins/read.def bash-4.0/builtins/read.def
    old new  
    369369      code = setjmp (alrmbuf);
    370370      if (code)
    371371        {
    372 #if 0
     372          /* Tricky.  The top of the unwind-protect stack is the free of
     373             input_string.  We want to run all the rest and use input_string,
     374             so we have to remove it from the stack. */
     375          remove_unwind_protect ();
    373376          run_unwind_frame ("read_builtin");
    374           return (EXECUTION_FAILURE);
    375 #else
    376377          input_string[i] = '\0';       /* make sure it's terminated */
    377           retval = 128+SIGALRM;;
     378          retval = 128+SIGALRM;
    378379          goto assign_vars;
    379 #endif
    380380        }
    381381      old_alrm = set_signal_handler (SIGALRM, sigalrm);
    382382      add_unwind_protect (reset_alarm, (char *)NULL);
  • execute_cmd.c

    diff -Naur bash-4.0.orig/execute_cmd.c bash-4.0/execute_cmd.c
    old new  
    568568
    569569      /* Fork a subshell, turn off the subshell bit, turn off job
    570570         control and call execute_command () on the command again. */
     571      line_number_for_err_trap = line_number;
    571572      paren_pid = make_child (savestring (make_command_string (command)),
    572573                              asynchronous);
    573574      if (paren_pid == 0)
     
    610611              if (user_subshell && was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
    611612                {
    612613                  last_command_exit_value = exec_result;
     614                  save_line_number = line_number;
     615                  line_number = line_number_for_err_trap;
    613616                  run_error_trap ();
     617                  line_number = save_line_number;
    614618                }
    615619
    616620              if (user_subshell && ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
     
    766770      if (was_error_trap && ignore_return == 0 && invert == 0 && pipe_in == NO_PIPE && pipe_out == NO_PIPE && exec_result != EXECUTION_SUCCESS)
    767771        {
    768772          last_command_exit_value = exec_result;
     773          line_number = line_number_for_err_trap;
    769774          run_error_trap ();
     775          line_number = save_line_number;
    770776        }
    771777
    772778      if (ignore_return == 0 && invert == 0 &&
     
    21052111  REDIRECT *rp;
    21062112  COMMAND *tc, *second;
    21072113  int ignore_return, exec_result, was_error_trap, invert;
     2114  volatile int save_line_number;
    21082115
    21092116  ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
    21102117
     
    21742181      invert = (command->flags & CMD_INVERT_RETURN) != 0;
    21752182      ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
    21762183
     2184      line_number_for_err_trap = line_number;
    21772185      exec_result = execute_pipeline (command, asynchronous, pipe_in, pipe_out, fds_to_close);
    21782186
    21792187      if (was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
    21802188        {
    21812189          last_command_exit_value = exec_result;
     2190          save_line_number = line_number;
     2191          line_number = line_number_for_err_trap;
    21822192          run_error_trap ();
     2193          line_number = save_line_number;
    21832194        }
    21842195
    21852196      if (ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
     
    29302941                  retval = execute_command (clauses->action);
    29312942                }
    29322943              while ((clauses->flags & CASEPAT_FALLTHROUGH) && (clauses = clauses->next));
    2933               if ((clauses->flags & CASEPAT_TESTNEXT) == 0)
     2944              if (clauses == 0 || (clauses->flags & CASEPAT_TESTNEXT) == 0)
    29342945                EXIT_CASE ();
    29352946              else
    29362947                break;
  • parse.y

    diff -Naur bash-4.0.orig/parse.y bash-4.0/parse.y
    old new  
    11221122                          REDIRECTEE rd;
    11231123                          REDIRECT *r;
    11241124
    1125                           tc = $1;
     1125                          tc = $1->type == cm_simple ? (COMMAND *)$1->value.Simple : $1;
    11261126                          rd.dest = 1;
    11271127                          r = make_redirection (2, r_duplicating_output, rd);
    11281128                          if (tc->redirects)
     
    16151615{
    16161616  int *ret;
    16171617
    1618   ret = (int *)xmalloc (3 * sizeof (int));
     1618  ret = (int *)xmalloc (4 * sizeof (int));
    16191619  ret[0] = last_read_token;
    16201620  ret[1] = token_before_that;
    16211621  ret[2] = two_tokens_ago;
     1622  ret[3] = current_token;
    16221623  return ret;
    16231624}
    16241625
     
    16311632  last_read_token = ts[0];
    16321633  token_before_that = ts[1];
    16331634  two_tokens_ago = ts[2];
     1635  current_token = ts[3];
    16341636}
    16351637
    16361638/*
     
    18771879    prompt_again ();
    18781880  ret = read_a_line (remove_quoted_newline);
    18791881#if defined (HISTORY)
    1880   if (remember_on_history && (parser_state & PST_HEREDOC))
     1882  if (ret && remember_on_history && (parser_state & PST_HEREDOC))
    18811883    {
    18821884      /* To make adding the the here-document body right, we need to rely
    18831885         on history_delimiting_chars() returning \n for the first line of
     
    26682670  FREE (word_desc_to_read);
    26692671  word_desc_to_read = (WORD_DESC *)NULL;
    26702672
     2673  current_token = '\n';         /* XXX */
    26712674  last_read_token = '\n';
    26722675  token_to_read = '\n';
    26732676}
     
    29152918#define P_DQUOTE        0x04
    29162919#define P_COMMAND       0x08    /* parsing a command, so look for comments */
    29172920#define P_BACKQUOTE     0x10    /* parsing a backquoted command substitution */
     2921#define P_ARRAYSUB      0x20    /* parsing a [...] array subscript for assignment */
    29182922
    29192923/* Lexical state while parsing a grouping construct or $(...). */
    29202924#define LEX_WASDOL      0x001
     
    29272931#define LEX_INHEREDOC   0x080
    29282932#define LEX_HEREDELIM   0x100           /* reading here-doc delimiter */
    29292933#define LEX_STRIPDOC    0x200           /* <<- strip tabs from here doc delim */
     2934#define LEX_INWORD      0x400
    29302935
    29312936#define COMSUB_META(ch)         ((ch) == ';' || (ch) == '&' || (ch) == '|')
    29322937
     
    31293134              APPEND_NESTRET ();
    31303135              FREE (nestret);
    31313136            }
     3137          else if ((flags & P_ARRAYSUB) && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '['))      /* ) } ] */
     3138            goto parse_dollar_word;
    31323139        }
    31333140      /* Parse an old-style command substitution within double quotes as a
    31343141         single word. */
     
    31453152      else if MBTEST(open != '`' && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '['))     /* ) } ] */
    31463153        /* check for $(), $[], or ${} inside quoted string. */
    31473154        {
     3155parse_dollar_word:
    31483156          if (open == ch)       /* undo previous increment */
    31493157            count--;
    31503158          if (ch == '(')                /* ) */
     
    31793187     int open, close;
    31803188     int *lenp, flags;
    31813189{
    3182   int count, ch, peekc, tflags, lex_rwlen, lex_firstind;
     3190  int count, ch, peekc, tflags, lex_rwlen, lex_wlen, lex_firstind;
    31833191  int nestlen, ttranslen, start_lineno;
    31843192  char *ret, *nestret, *ttrans, *heredelim;
    31853193  int retind, retsize, rflags, hdlen;
     
    32003208  retind = 0;
    32013209
    32023210  start_lineno = line_number;
    3203   lex_rwlen = 0;
     3211  lex_rwlen = lex_wlen = 0;
    32043212
    32053213  heredelim = 0;
    32063214  lex_firstind = -1;
     
    32673275          continue;
    32683276        }
    32693277
     3278      if (tflags & LEX_PASSNEXT)                /* last char was backslash */
     3279        {
     3280/*itrace("parse_comsub:%d: lex_passnext -> 0 ch = `%c' (%d)", line_number, ch, __LINE__);*/
     3281          tflags &= ~LEX_PASSNEXT;
     3282          if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
     3283            {
     3284              if (retind > 0)
     3285                retind--;       /* swallow previously-added backslash */
     3286              continue;
     3287            }
     3288
     3289          RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
     3290          if MBTEST(ch == CTLESC || ch == CTLNUL)
     3291            ret[retind++] = CTLESC;
     3292          ret[retind++] = ch;
     3293          continue;
     3294        }
     3295
     3296      /* If this is a shell break character, we are not in a word.  If not,
     3297         we either start or continue a word. */
     3298      if MBTEST(shellbreak (ch))
     3299        {
     3300          tflags &= ~LEX_INWORD;
     3301/*itrace("parse_comsub:%d: lex_inword -> 0 ch = `%c' (%d)", line_number, ch, __LINE__);*/
     3302        }
     3303      else
     3304        {
     3305          if (tflags & LEX_INWORD)
     3306            {
     3307              lex_wlen++;
     3308/*itrace("parse_comsub:%d: lex_inword == 1 ch = `%c' lex_wlen = %d (%d)", line_number, ch, lex_wlen, __LINE__);*/
     3309            }         
     3310          else
     3311            {
     3312/*itrace("parse_comsub:%d: lex_inword -> 1 ch = `%c' (%d)", line_number, ch, __LINE__);*/
     3313              tflags |= LEX_INWORD;
     3314              lex_wlen = 0;
     3315            }
     3316        }
     3317
    32703318      /* Skip whitespace */
    32713319      if MBTEST(shellblank (ch) && lex_rwlen == 0)
    32723320        {
     
    33643412}               
    33653413              tflags &= ~LEX_RESWDOK;
    33663414            }
    3367           else if (shellbreak (ch) == 0)
     3415          else if MBTEST((tflags & LEX_CKCOMMENT) && ch == '#' && (lex_rwlen == 0 || ((tflags & LEX_INWORD) && lex_wlen == 0)))
     3416            ;   /* don't modify LEX_RESWDOK if we're starting a comment */
     3417          else if MBTEST((tflags & LEX_INCASE) && ch != '\n')
     3418            /* If we can read a reserved word and we're in case, we're at the
     3419               point where we can read a new pattern list or an esac.  We
     3420               handle the esac case above.  If we read a newline, we want to
     3421               leave LEX_RESWDOK alone.  If we read anything else, we want to
     3422               turn off LEX_RESWDOK, since we're going to read a pattern list. */
    33683423{
    3369               tflags &= ~LEX_RESWDOK;
     3424            tflags &= ~LEX_RESWDOK;
     3425/*itrace("parse_comsub:%d: lex_incase == 1 found `%c', lex_reswordok -> 0", line_number, ch);*/
     3426}
     3427          else if MBTEST(shellbreak (ch) == 0)
     3428{
     3429            tflags &= ~LEX_RESWDOK;
    33703430/*itrace("parse_comsub:%d: found `%c', lex_reswordok -> 0", line_number, ch);*/
    33713431}
    33723432        }
     
    33943454                }
    33953455              else
    33963456                shell_ungetc (peekc);
    3397               tflags |= LEX_HEREDELIM;
    3398               lex_firstind = -1;
     3457              if (peekc != '<')
     3458                {
     3459                  tflags |= LEX_HEREDELIM;
     3460                  lex_firstind = -1;
     3461                }
    33993462              continue;
    34003463            }
    34013464          else
    3402             ch = peekc;         /* fall through and continue XXX - this skips comments if peekc == '#' */
     3465            ch = peekc;         /* fall through and continue XXX */
    34033466        }
    3404       /* Not exactly right yet, should handle shell metacharacters, too.  If
    3405          any changes are made to this test, make analogous changes to subst.c:
    3406          extract_delimited_string(). */
    3407       else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || shellblank (ret[retind - 1])))
     3467      else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (((tflags & LEX_RESWDOK) && lex_rwlen == 0) || ((tflags & LEX_INWORD) && lex_wlen == 0)))
     3468{
     3469/*itrace("parse_comsub:%d: lex_incomment -> 1 (%d)", line_number, __LINE__);*/
    34083470        tflags |= LEX_INCOMMENT;
     3471}
    34093472
    3410       if (tflags & LEX_PASSNEXT)                /* last char was backslash */
    3411         {
    3412           tflags &= ~LEX_PASSNEXT;
    3413           if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
    3414             {
    3415               if (retind > 0)
    3416                 retind--;       /* swallow previously-added backslash */
    3417               continue;
    3418             }
    3419 
    3420           RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
    3421           if MBTEST(ch == CTLESC || ch == CTLNUL)
    3422             ret[retind++] = CTLESC;
    3423           ret[retind++] = ch;
    3424           continue;
    3425         }
    3426       else if MBTEST(ch == CTLESC || ch == CTLNUL)      /* special shell escapes */
     3473      if MBTEST(ch == CTLESC || ch == CTLNUL)   /* special shell escapes */
    34273474        {
    34283475          RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
    34293476          ret[retind++] = CTLESC;
     
    42484295                     ((token_index > 0 && assignment_acceptable (last_read_token) && token_is_ident (token, token_index)) ||
    42494296                      (token_index == 0 && (parser_state&PST_COMPASSIGN))))
    42504297        {
    4251           ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
     4298          ttok = parse_matched_pair (cd, '[', ']', &ttoklen, P_ARRAYSUB);
    42524299          if (ttok == &matched_pair_error)
    42534300            return -1;          /* Bail immediately. */
    42544301          RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
     
    44494496    case '}':           /* XXX */
    44504497    case AND_AND:
    44514498    case BANG:
     4499    case BAR_AND:
    44524500    case DO:
    44534501    case DONE:
    44544502    case ELIF:
  • patchlevel.h

    diff -Naur bash-4.0.orig/patchlevel.h bash-4.0/patchlevel.h
    old new  
    2525   regexp `^#define[    ]*PATCHLEVEL', since that's what support/mkversion.sh
    2626   looks for to find the patch level (for the sccs version string). */
    2727
    28 #define PATCHLEVEL 0
     28#define PATCHLEVEL 17
    2929
    3030#endif /* _PATCHLEVEL_H_ */
  • pcomplete.c

    diff -Naur bash-4.0.orig/pcomplete.c bash-4.0/pcomplete.c
    old new  
    10321032  cmdlist = build_arg_list (funcname, text, lwords, cw);
    10331033
    10341034  pps = &ps;
     1035  save_parser_state (pps);
    10351036  begin_unwind_frame ("gen-shell-function-matches");
    10361037  add_unwind_protect (restore_parser_state, (char *)pps);
    10371038  add_unwind_protect (dispose_words, (char *)cmdlist);
  • bash-4.0

    diff -Naur bash-4.0.orig/sig.c bash-4.0/sig.c
    old new  
    448448termsig_sighandler (sig)
    449449     int sig;
    450450{
     451  /* If we get called twice with the same signal before handling it,
     452     terminate right away. */
     453  if (
     454#ifdef SIGHUP
     455    sig != SIGHUP &&
     456#endif
     457#ifdef SIGINT
     458    sig != SIGINT &&
     459#endif
     460#ifdef SIGDANGER
     461    sig != SIGDANGER &&
     462#endif
     463#ifdef SIGPIPE
     464    sig != SIGPIPE &&
     465#endif
     466#ifdef SIGALRM
     467    sig != SIGALRM &&
     468#endif
     469#ifdef SIGTERM
     470    sig != SIGTERM &&
     471#endif
     472#ifdef SIGXCPU
     473    sig != SIGXCPU &&
     474#endif
     475#ifdef SIGXFSZ
     476    sig != SIGXFSZ &&
     477#endif
     478#ifdef SIGVTALRM
     479    sig != SIGVTALRM &&
     480#endif
     481#ifdef SIGLOST
     482    sig != SIGLOST &&
     483#endif
     484#ifdef SIGUSR1
     485    sig != SIGUSR1 &&
     486#endif
     487#ifdef SIGUSR2
     488   sig != SIGUSR2 &&
     489#endif
     490   sig == terminating_signal)
     491    terminate_immediately = 1;
     492
    451493  terminating_signal = sig;
    452494
    453495  /* XXX - should this also trigger when interrupt_immediately is set? */
  • subst.c

    diff -Naur bash-4.0.orig/subst.c bash-4.0/subst.c
    old new  
    8585
    8686/* Flags for the `pflags' argument to param_expand() */
    8787#define PF_NOCOMSUB     0x01    /* Do not perform command substitution */
     88#define PF_IGNUNBOUND   0x02    /* ignore unbound vars even if -u set */
    8889
    8990/* These defs make it easier to use the editor. */
    9091#define LBRACE          '{'
     
    222223static int skip_double_quoted __P((char *, size_t, int));
    223224static char *extract_delimited_string __P((char *, int *, char *, char *, char *, int));
    224225static char *extract_dollar_brace_string __P((char *, int *, int, int));
     226static int skip_matched_pair __P((const char *, int, int, int, int));
    225227
    226228static char *pos_params __P((char *, int, int, int));
    227229
     
    262264static int chk_atstar __P((char *, int, int *, int *));
    263265static int chk_arithsub __P((const char *, int));
    264266
    265 static WORD_DESC *parameter_brace_expand_word __P((char *, int, int));
     267static WORD_DESC *parameter_brace_expand_word __P((char *, int, int, int));
    266268static WORD_DESC *parameter_brace_expand_indir __P((char *, int, int, int *, int *));
    267269static WORD_DESC *parameter_brace_expand_rhs __P((char *, char *, int, int, int *, int *));
    268270static void parameter_brace_expand_error __P((char *, char *));
     
    13741376
    13751377#define CQ_RETURN(x) do { no_longjmp_on_fatal_error = 0; return (x); } while (0)
    13761378
     1379/* This function assumes s[i] == open; returns with s[ret] == close; used to
     1380   parse array subscripts.  FLAGS currently unused. */
     1381static int
     1382skip_matched_pair (string, start, open, close, flags)
     1383     const char *string;
     1384     int start, open, close, flags;
     1385{
     1386  int i, pass_next, backq, si, c, count;
     1387  size_t slen;
     1388  char *temp, *ss;
     1389  DECLARE_MBSTATE;
     1390
     1391  slen = strlen (string + start) + start;
     1392  no_longjmp_on_fatal_error = 1;
     1393
     1394  i = start + 1;                /* skip over leading bracket */
     1395  count = 1;
     1396  pass_next = backq = 0;
     1397  ss = (char *)string;
     1398  while (c = string[i])
     1399    {
     1400      if (pass_next)
     1401        {
     1402          pass_next = 0;
     1403          if (c == 0)
     1404            CQ_RETURN(i);
     1405          ADVANCE_CHAR (string, slen, i);
     1406          continue;
     1407        }
     1408      else if (c == '\\')
     1409        {
     1410          pass_next = 1;
     1411          i++;
     1412          continue;
     1413        }
     1414      else if (backq)
     1415        {
     1416          if (c == '`')
     1417            backq = 0;
     1418          ADVANCE_CHAR (string, slen, i);
     1419          continue;
     1420        }
     1421      else if (c == '`')
     1422        {
     1423          backq = 1;
     1424          i++;
     1425          continue;
     1426        }
     1427      else if (c == open)
     1428        {
     1429          count++;
     1430          i++;
     1431          continue;
     1432        }
     1433      else if (c == close)
     1434        {
     1435          count--;
     1436          if (count == 0)
     1437            break;
     1438          i++;
     1439          continue;
     1440        }
     1441      else if (c == '\'' || c == '"')
     1442        {
     1443          i = (c == '\'') ? skip_single_quoted (ss, slen, ++i)
     1444                          : skip_double_quoted (ss, slen, ++i);
     1445          /* no increment, the skip functions increment past the closing quote. */
     1446        }
     1447      else if (c == '$' && (string[i+1] == LPAREN || string[i+1] == LBRACE))
     1448        {
     1449          si = i + 2;
     1450          if (string[si] == '\0')
     1451            CQ_RETURN(si);
     1452
     1453          if (string[i+1] == LPAREN)
     1454            temp = extract_delimited_string (ss, &si, "$(", "(", ")", SX_NOALLOC|SX_COMMAND); /* ) */
     1455          else
     1456            temp = extract_dollar_brace_string (ss, &si, 0, SX_NOALLOC);
     1457          i = si;
     1458          if (string[i] == '\0')        /* don't increment i past EOS in loop */
     1459            break;
     1460          i++;
     1461          continue;
     1462        }
     1463      else
     1464        ADVANCE_CHAR (string, slen, i);
     1465    }
     1466
     1467  CQ_RETURN(i);
     1468}
     1469
     1470#if defined (ARRAY_VARS)
     1471int
     1472skipsubscript (string, start)
     1473     const char *string;
     1474     int start;
     1475{
     1476  return (skip_matched_pair (string, start, '[', ']', 0));
     1477}
     1478#endif
     1479
    13771480/* Skip characters in STRING until we find a character in DELIMS, and return
    13781481   the index of that character.  START is the index into string at which we
    13791482   begin.  This is similar in spirit to strpbrk, but it returns an index into
     
    50935196   the shell, e.g., "@", "$", "*", etc.  QUOTED, if non-zero, means that
    50945197   NAME was found inside of a double-quoted expression. */
    50955198static WORD_DESC *
    5096 parameter_brace_expand_word (name, var_is_special, quoted)
     5199parameter_brace_expand_word (name, var_is_special, quoted, pflags)
    50975200     char *name;
    5098      int var_is_special, quoted;
     5201     int var_is_special, quoted, pflags;
    50995202{
    51005203  WORD_DESC *ret;
    51015204  char *temp, *tt;
     
    51275230      strcpy (tt + 1, name);
    51285231
    51295232      ret = param_expand (tt, &sindex, quoted, (int *)NULL, (int *)NULL,
    5130                           (int *)NULL, (int *)NULL, 0);
     5233                          (int *)NULL, (int *)NULL, pflags);
    51315234      free (tt);
    51325235    }
    51335236#if defined (ARRAY_VARS)
     
    51885291  char *temp, *t;
    51895292  WORD_DESC *w;
    51905293
    5191   w = parameter_brace_expand_word (name, var_is_special, quoted);
     5294  w = parameter_brace_expand_word (name, var_is_special, quoted, PF_IGNUNBOUND);
    51925295  t = w->word;
    51935296  /* Have to dequote here if necessary */
    51945297  if (t)
     
    52055308  if (t == 0)
    52065309    return (WORD_DESC *)NULL;
    52075310
    5208   w = parameter_brace_expand_word (t, SPECIAL_VAR(t, 0), quoted);
     5311  w = parameter_brace_expand_word (t, SPECIAL_VAR(t, 0), quoted, 0);
    52095312  free (t);
    52105313
    52115314  return w;
     
    65566659  if (want_indir)
    65576660    tdesc = parameter_brace_expand_indir (name + 1, var_is_special, quoted, quoted_dollar_atp, contains_dollar_at);
    65586661  else
    6559     tdesc = parameter_brace_expand_word (name, var_is_special, quoted);
     6662    tdesc = parameter_brace_expand_word (name, var_is_special, quoted, PF_IGNUNBOUND);
    65606663
    65616664  if (tdesc)
    65626665    {
     
    68876990    case '*':           /* `$*' */
    68886991      list = list_rest_of_args ();
    68896992
    6890       if (list == 0 && unbound_vars_is_error)
     6993      if (list == 0 && unbound_vars_is_error && (pflags & PF_IGNUNBOUND) == 0)
    68916994        {
    68926995          uerror[0] = '$';
    68936996          uerror[1] = '*';
     
    69497052    case '@':           /* `$@' */
    69507053      list = list_rest_of_args ();
    69517054
    6952       if (list == 0 && unbound_vars_is_error)
     7055      if (list == 0 && unbound_vars_is_error && (pflags & PF_IGNUNBOUND) == 0)
    69537056        {
    69547057          uerror[0] = '$';
    69557058          uerror[1] = '@';
  • bash-4.0

    diff -Naur bash-4.0.orig/trap.c bash-4.0/trap.c
    old new  
    755755        }
    756756
    757757      flags = SEVAL_NONINT|SEVAL_NOHIST;
    758       if (sig != DEBUG_TRAP && sig != RETURN_TRAP)
     758      if (sig != DEBUG_TRAP && sig != RETURN_TRAP && sig != ERROR_TRAP)
    759759        flags |= SEVAL_RESETLINE;
    760760      if (function_code == 0)
    761761        parse_and_execute (trap_command, tag, flags);
Note: See TracBrowser for help on using the repository browser.