- in command_word_completion_function, use rl_variable_value to decide
whether or not we should ignore case, and use strncasecmp instead of
strncmp where appropriate
+
+ 10/11
+ -----
+builtins/fc.def
+ - fixed a typo when using POSIX_FC_EDIT_COMMAND
+
+redir.h
+ - new flag values for redirections: RX_INTERNAL and RX_USER (currently
+ unused)
+
+redir.c
+ - add_undo_redirect and add_undo_close_redirect now set RX_INTERNAL
+ flag when making new redirects
+ - in do_redirection_internal, only set file descriptors > 2 to CLEXEC
+ if they're marked as RX_INTERNAL
+
+ 10/12
+ -----
+jobs.c
+ - in wait_for_single_pid, if in posix mode, remove the waited-for pid
+ from the list of background pids, forgetting it entirely. POSIX
+ conformance tests test for this.
+
+lib/readline/{readline.h,vi_mode.c}
+ - new state flag, RL_STATE_VICMDONCE, set after entering vi command
+ mode the first time; reset on each call to readline()
+
+ 10/13
+ -----
+lib/readline/undo.c
+ - in rl_revert_line, make sure that revert-line in vi mode leaves
+ rl_point set to 0 no matter the state of the line buffer
+
+lib/readline/vi_mode.c
+ - when entering vi_command mode for the first time, free any existing
+ undo list so the previous insertions won't be undone by the `U'
+ command. This is how POSIX.2 says `U' should work (and the test
+ suite tests for it)
+
+lib/readline/bind.c
+ - change rl_parse_and_bind so only `set' commands involving boolean
+ readline variables have trailing whitespace stripped from the value
+ string
+
+ 10/16
+ -----
+lib/glob/sm_loop.c
+ - fix patscan() to correctly scan backslash-escaped characters
rl_completion_found_quote, but doesn't set rl_completion_quote_character,
we have an embedded quoted string or backslash-escaped character in
the passed text. We need to dequote that before calling
- filename_completion_function
+ filename_completion_function. So far, this is in place only for
+ absolute program names (those containing a `/')
+ - in command_word_completion_function, use rl_variable_value to decide
+ whether or not we should ignore case, and use strncasecmp instead of
+ strncmp where appropriate
+
+ 10/11
+ -----
+builtins/fc.def
+ - fixed a typo when using POSIX_FC_EDIT_COMMAND
+
+redir.h
+ - new flag values for redirections: RX_INTERNAL and RX_USER (currently
+ unused)
+
+redir.c
+ - add_undo_redirect and add_undo_close_redirect now set RX_INTERNAL
+ flag when making new redirects
+ - in do_redirection_internal, only set file descriptors > 2 to CLEXEC
+ if they're marked as RX_INTERNAL
+
+ 10/12
+ -----
+jobs.c
+ - in wait_for_single_pid, if in posix mode, remove the waited-for pid
+ from the list of background pids, forgetting it entirely. POSIX
+ conformance tests test for this.
+
+lib/readline/{readline.h,vi_mode.c}
+ - new state flag, RL_STATE_VICMDONCE, set after entering vi command
+ mode the first time; reset on each call to readline()
+
+ 10/13
+ -----
+lib/readline/undo.c
+ - in rl_revert_line, make sure that revert-line in vi mode leaves
+ rl_point set to 0 no matter the state of the line buffer
+
+lib/readline/vi_mode.c
+ - when entering vi_command mode for the first time, free any existing
+ undo list so the previous insertions won't be undone by the `U'
+ command. This is how POSIX.2 says `U' should work (and the test
+ suite tests for it)
+
+lib/readline/bind.c
+ - change rl_parse_and_bind so only `set' commands involving boolean
+ readline variables have trailing whitespace stripped from the value
+ string
{
fcedit = posixly_correct ? POSIX_FC_EDIT_COMMAND : FC_EDIT_COMMAND;
command = (char *)xmalloc (3 + strlen (fcedit) + strlen (fn));
- sprintf (command, "%s %s", FC_EDIT_COMMAND, fn);
+ sprintf (command, "%s %s", fcedit, fn);
}
retval = parse_and_execute (command, "fc", SEVAL_NOHIST);
if (retval != EXECUTION_SUCCESS)
bfox@gnu.org
Chet Ramey, Case Western Reserve University
- chet@po.CWRU.Edu
+ chet@po.cwru.edu
B\bBU\bUG\bG R\bRE\bEP\bPO\bOR\bRT\bTS\bS
If you find a bug in b\bba\bas\bsh\bh,\b, you should report it. But first, you should
it provides for filing a bug report.
Comments and bug reports concerning this manual page should be directed
- to _\bc_\bh_\be_\bt_\b@_\bp_\bo_\b._\bC_\bW_\bR_\bU_\b._\bE_\bd_\bu.
+ to _\bc_\bh_\be_\bt_\b@_\bp_\bo_\b._\bc_\bw_\br_\bu_\b._\be_\bd_\bu.
B\bBU\bUG\bGS\bS
It's too big and too slow.
.\" Chet Ramey
.\" Information Network Services
.\" Case Western Reserve University
-.\" chet@po.CWRU.Edu
+.\" chet@po.cwru.edu
.\"
.\" Last Change: Sat Aug 27 13:28:44 EDT 2005
.\"
.PP
Chet Ramey, Case Western Reserve University
.br
-chet@po.CWRU.Edu
+chet@po.cwru.edu
.SH BUG REPORTS
If you find a bug in
.B bash,
.PP
Comments and bug reports concerning
this manual page should be directed to
-.IR chet@po.CWRU.Edu .
+.IR chet@po.cwru.edu .
.SH BUGS
.PP
It's too big and too slow.
<TITLE>BASH(1) Manual Page</TITLE>
</HEAD>
<BODY><TABLE WIDTH=100%>
-<TH ALIGN=LEFT>BASH(1)<TH ALIGN=CENTER>2005 Aug 27<TH ALIGN=RIGHT>BASH(1)
+<TR>
+<TH ALIGN=LEFT width=33%>BASH(1)<TH ALIGN=CENTER width=33%>2005 Aug 27<TH ALIGN=RIGHT width=33%>BASH(1)
+</TR>
</TABLE>
<BR><A HREF="#index">Index</A>
<HR>
<A NAME="lbAB"> </A>
-<H2>NAME</H2>
+<H3>NAME</H3>
bash - GNU Bourne-Again SHell
<A NAME="lbAC"> </A>
-<H2>SYNOPSIS</H2>
+<H3>SYNOPSIS</H3>
<B>bash</B>
[options]
[file]
<A NAME="lbAD"> </A>
-<H2>COPYRIGHT</H2>
+<H3>COPYRIGHT</H3>
Bash is Copyright © 1989-2005 by the Free Software Foundation, Inc.
<A NAME="lbAE"> </A>
-<H2>DESCRIPTION</H2>
+<H3>DESCRIPTION</H3>
<B>Bash</B>
can be configured to be POSIX-conformant by default.
<A NAME="lbAF"> </A>
-<H2>OPTIONS</H2>
+<H3>OPTIONS</H3>
In addition to the single-character shell options documented in the
description of the <B>set</B> builtin command, <B>bash</B>
</DL>
<A NAME="lbAG"> </A>
-<H2>ARGUMENTS</H2>
+<H3>ARGUMENTS</H3>
If arguments remain after option processing, and neither the
<B>-c</B>
</FONT>
for the script.
<A NAME="lbAH"> </A>
-<H2>INVOCATION</H2>
+<H3>INVOCATION</H3>
A <I>login shell</I> is one whose first character of argument zero is a
<B>-</B>,
If the <B>-p</B> option is supplied at invocation, the startup behavior is
the same, but the effective user id is not reset.
<A NAME="lbAI"> </A>
-<H2>DEFINITIONS</H2>
+<H3>DEFINITIONS</H3>
<P>
</DL>
<A NAME="lbAJ"> </A>
-<H2>RESERVED WORDS</H2>
+<H3>RESERVED WORDS</H3>
<I>Reserved words</I> are words that have a special meaning to the shell.
The following words are recognized as reserved when unquoted and either
<A NAME="lbAK"> </A>
-<H2>SHELL GRAMMAR</H2>
+<H3>SHELL GRAMMAR</H3>
<A NAME="lbAL"> </A>
-<H3>Simple Commands</H3>
+<H4>Simple Commands</H4>
<P>
<I>n</I>.
<A NAME="lbAM"> </A>
-<H3>Pipelines</H3>
+<H4>Pipelines</H4>
<P>
Each command in a pipeline is executed as a separate process (i.e., in a
subshell).
<A NAME="lbAN"> </A>
-<H3>Lists</H3>
+<H4>Lists</H4>
<P>
AND and OR lists is the exit status of the last command
executed in the list.
<A NAME="lbAO"> </A>
-<H3>Compound Commands</H3>
+<H4>Compound Commands</H4>
<P>
none was executed.
</DL>
<A NAME="lbAP"> </A>
-<H3>Shell Function Definitions</H3>
+<H4>Shell Function Definitions</H4>
<P>
below.)
</DL>
<A NAME="lbAQ"> </A>
-<H2>COMMENTS</H2>
+<H3>COMMENTS</H3>
In a non-interactive shell, or an interactive shell in which the
<B>interactive_comments</B>
option is on by default in interactive shells.
<A NAME="lbAR"> </A>
-<H2>QUOTING</H2>
+<H3>QUOTING</H3>
<I>Quoting</I> is used to remove the special meaning of certain
characters or words to the shell. Quoting can be used to
If the string is translated and replaced, the replacement is
double-quoted.
<A NAME="lbAS"> </A>
-<H2>PARAMETERS</H2>
+<H3>PARAMETERS</H3>
A
<I>parameter</I>
When applied to a string-valued variable, <I>value</I> is expanded and
appended to the variable's value.
<A NAME="lbAT"> </A>
-<H3>Positional Parameters</H3>
+<H4>Positional Parameters</H4>
<P>
</FONT>
below).
<A NAME="lbAU"> </A>
-<H3>Special Parameters</H3>
+<H4>Special Parameters</H4>
<P>
</DL>
<A NAME="lbAV"> </A>
-<H3>Shell Variables</H3>
+<H4>Shell Variables</H4>
<P>
</DL>
<A NAME="lbAW"> </A>
-<H3>Arrays</H3>
+<H4>Arrays</H4>
<B>Bash</B>
builtins display array values in a way that allows them to be
reused as assignments.
<A NAME="lbAX"> </A>
-<H2>EXPANSION</H2>
+<H3>EXPANSION</H3>
Expansion is performed on the command line after it has been split into
words. There are seven kinds of expansion performed:
</FONT>
<A NAME="lbAY"> </A>
-<H3>Brace Expansion</H3>
+<H4>Brace Expansion</H4>
<P>
</FONT>
below).
<A NAME="lbAZ"> </A>
-<H3>Tilde Expansion</H3>
+<H4>Tilde Expansion</H4>
<P>
</FONT>
and the shell assigns the expanded value.
<A NAME="lbBA"> </A>
-<H3>Parameter Expansion</H3>
+<H4>Parameter Expansion</H4>
<P>
array in turn, and the expansion is the resultant list.
</DL>
<A NAME="lbBB"> </A>
-<H3>Command Substitution</H3>
+<H4>Command Substitution</H4>
<P>
If the substitution appears within double quotes, word splitting and
pathname expansion are not performed on the results.
<A NAME="lbBC"> </A>
-<H3>Arithmetic Expansion</H3>
+<H4>Arithmetic Expansion</H4>
<P>
prints a message indicating failure and no substitution occurs.
<A NAME="lbBD"> </A>
-<H3>Process Substitution</H3>
+<H4>Process Substitution</H4>
<P>
command substitution,
and arithmetic expansion.
<A NAME="lbBE"> </A>
-<H3>Word Splitting</H3>
+<H4>Word Splitting</H4>
<P>
Note that if no expansion occurs, no splitting
is performed.
<A NAME="lbBF"> </A>
-<H3>Pathname Expansion</H3>
+<H4>Pathname Expansion</H4>
<P>
<A NAME="lbBG"> </A>
-<H3>Quote Removal</H3>
+<H4>Quote Removal</H4>
<P>
and <B>"</B> that did not result from one of the above
expansions are removed.
<A NAME="lbBH"> </A>
-<H2>REDIRECTION</H2>
+<H3>REDIRECTION</H3>
Before a command is executed, its input and output
may be
care, as they may conflict with file descriptors the shell uses
internally.
<A NAME="lbBI"> </A>
-<H3>Redirecting Input</H3>
+<H4>Redirecting Input</H4>
<P>
</DL>
<A NAME="lbBJ"> </A>
-<H3>Redirecting Output</H3>
+<H4>Redirecting Output</H4>
<P>
builtin command is not enabled, the redirection is attempted even
if the file named by <I>word</I> exists.
<A NAME="lbBK"> </A>
-<H3>Appending Redirected Output</H3>
+<H4>Appending Redirected Output</H4>
<P>
<P>
<A NAME="lbBL"> </A>
-<H3>Redirecting Standard Output and Standard Error</H3>
+<H4>Redirecting Standard Output and Standard Error</H4>
<P>
</DL>
<A NAME="lbBM"> </A>
-<H3>Here Documents</H3>
+<H4>Here Documents</H4>
<P>
here-documents within shell scripts to be indented in a
natural fashion.
<A NAME="lbBN"> </A>
-<H3>Here Strings</H3>
+<H4>Here Strings</H4>
A variant of here documents, the format is:
<DL COMPACT><DT><DD>
The <I>word</I> is expanded and supplied to the command on its standard
input.
<A NAME="lbBO"> </A>
-<H3>Duplicating File Descriptors</H3>
+<H4>Duplicating File Descriptors</H4>
<P>
expand to one or more digits, the standard output and standard
error are redirected as described previously.
<A NAME="lbBP"> </A>
-<H3>Moving File Descriptors</H3>
+<H4>Moving File Descriptors</H4>
<P>
or the standard output (file descriptor 1) if <I>n</I> is not specified.
<A NAME="lbBQ"> </A>
-<H3>Opening File Descriptors for Reading and Writing</H3>
+<H4>Opening File Descriptors for Reading and Writing</H4>
<P>
is not specified. If the file does not exist, it is created.
<A NAME="lbBR"> </A>
-<H2>ALIASES</H2>
+<H3>ALIASES</H3>
<I>Aliases</I> allow a string to be substituted for a word when it is used
as the first word of a simple command.
For almost every purpose, aliases are superseded by
shell functions.
<A NAME="lbBS"> </A>
-<H2>FUNCTIONS</H2>
+<H3>FUNCTIONS</H3>
A shell function, defined as described above under
<FONT SIZE=-1><B>SHELL GRAMMAR</B>,
Functions may be recursive. No limit is imposed on the number
of recursive calls.
<A NAME="lbBT"> </A>
-<H2>ARITHMETIC EVALUATION</H2>
+<H3>ARITHMETIC EVALUATION</H3>
The shell allows arithmetic expressions to be evaluated, under
certain circumstances (see the <B>let</B> and <B>declare</B> builtin
parentheses are evaluated first and may override the precedence
rules above.
<A NAME="lbBU"> </A>
-<H2>CONDITIONAL EXPRESSIONS</H2>
+<H3>CONDITIONAL EXPRESSIONS</H3>
Conditional expressions are used by the <B>[[</B> compound command and
the <B>test</B> and <B>[</B> builtin commands to test file attributes
</DL>
<A NAME="lbBV"> </A>
-<H2>SIMPLE COMMAND EXPANSION</H2>
+<H3>SIMPLE COMMAND EXPANSION</H3>
When a simple command is executed, the shell performs the following
expansions, assignments, and redirections, from left to right.
the exit status of the last command substitution performed. If there
were no command substitutions, the command exits with a status of zero.
<A NAME="lbBW"> </A>
-<H2>COMMAND EXECUTION</H2>
+<H3>COMMAND EXECUTION</H3>
After a command has been split into words, if it results in a
simple command and an optional list of arguments, the following
by the name of the program, followed by the command
arguments, if any.
<A NAME="lbBX"> </A>
-<H2>COMMAND EXECUTION ENVIRONMENT</H2>
+<H3>COMMAND EXECUTION ENVIRONMENT</H3>
The shell has an <I>execution environment</I>, which consists of the
following:
Otherwise, the invoked command inherits the file descriptors of the calling
shell as modified by redirections.
<A NAME="lbBY"> </A>
-<H2>ENVIRONMENT</H2>
+<H3>ENVIRONMENT</H3>
When a program is invoked it is given an array of strings
called the
is set to the full file name of the command and passed to that
command in its environment.
<A NAME="lbBZ"> </A>
-<H2>EXIT STATUS</H2>
+<H3>EXIT STATUS</H3>
For the shell's purposes, a command which exits with a
zero exit status has succeeded. An exit status of zero
with a non-zero value. See also the <B>exit</B> builtin
command below.
<A NAME="lbCA"> </A>
-<H2>SIGNALS</H2>
+<H3>SIGNALS</H3>
When <B>bash</B> is interactive, in the absence of any traps, it ignores
<FONT SIZE=-1><B>SIGTERM</B>
cause the <B>wait</B> builtin to return immediately with an exit status
greater than 128, immediately after which the trap is executed.
<A NAME="lbCB"> </A>
-<H2>JOB CONTROL</H2>
+<H3>JOB CONTROL</H3>
<I>Job control</I>
the shell does not print another warning, and the stopped
jobs are terminated.
<A NAME="lbCC"> </A>
-<H2>PROMPTING</H2>
+<H3>PROMPTING</H3>
When executing interactively,
<B>bash</B>
</FONT>
below).
<A NAME="lbCD"> </A>
-<H2>READLINE</H2>
+<H3>READLINE</H3>
This is the library that handles reading input when using an interactive
shell, unless the
</FONT>
below).
<A NAME="lbCE"> </A>
-<H3>Readline Notation</H3>
+<H4>Readline Notation</H4>
<P>
Commands which do not kill text separate the chunks of text
on the kill ring.
<A NAME="lbCF"> </A>
-<H3>Readline Initialization</H3>
+<H4>Readline Initialization</H4>
<P>
In addition to command names, readline allows keys to be bound
to a string that is inserted when the key is pressed (a <I>macro</I>).
<A NAME="lbCG"> </A>
-<H3>Readline Key Bindings</H3>
+<H4>Readline Key Bindings</H4>
<P>
</FONT>
below).
<A NAME="lbCH"> </A>
-<H3>Readline Variables</H3>
+<H4>Readline Variables</H4>
<P>
</DL>
<A NAME="lbCI"> </A>
-<H3>Readline Conditional Constructs</H3>
+<H4>Readline Conditional Constructs</H4>
<P>
</DL>
<A NAME="lbCJ"> </A>
-<H3>Searching</H3>
+<H4>Searching</H4>
<P>
to search for matching history lines. The search string may be
typed by the user or be part of the contents of the current line.
<A NAME="lbCK"> </A>
-<H3>Readline Command Names</H3>
+<H4>Readline Command Names</H4>
<P>
<B>set-mark</B> command.
The text between the point and mark is referred to as the <I>region</I>.
<A NAME="lbCL"> </A>
-<H3>Commands for Moving</H3>
+<H4>Commands for Moving</H4>
<P>
</DL>
<A NAME="lbCM"> </A>
-<H3>Commands for Manipulating the History</H3>
+<H4>Commands for Manipulating the History</H4>
<P>
</DL>
<A NAME="lbCN"> </A>
-<H3>Commands for Changing Text</H3>
+<H4>Commands for Changing Text</H4>
<P>
</DL>
<A NAME="lbCO"> </A>
-<H3>Killing and Yanking</H3>
+<H4>Killing and Yanking</H4>
<P>
</DL>
<A NAME="lbCP"> </A>
-<H3>Numeric Arguments</H3>
+<H4>Numeric Arguments</H4>
<P>
</DL>
<A NAME="lbCQ"> </A>
-<H3>Completing</H3>
+<H4>Completing</H4>
<P>
</DL>
<A NAME="lbCR"> </A>
-<H3>Keyboard Macros</H3>
+<H4>Keyboard Macros</H4>
<P>
</DL>
<A NAME="lbCS"> </A>
-<H3>Miscellaneous</H3>
+<H4>Miscellaneous</H4>
<P>
</DL>
<A NAME="lbCT"> </A>
-<H3>Programmable Completion</H3>
+<H4>Programmable Completion</H4>
<P>
the value of the <B>mark-directories</B> readline variable, regardless
of the setting of the <B>mark-symlinked-directories</B> readline variable.
<A NAME="lbCU"> </A>
-<H2>HISTORY</H2>
+<H3>HISTORY</H3>
When the
<B>-o history</B>
</FONT>
for information on setting and unsetting shell options.
<A NAME="lbCV"> </A>
-<H2>HISTORY EXPANSION</H2>
+<H3>HISTORY EXPANSION</H3>
<P>
<B>Shell Variables</B>).
<A NAME="lbCW"> </A>
-<H3>Event Designators</H3>
+<H4>Event Designators</H4>
<P>
</DL>
<A NAME="lbCX"> </A>
-<H3>Word Designators</H3>
+<H4>Word Designators</H4>
<P>
If a word designator is supplied without an event specification, the
previous command is used as the event.
<A NAME="lbCY"> </A>
-<H3>Modifiers</H3>
+<H4>Modifiers</H4>
<P>
</DL>
<A NAME="lbCZ"> </A>
-<H2>SHELL BUILTIN COMMANDS</H2>
+<H3>SHELL BUILTIN COMMANDS</H3>
</DL>
<A NAME="lbDA"> </A>
-<H2>RESTRICTED SHELL</H2>
+<H3>RESTRICTED SHELL</H3>
<A NAME="lbDB"> </A>
-<H2>SEE ALSO</H2>
+<H3>SEE ALSO</H3>
<DL COMPACT>
</DL>
<A NAME="lbDC"> </A>
-<H2>FILES</H2>
+<H3>FILES</H3>
<DL COMPACT>
</DL>
<A NAME="lbDD"> </A>
-<H2>AUTHORS</H2>
+<H3>AUTHORS</H3>
Brian Fox, Free Software Foundation
<BR>
Chet Ramey, Case Western Reserve University
<BR>
-<A HREF="mailto:chet@po.CWRU.Edu">chet@po.CWRU.Edu</A>
+<A HREF="mailto:chet@po.cwru.edu">chet@po.cwru.edu</A>
<A NAME="lbDE"> </A>
-<H2>BUG REPORTS</H2>
+<H3>BUG REPORTS</H3>
If you find a bug in
<B>bash,</B>
Comments and bug reports concerning
this manual page should be directed to
-<I><A HREF="mailto:chet@po.CWRU.Edu">chet@po.CWRU.Edu</A></I>.
+<I><A HREF="mailto:chet@po.cwru.edu">chet@po.cwru.edu</A></I>.
<A NAME="lbDF"> </A>
-<H2>BUGS</H2>
+<H3>BUGS</H3>
<P>
+<HR>
+<TABLE WIDTH=100%>
+<TR>
+<TH ALIGN=LEFT width=33%>GNU Bash-3.1-beta1<TH ALIGN=CENTER width=33%>2005 Aug 27<TH ALIGN=RIGHT width=33%>BASH(1)
+</TR>
+</TABLE>
<HR>
<A NAME="index"> </A><H2>Index</H2>
<DL>
</DL>
<HR>
This document was created by man2html from bash.1.<BR>
-Time: 03 October 2005 15:07:47 EDT
+Time: 12 October 2005 16:46:47 EDT
</BODY>
</HTML>
%!PS-Adobe-3.0
%%Creator: groff version 1.19.1
-%%CreationDate: Mon Oct 3 15:05:27 2005
+%%CreationDate: Wed Oct 12 16:46:45 2005
%%DocumentNeededResources: font Times-Roman
%%+ font Times-Bold
%%+ font Times-Italic
(Brian F)108 566.4 Q(ox, Free Softw)-.15 E(are F)-.1 E(oundation)-.15 E
(bfox@gnu.or)108 578.4 Q(g)-.18 E(Chet Rame)108 595.2 Q 1.3 -.65(y, C)
-.15 H(ase W).65 E(estern Reserv)-.8 E 2.5(eU)-.15 G(ni)-2.5 E -.15(ve)
--.25 G(rsity).15 E(chet@po.CWR)108 607.2 Q(U.Edu)-.4 E F3 -.11(BU)72 624
-S 2.738(GR).11 G(EPOR)-2.738 E(TS)-.438 E F0 .567(If you \214nd a b)108
+-.25 G(rsity).15 E(chet@po.cwru.edu)108 607.2 Q F3 -.11(BU)72 624 S
+2.738(GR).11 G(EPOR)-2.738 E(TS)-.438 E F0 .567(If you \214nd a b)108
636 R .568(ug in)-.2 F F1(bash,)3.068 E F0 .568(you should report it.)
3.068 F .568(But \214rst, you should mak)5.568 F 3.068(es)-.1 G .568
(ure that it really is a b)-3.068 F .568(ug, and)-.2 F 5.626
(inserts the \214rst three items automatically into the template it pro)
2.72 E(vides for \214ling a b)-.15 E(ug report.)-.2 E(Comments and b)108
165.6 Q(ug reports concerning this manual page should be directed to)-.2
-E F2 -.15(ch)2.5 G(et@po.CWR).15 E -.25(U.)-.4 G(Edu).25 E F0(.).25 E/F3
-10.95/Times-Bold@0 SF -.11(BU)72 182.4 S(GS).11 E F0(It')108 194.4 Q 2.5
-(st)-.55 G(oo big and too slo)-2.5 E -.65(w.)-.25 G 1.868
+E F2 -.15(ch)2.5 G(et@po.cwru.edu).15 E F0(.).25 E/F3 10.95/Times-Bold@0
+SF -.11(BU)72 182.4 S(GS).11 E F0(It')108 194.4 Q 2.5(st)-.55 G
+(oo big and too slo)-2.5 E -.65(w.)-.25 G 1.868
(There are some subtle dif)108 211.2 R 1.868(ferences between)-.25 F F1
(bash)4.369 E F0 1.869(and traditional v)4.369 F 1.869(ersions of)-.15 F
F1(sh)4.369 E F0 4.369(,m)C 1.869(ostly because of the)-4.369 F/F4 9
%!PS-Adobe-3.0
%%Creator: groff version 1.19.1
-%%CreationDate: Mon Oct 3 15:05:28 2005
+%%CreationDate: Wed Oct 12 16:46:45 2005
%%DocumentNeededResources: font Times-Roman
%%+ font Times-Bold
%%+ font Times-Italic
%!PS-Adobe-3.0
%%Creator: groff version 1.19.1
-%%CreationDate: Mon Oct 3 15:05:28 2005
+%%CreationDate: Wed Oct 12 16:46:46 2005
%%DocumentNeededResources: font Times-Roman
%%+ font Times-Bold
%%DocumentSuppliedResources: procset grops 1.19 1
/* If running in posix mode, remove the job from the jobs table immediately */
if (posixly_correct)
- cleanup_dead_jobs ();
+ {
+ cleanup_dead_jobs ();
+ bgp_delete (pid);
+ }
return r;
}
CHAR *string, *end;
INT delim;
{
- int pnest, bnest;
+ int pnest, bnest, skip;
INT cchar;
CHAR *s, c, *bfirst;
- pnest = bnest = 0;
+ pnest = bnest = skip = 0;
cchar = 0;
bfirst = NULL;
{
if (s >= end)
return (s);
+ if (skip)
+ {
+ skip = 0;
+ continue;
+ }
switch (c)
{
+ case L('\\'):
+ skip = 1;
+ break;
+
case L('\0'):
return ((CHAR *)NULL);
--- /dev/null
+/* Copyright (C) 1991-2005 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. */
+
+int FCT __P((CHAR *, CHAR *, int));
+
+static int GMATCH __P((CHAR *, CHAR *, CHAR *, CHAR *, int));
+static CHAR *PARSE_COLLSYM __P((CHAR *, INT *));
+static CHAR *BRACKMATCH __P((CHAR *, U_CHAR, int));
+static int EXTMATCH __P((INT, CHAR *, CHAR *, CHAR *, CHAR *, int));
+static CHAR *PATSCAN __P((CHAR *, CHAR *, INT));
+
+int
+FCT (pattern, string, flags)
+ CHAR *pattern;
+ CHAR *string;
+ int flags;
+{
+ CHAR *se, *pe;
+
+ if (string == 0 || pattern == 0)
+ return FNM_NOMATCH;
+
+ se = string + STRLEN ((XCHAR *)string);
+ pe = pattern + STRLEN ((XCHAR *)pattern);
+
+ return (GMATCH (string, se, pattern, pe, flags));
+}
+
+/* Match STRING against the filename pattern PATTERN, returning zero if
+ it matches, FNM_NOMATCH if not. */
+static int
+GMATCH (string, se, pattern, pe, flags)
+ CHAR *string, *se;
+ CHAR *pattern, *pe;
+ int flags;
+{
+ CHAR *p, *n; /* pattern, string */
+ INT c; /* current pattern character - XXX U_CHAR? */
+ INT sc; /* current string character - XXX U_CHAR? */
+
+ p = pattern;
+ n = string;
+
+ if (string == 0 || pattern == 0)
+ return FNM_NOMATCH;
+
+#if DEBUG_MATCHING
+fprintf(stderr, "gmatch: string = %s; se = %s\n", string, se);
+fprintf(stderr, "gmatch: pattern = %s; pe = %s\n", pattern, pe);
+#endif
+
+ while (p < pe)
+ {
+ c = *p++;
+ c = FOLD (c);
+
+ sc = n < se ? *n : '\0';
+
+#ifdef EXTENDED_GLOB
+ /* EXTMATCH () will handle recursively calling GMATCH, so we can
+ just return what EXTMATCH() returns. */
+ if ((flags & FNM_EXTMATCH) && *p == L('(') &&
+ (c == L('+') || c == L('*') || c == L('?') || c == L('@') || c == L('!'))) /* ) */
+ {
+ int lflags;
+ /* If we're not matching the start of the string, we're not
+ concerned about the special cases for matching `.' */
+ lflags = (n == string) ? flags : (flags & ~FNM_PERIOD);
+ return (EXTMATCH (c, n, se, p, pe, lflags));
+ }
+#endif /* EXTENDED_GLOB */
+
+ switch (c)
+ {
+ case L('?'): /* Match single character */
+ if (sc == '\0')
+ return FNM_NOMATCH;
+ else if ((flags & FNM_PATHNAME) && sc == L('/'))
+ /* If we are matching a pathname, `?' can never match a `/'. */
+ return FNM_NOMATCH;
+ else if ((flags & FNM_PERIOD) && sc == L('.') &&
+ (n == string || ((flags & FNM_PATHNAME) && n[-1] == L('/'))))
+ /* `?' cannot match a `.' if it is the first character of the
+ string or if it is the first character following a slash and
+ we are matching a pathname. */
+ return FNM_NOMATCH;
+ break;
+
+ case L('\\'): /* backslash escape removes special meaning */
+ if (p == pe)
+ return FNM_NOMATCH;
+
+ if ((flags & FNM_NOESCAPE) == 0)
+ {
+ c = *p++;
+ /* A trailing `\' cannot match. */
+ if (p > pe)
+ return FNM_NOMATCH;
+ c = FOLD (c);
+ }
+ if (FOLD (sc) != (U_CHAR)c)
+ return FNM_NOMATCH;
+ break;
+
+ case '*': /* Match zero or more characters */
+ if (p == pe)
+ return 0;
+
+ if ((flags & FNM_PERIOD) && sc == L('.') &&
+ (n == string || ((flags & FNM_PATHNAME) && n[-1] == L('/'))))
+ /* `*' cannot match a `.' if it is the first character of the
+ string or if it is the first character following a slash and
+ we are matching a pathname. */
+ return FNM_NOMATCH;
+
+ /* Collapse multiple consecutive `*' and `?', but make sure that
+ one character of the string is consumed for each `?'. */
+ for (c = *p++; (c == L('?') || c == L('*')); c = *p++)
+ {
+ if ((flags & FNM_PATHNAME) && sc == L('/'))
+ /* A slash does not match a wildcard under FNM_PATHNAME. */
+ return FNM_NOMATCH;
+#ifdef EXTENDED_GLOB
+ else if ((flags & FNM_EXTMATCH) && c == L('?') && *p == L('(')) /* ) */
+ {
+ CHAR *newn;
+ for (newn = n; newn < se; ++newn)
+ {
+ if (EXTMATCH (c, newn, se, p, pe, flags) == 0)
+ return (0);
+ }
+ /* We didn't match. If we have a `?(...)', that's failure. */
+ return FNM_NOMATCH;
+ }
+#endif
+ else if (c == L('?'))
+ {
+ if (sc == L('\0'))
+ return FNM_NOMATCH;
+ /* One character of the string is consumed in matching
+ this ? wildcard, so *??? won't match if there are
+ fewer than three characters. */
+ n++;
+ sc = n < se ? *n : '\0';
+ }
+
+#ifdef EXTENDED_GLOB
+ /* Handle ******(patlist) */
+ if ((flags & FNM_EXTMATCH) && c == L('*') && *p == L('(')) /*)*/
+ {
+ CHAR *newn;
+ /* We need to check whether or not the extended glob
+ pattern matches the remainder of the string.
+ If it does, we match the entire pattern. */
+ for (newn = n; newn < se; ++newn)
+ {
+ if (EXTMATCH (c, newn, se, p, pe, flags) == 0)
+ return (0);
+ }
+ /* We didn't match the extended glob pattern, but
+ that's OK, since we can match 0 or more occurrences.
+ We need to skip the glob pattern and see if we
+ match the rest of the string. */
+ newn = PATSCAN (p + 1, pe, 0);
+ /* If NEWN is 0, we have an ill-formed pattern. */
+ p = newn ? newn : pe;
+ }
+#endif
+ if (p == pe)
+ break;
+ }
+
+ /* If we've hit the end of the pattern and the last character of
+ the pattern was handled by the loop above, we've succeeded.
+ Otherwise, we need to match that last character. */
+ if (p == pe && (c == L('?') || c == L('*')))
+ return (0);
+
+ /* General case, use recursion. */
+ {
+ U_CHAR c1;
+
+ c1 = ((flags & FNM_NOESCAPE) == 0 && c == L('\\')) ? *p : c;
+ c1 = FOLD (c1);
+ for (--p; n < se; ++n)
+ {
+ /* Only call strmatch if the first character indicates a
+ possible match. We can check the first character if
+ we're not doing an extended glob match. */
+ if ((flags & FNM_EXTMATCH) == 0 && c != L('[') && FOLD (*n) != c1) /*]*/
+ continue;
+
+ /* If we're doing an extended glob match and the pattern is not
+ one of the extended glob patterns, we can check the first
+ character. */
+ if ((flags & FNM_EXTMATCH) && p[1] != L('(') && /*)*/
+ STRCHR (L("?*+@!"), *p) == 0 && c != L('[') && FOLD (*n) != c1) /*]*/
+ continue;
+
+ /* Otherwise, we just recurse. */
+ if (GMATCH (n, se, p, pe, flags & ~FNM_PERIOD) == 0)
+ return (0);
+ }
+ return FNM_NOMATCH;
+ }
+
+ case L('['):
+ {
+ if (sc == L('\0') || n == se)
+ return FNM_NOMATCH;
+
+ /* A character class cannot match a `.' if it is the first
+ character of the string or if it is the first character
+ following a slash and we are matching a pathname. */
+ if ((flags & FNM_PERIOD) && sc == L('.') &&
+ (n == string || ((flags & FNM_PATHNAME) && n[-1] == L('/'))))
+ return (FNM_NOMATCH);
+
+ p = BRACKMATCH (p, sc, flags);
+ if (p == 0)
+ return FNM_NOMATCH;
+ }
+ break;
+
+ default:
+ if ((U_CHAR)c != FOLD (sc))
+ return (FNM_NOMATCH);
+ }
+
+ ++n;
+ }
+
+ if (n == se)
+ return (0);
+
+ if ((flags & FNM_LEADING_DIR) && *n == L('/'))
+ /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */
+ return 0;
+
+ return (FNM_NOMATCH);
+}
+
+/* Parse a bracket expression collating symbol ([.sym.]) starting at P, find
+ the value of the symbol, and move P past the collating symbol expression.
+ The value is returned in *VP, if VP is not null. */
+static CHAR *
+PARSE_COLLSYM (p, vp)
+ CHAR *p;
+ INT *vp;
+{
+ register int pc;
+ INT val;
+
+ p++; /* move past the `.' */
+
+ for (pc = 0; p[pc]; pc++)
+ if (p[pc] == L('.') && p[pc+1] == L(']'))
+ break;
+ val = COLLSYM (p, pc);
+ if (vp)
+ *vp = val;
+ return (p + pc + 2);
+}
+
+/* Use prototype definition here because of type promotion. */
+static CHAR *
+#if defined (PROTOTYPES)
+BRACKMATCH (CHAR *p, U_CHAR test, int flags)
+#else
+BRACKMATCH (p, test, flags)
+ CHAR *p;
+ U_CHAR test;
+ int flags;
+#endif
+{
+ register CHAR cstart, cend, c;
+ register int not; /* Nonzero if the sense of the character class is inverted. */
+ int brcnt;
+ INT pc;
+ CHAR *savep;
+
+ test = FOLD (test);
+
+ savep = p;
+
+ /* POSIX.2 3.13.1 says that an exclamation mark (`!') shall replace the
+ circumflex (`^') in its role in a `nonmatching list'. A bracket
+ expression starting with an unquoted circumflex character produces
+ unspecified results. This implementation treats the two identically. */
+ if (not = (*p == L('!') || *p == L('^')))
+ ++p;
+
+ c = *p++;
+ for (;;)
+ {
+ /* Initialize cstart and cend in case `-' is the last
+ character of the pattern. */
+ cstart = cend = c;
+
+ /* POSIX.2 equivalence class: [=c=]. See POSIX.2 2.8.3.2. Find
+ the end of the equivalence class, move the pattern pointer past
+ it, and check for equivalence. XXX - this handles only
+ single-character equivalence classes, which is wrong, or at
+ least incomplete. */
+ if (c == L('[') && *p == L('=') && p[2] == L('=') && p[3] == L(']'))
+ {
+ pc = FOLD (p[1]);
+ p += 4;
+ if (COLLEQUIV (test, pc))
+ {
+/*[*/ /* Move past the closing `]', since the first thing we do at
+ the `matched:' label is back p up one. */
+ p++;
+ goto matched;
+ }
+ else
+ {
+ c = *p++;
+ if (c == L('\0'))
+ return ((test == L('[')) ? savep : (CHAR *)0); /*]*/
+ c = FOLD (c);
+ continue;
+ }
+ }
+
+ /* POSIX.2 character class expression. See POSIX.2 2.8.3.2. */
+ if (c == L('[') && *p == L(':'))
+ {
+ CHAR *close, *ccname;
+
+ pc = 0; /* make sure invalid char classes don't match. */
+ /* Find end of character class name */
+ for (close = p + 1; *close != '\0'; close++)
+ if (*close == L(':') && *(close+1) == L(']'))
+ break;
+
+ if (*close != L('\0'))
+ {
+ ccname = (CHAR *)malloc ((close - p) * sizeof (CHAR));
+ if (ccname == 0)
+ pc = 0;
+ else
+ {
+ bcopy (p + 1, ccname, (close - p - 1) * sizeof (CHAR));
+ *(ccname + (close - p - 1)) = L('\0');
+ pc = IS_CCLASS (test, (XCHAR *)ccname);
+ }
+ if (pc == -1)
+ pc = 0;
+ else
+ p = close + 2;
+
+ free (ccname);
+ }
+
+ if (pc)
+ {
+/*[*/ /* Move past the closing `]', since the first thing we do at
+ the `matched:' label is back p up one. */
+ p++;
+ goto matched;
+ }
+ else
+ {
+ /* continue the loop here, since this expression can't be
+ the first part of a range expression. */
+ c = *p++;
+ if (c == L('\0'))
+ return ((test == L('[')) ? savep : (CHAR *)0);
+ else if (c == L(']'))
+ break;
+ c = FOLD (c);
+ continue;
+ }
+ }
+
+ /* POSIX.2 collating symbols. See POSIX.2 2.8.3.2. Find the end of
+ the symbol name, make sure it is terminated by `.]', translate
+ the name to a character using the external table, and do the
+ comparison. */
+ if (c == L('[') && *p == L('.'))
+ {
+ p = PARSE_COLLSYM (p, &pc);
+ /* An invalid collating symbol cannot be the first point of a
+ range. If it is, we set cstart to one greater than `test',
+ so any comparisons later will fail. */
+ cstart = (pc == INVALID) ? test + 1 : pc;
+ }
+
+ if (!(flags & FNM_NOESCAPE) && c == L('\\'))
+ {
+ if (*p == '\0')
+ return (CHAR *)0;
+ cstart = cend = *p++;
+ }
+
+ cstart = cend = FOLD (cstart);
+
+ /* POSIX.2 2.8.3.1.2 says: `An expression containing a `[' that
+ is not preceded by a backslash and is not part of a bracket
+ expression produces undefined results.' This implementation
+ treats the `[' as just a character to be matched if there is
+ not a closing `]'. */
+ if (c == L('\0'))
+ return ((test == L('[')) ? savep : (CHAR *)0);
+
+ c = *p++;
+ c = FOLD (c);
+
+ if ((flags & FNM_PATHNAME) && c == L('/'))
+ /* [/] can never match when matching a pathname. */
+ return (CHAR *)0;
+
+ /* This introduces a range, unless the `-' is the last
+ character of the class. Find the end of the range
+ and move past it. */
+ if (c == L('-') && *p != L(']'))
+ {
+ cend = *p++;
+ if (!(flags & FNM_NOESCAPE) && cend == L('\\'))
+ cend = *p++;
+ if (cend == L('\0'))
+ return (CHAR *)0;
+ if (cend == L('[') && *p == L('.'))
+ {
+ p = PARSE_COLLSYM (p, &pc);
+ /* An invalid collating symbol cannot be the second part of a
+ range expression. If we get one, we set cend to one fewer
+ than the test character to make sure the range test fails. */
+ cend = (pc == INVALID) ? test - 1 : pc;
+ }
+ cend = FOLD (cend);
+
+ c = *p++;
+
+ /* POSIX.2 2.8.3.2: ``The ending range point shall collate
+ equal to or higher than the starting range point; otherwise
+ the expression shall be treated as invalid.'' Note that this
+ applies to only the range expression; the rest of the bracket
+ expression is still checked for matches. */
+ if (RANGECMP (cstart, cend) > 0)
+ {
+ if (c == L(']'))
+ break;
+ c = FOLD (c);
+ continue;
+ }
+ }
+
+ if (RANGECMP (test, cstart) >= 0 && RANGECMP (test, cend) <= 0)
+ goto matched;
+
+ if (c == L(']'))
+ break;
+ }
+ /* No match. */
+ return (!not ? (CHAR *)0 : p);
+
+matched:
+ /* Skip the rest of the [...] that already matched. */
+ c = *--p;
+ brcnt = 1;
+ while (brcnt > 0)
+ {
+ /* A `[' without a matching `]' is just another character to match. */
+ if (c == L('\0'))
+ return ((test == L('[')) ? savep : (CHAR *)0);
+
+ c = *p++;
+ if (c == L('[') && (*p == L('=') || *p == L(':') || *p == L('.')))
+ brcnt++;
+ else if (c == L(']'))
+ brcnt--;
+ else if (!(flags & FNM_NOESCAPE) && c == L('\\'))
+ {
+ if (*p == '\0')
+ return (CHAR *)0;
+ /* XXX 1003.2d11 is unclear if this is right. */
+ ++p;
+ }
+ }
+ return (not ? (CHAR *)0 : p);
+}
+
+#if defined (EXTENDED_GLOB)
+/* ksh-like extended pattern matching:
+
+ [?*+@!](pat-list)
+
+ where pat-list is a list of one or patterns separated by `|'. Operation
+ is as follows:
+
+ ?(patlist) match zero or one of the given patterns
+ *(patlist) match zero or more of the given patterns
+ +(patlist) match one or more of the given patterns
+ @(patlist) match exactly one of the given patterns
+ !(patlist) match anything except one of the given patterns
+*/
+
+/* Scan a pattern starting at STRING and ending at END, keeping track of
+ embedded () and []. If DELIM is 0, we scan until a matching `)'
+ because we're scanning a `patlist'. Otherwise, we scan until we see
+ DELIM. In all cases, we never scan past END. The return value is the
+ first character after the matching DELIM. */
+static CHAR *
+PATSCAN (string, end, delim)
+ CHAR *string, *end;
+ INT delim;
+{
+ int pnest, bnest;
+ INT cchar;
+ CHAR *s, c, *bfirst;
+
+ pnest = bnest = 0;
+ cchar = 0;
+ bfirst = NULL;
+
+ for (s = string; c = *s; s++)
+ {
+ if (s >= end)
+ return (s);
+ switch (c)
+ {
+ case L('\\'):
+ continue;
+
+ case L('\0'):
+ return ((CHAR *)NULL);
+
+ /* `[' is not special inside a bracket expression, but it may
+ introduce one of the special POSIX bracket expressions
+ ([.SYM.], [=c=], [: ... :]) that needs special handling. */
+ case L('['):
+ if (bnest == 0)
+ {
+ bfirst = s + 1;
+ if (*bfirst == L('!') || *bfirst == L('^'))
+ bfirst++;
+ bnest++;
+ }
+ else if (s[1] == L(':') || s[1] == L('.') || s[1] == L('='))
+ cchar = s[1];
+ break;
+
+ /* `]' is not special if it's the first char (after a leading `!'
+ or `^') in a bracket expression or if it's part of one of the
+ special POSIX bracket expressions ([.SYM.], [=c=], [: ... :]) */
+ case L(']'):
+ if (bnest)
+ {
+ if (cchar && s[-1] == cchar)
+ cchar = 0;
+ else if (s != bfirst)
+ {
+ bnest--;
+ bfirst = 0;
+ }
+ }
+ break;
+
+ case L('('):
+ if (bnest == 0)
+ pnest++;
+ break;
+
+ case L(')'):
+ if (bnest == 0 && pnest-- <= 0)
+ return ++s;
+ break;
+
+ case L('|'):
+ if (bnest == 0 && pnest == 0 && delim == L('|'))
+ return ++s;
+ break;
+ }
+ }
+
+ return (NULL);
+}
+
+/* Return 0 if dequoted pattern matches S in the current locale. */
+static int
+STRCOMPARE (p, pe, s, se)
+ CHAR *p, *pe, *s, *se;
+{
+ int ret;
+ CHAR c1, c2;
+
+ c1 = *pe;
+ c2 = *se;
+
+ *pe = *se = '\0';
+#if HAVE_MULTIBYTE || defined (HAVE_STRCOLL)
+ ret = STRCOLL ((XCHAR *)p, (XCHAR *)s);
+#else
+ ret = STRCMP ((XCHAR *)p, (XCHAR *)s);
+#endif
+
+ *pe = c1;
+ *se = c2;
+
+ return (ret == 0 ? ret : FNM_NOMATCH);
+}
+
+/* Match a ksh extended pattern specifier. Return FNM_NOMATCH on failure or
+ 0 on success. This is handed the entire rest of the pattern and string
+ the first time an extended pattern specifier is encountered, so it calls
+ gmatch recursively. */
+static int
+EXTMATCH (xc, s, se, p, pe, flags)
+ INT xc; /* select which operation */
+ CHAR *s, *se;
+ CHAR *p, *pe;
+ int flags;
+{
+ CHAR *prest; /* pointer to rest of pattern */
+ CHAR *psub; /* pointer to sub-pattern */
+ CHAR *pnext; /* pointer to next sub-pattern */
+ CHAR *srest; /* pointer to rest of string */
+ int m1, m2;
+
+#if DEBUG_MATCHING
+fprintf(stderr, "extmatch: xc = %c\n", xc);
+fprintf(stderr, "extmatch: s = %s; se = %s\n", s, se);
+fprintf(stderr, "extmatch: p = %s; pe = %s\n", p, pe);
+#endif
+
+ prest = PATSCAN (p + (*p == L('(')), pe, 0); /* ) */
+ if (prest == 0)
+ /* If PREST is 0, we failed to scan a valid pattern. In this
+ case, we just want to compare the two as strings. */
+ return (STRCOMPARE (p - 1, pe, s, se));
+
+ switch (xc)
+ {
+ case L('+'): /* match one or more occurrences */
+ case L('*'): /* match zero or more occurrences */
+ /* If we can get away with no matches, don't even bother. Just
+ call GMATCH on the rest of the pattern and return success if
+ it succeeds. */
+ if (xc == L('*') && (GMATCH (s, se, prest, pe, flags) == 0))
+ return 0;
+
+ /* OK, we have to do this the hard way. First, we make sure one of
+ the subpatterns matches, then we try to match the rest of the
+ string. */
+ for (psub = p + 1; ; psub = pnext)
+ {
+ pnext = PATSCAN (psub, pe, L('|'));
+ for (srest = s; srest <= se; srest++)
+ {
+ /* Match this substring (S -> SREST) against this
+ subpattern (psub -> pnext - 1) */
+ m1 = GMATCH (s, srest, psub, pnext - 1, flags) == 0;
+ /* OK, we matched a subpattern, so make sure the rest of the
+ string matches the rest of the pattern. Also handle
+ multiple matches of the pattern. */
+ if (m1)
+ m2 = (GMATCH (srest, se, prest, pe, flags) == 0) ||
+ (s != srest && GMATCH (srest, se, p - 1, pe, flags) == 0);
+ if (m1 && m2)
+ return (0);
+ }
+ if (pnext == prest)
+ break;
+ }
+ return (FNM_NOMATCH);
+
+ case L('?'): /* match zero or one of the patterns */
+ case L('@'): /* match exactly one of the patterns */
+ /* If we can get away with no matches, don't even bother. Just
+ call gmatch on the rest of the pattern and return success if
+ it succeeds. */
+ if (xc == L('?') && (GMATCH (s, se, prest, pe, flags) == 0))
+ return 0;
+
+ /* OK, we have to do this the hard way. First, we see if one of
+ the subpatterns matches, then, if it does, we try to match the
+ rest of the string. */
+ for (psub = p + 1; ; psub = pnext)
+ {
+ pnext = PATSCAN (psub, pe, L('|'));
+ srest = (prest == pe) ? se : s;
+ for ( ; srest <= se; srest++)
+ {
+ if (GMATCH (s, srest, psub, pnext - 1, flags) == 0 &&
+ GMATCH (srest, se, prest, pe, flags) == 0)
+ return (0);
+ }
+ if (pnext == prest)
+ break;
+ }
+ return (FNM_NOMATCH);
+
+ case '!': /* match anything *except* one of the patterns */
+ for (srest = s; srest <= se; srest++)
+ {
+ m1 = 0;
+ for (psub = p + 1; ; psub = pnext)
+ {
+ pnext = PATSCAN (psub, pe, L('|'));
+ /* If one of the patterns matches, just bail immediately. */
+ if (m1 = (GMATCH (s, srest, psub, pnext - 1, flags) == 0))
+ break;
+ if (pnext == prest)
+ break;
+ }
+ if (m1 == 0 && GMATCH (srest, se, prest, pe, flags) == 0)
+ return (0);
+ }
+ return (FNM_NOMATCH);
+ }
+
+ return (FNM_NOMATCH);
+}
+#endif /* EXTENDED_GLOB */
+
+#undef IS_CCLASS
+#undef FOLD
+#undef CHAR
+#undef U_CHAR
+#undef XCHAR
+#undef INT
+#undef INVALID
+#undef FCT
+#undef GMATCH
+#undef COLLSYM
+#undef PARSE_COLLSYM
+#undef PATSCAN
+#undef STRCOMPARE
+#undef EXTMATCH
+#undef BRACKMATCH
+#undef STRCHR
+#undef STRCOLL
+#undef STRLEN
+#undef STRCMP
+#undef COLLEQUIV
+#undef RANGECMP
+#undef L
static void _rl_init_file_error PARAMS((const char *));
static int _rl_read_init_file PARAMS((const char *, int));
static int glean_key_from_name PARAMS((char *));
+static int find_boolean_var PARAMS((const char *));
+
static char *_rl_get_string_variable_value PARAMS((const char *));
static int substring_member_of_array PARAMS((char *, const char **));
*value++ = '\0';
while (*value && whitespace (*value)) value++;
- /* remove trailing whitespace */
- e = value + strlen (value) - 1;
- while (e >= value && whitespace (*e))
- e--;
- e++; /* skip back to whitespace or EOS */
- if (*e && e >= value)
- *e = '\0';
+ /* Strip trailing whitespace from values to boolean variables. Temp
+ fix until I get a real quoted-string parser here. */
+ i = find_boolean_var (var);
+ if (i >= 0)
+ {
+ /* remove trailing whitespace */
+ e = value + strlen (value) - 1;
+ while (e >= value && whitespace (*e))
+ e--;
+ e++; /* skip back to whitespace or EOS */
+ if (*e && e >= value)
+ *e = '\0';
+ }
rl_variable_bind (var, value);
return 0;
/* bind.c -- key binding and startup file support for the readline library. */
-/* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2005 Free Software Foundation, Inc.
This file is part of the GNU Readline Library, a library for
reading lines of text with interactive input and history editing.
static void _rl_init_file_error PARAMS((const char *));
static int _rl_read_init_file PARAMS((const char *, int));
static int glean_key_from_name PARAMS((char *));
+static int find_boolean_var PARAMS((const char *));
+
static char *_rl_get_string_variable_value PARAMS((const char *));
static int substring_member_of_array PARAMS((char *, const char **));
k.function = 0;
/* If no keys to bind to, exit right away. */
- if (!keyseq || !*keyseq)
+ if (keyseq == 0 || *keyseq == 0)
{
if (type == ISMACR)
free (data);
*value++ = '\0';
while (*value && whitespace (*value)) value++;
- /* remove trailing whitespace */
- e = value + strlen (value) - 1;
- while (e >= value && whitespace (*e))
- e--;
- e++; /* skip back to whitespace or EOS */
- if (*e && e >= value)
- *e = '\0';
+ /* Strip trailing whitespace from values to boolean variables. Temp
+ fix until I get a real quoted-string parser here. */
+ i = find_boolean_var (var);
+
+ if (i >= 0)
+ {
+ /* remove trailing whitespace */
+ e = value + strlen (value) - 1;
+ while (e >= value && whitespace (*e))
+ e--;
+ e++; /* skip back to whitespace or EOS */
+ if (*e && e >= value)
+ *e = '\0';
+ }
rl_variable_bind (var, value);
return 0;
return (*boolean_varlist[i].value ? "on" : "off");
i = find_string_var (name);
+ if (i >= 0)
+ return (_rl_get_string_variable_value (string_varlist[i].name));
/* Unknown variable names return NULL. */
- if (i < 0)
- return 0;
-
- return (_rl_get_string_variable_value (string_varlist[i].name));
+ return 0;
}
int
#define RL_STATE_CALLBACK 0x080000 /* using the callback interface */
#define RL_STATE_VIMOTION 0x100000 /* reading vi motion arg */
#define RL_STATE_MULTIKEY 0x200000 /* reading multiple-key command */
+#define RL_STATE_VICMDONCE 0x400000 /* entered vi command mode at least once */
#define RL_STATE_DONE 0x800000 /* done; accepted line */
{
while (rl_undo_list)
rl_do_undo ();
+#if defined (VI_MODE)
+ if (rl_editing_mode == vi_mode)
+ rl_point = rl_mark = 0; /* rl_end should be set correctly */
+#endif
}
+
return 0;
}
for (i = 0; i < sizeof (vi_mark_chars) / sizeof (int); i++)
vi_mark_chars[i] = -1;
+
+ RL_UNSETSTATE(RL_STATE_VICMDONCE);
}
void
_rl_keymap = vi_movement_keymap;
_rl_vi_done_inserting ();
+
+ /* This is how POSIX.2 says `U' should behave -- everything up until the
+ first time you go into command mode should not be undone. */
+ if (RL_ISSTATE (RL_STATE_VICMDONCE) == 0)
+ rl_free_undo_list ();
+
+ RL_SETSTATE (RL_STATE_VICMDONCE);
return (0);
}
redirector = redirect->redirector;
ri = redirect->instruction;
+if (redirect->flags & RX_INTERNAL)
+ flags |= RX_INTERNAL;
+
if (TRANSLATE_REDIRECT (ri))
{
/* We have [N]>&WORD[-] or [N]<&WORD[-]. Expand WORD, then translate
always be open. */
/* if ((already_set || set_unconditionally) && (ok_to_set))
set_it () */
+#if 0
if (((fcntl (redir_fd, F_GETFD, 0) == 1) || redir_fd < 2 || (flags & RX_CLEXEC)) &&
(redirector > 2))
+#else
+ if (((fcntl (redir_fd, F_GETFD, 0) == 1) || (redir_fd < 2 && (flags & RX_INTERNAL)) || (flags & RX_CLEXEC)) &&
+ (redirector > 2))
+#endif
SET_CLOSE_ON_EXEC (redirector);
/* dup-and-close redirection */
rd.dest = 0;
closer = make_redirection (new_fd, r_close_this, rd);
+ closer->flags |= RX_INTERNAL;
dummy_redirect = copy_redirects (closer);
rd.dest = new_fd;
new_redirect = make_redirection (fd, r_duplicating_input, rd);
else
new_redirect = make_redirection (fd, r_duplicating_output, rd);
+ new_redirect->flags |= RX_INTERNAL;
new_redirect->next = closer;
closer->next = redirection_undo_list;
rd.dest = 0;
closer = make_redirection (fd, r_close_this, rd);
+ closer->flags |= RX_INTERNAL;
closer->next = redirection_undo_list;
redirection_undo_list = closer;
}
#define RX_ACTIVE 0x01 /* do it; don't just go through the motions */
#define RX_UNDOABLE 0x02 /* make a list to undo these redirections */
#define RX_CLEXEC 0x04 /* set close-on-exec for opened fds > 2 */
+#define RX_INTERNAL 0x08
+#define RX_USER 0x10
extern void redirection_error __P((REDIRECT *, int));
extern int do_redirections __P((REDIRECT *, int));
*sindex = slen - 1;
return ret;
}
+ return 0;
}
#endif
td.flags = W_ASSIGNMENT;
td.word = string;
- do_assignment_internal (&td, 0);
+ return (do_assignment_internal (&td, 0));
}
/***************************************************
static char location_base[NULL_TERMINATED(MED_STR_MAX)] = "";
+static char th_page_and_sec[128] = { '\0' };
+static char th_datestr[128] = { '\0' };
+static char th_version[128] = { '\0' };
+
char *signature = "<HR>\nThis document was created by man2html from %s.<BR>\nTime: %s\n";
/* timeformat for signature */
return c;
}
+static void
+outputPageHeader(char *l, char *c, char *r)
+{
+ out_html("<TABLE WIDTH=100%>\n<TR>\n");
+ out_html("<TH ALIGN=LEFT width=33%>");
+ out_html(l);
+ out_html("<TH ALIGN=CENTER width=33%>");
+ out_html(c);
+ out_html("<TH ALIGN=RIGHT width=33%>");
+ out_html(r);
+ out_html("\n</TR>\n</TABLE>\n");
+}
+
+static void
+outputPageFooter(char *l, char *c, char *r)
+{
+ out_html("<HR>\n");
+ outputPageHeader(l, c, r);
+}
+
static int ifelseval = 0;
static char *
out_html(label);
/* for mosaic users */
if (mode)
- out_html("\"> </A>\n<H3>");
+ out_html("\"> </A>\n<H4>");
else
- out_html("\"> </A>\n<H2>");
+ out_html("\"> </A>\n<H3>");
mandoc_synopsis = strncmp(c, "SYNOPSIS", 8) == 0;
c = mandoc_command ? scan_troff_mandoc(c, 1, NULL) : scan_troff(c, 1, NULL);
if (mode)
- out_html("</H3>\n");
+ out_html("</H4>\n");
else
- out_html("</H2>\n");
+ out_html("</H3>\n");
curpos = 0;
break;
case V('T', 'S'):
if (!output_possible) {
sl = fill_words(c + j, wordlist, &words);
if (words > 1) {
- char page_and_sec[128];
-
+ char *t;
for (i = 1; i < words; i++)
wordlist[i][-1] = '\0';
*sl = '\0';
output_possible = 1;
- sprintf(page_and_sec, "%s(%s)", wordlist[0], wordlist[1]);
+ sprintf(th_page_and_sec, "%s(%s)", wordlist[0], wordlist[1]);
+ if (words > 2) {
+ t = unescape(wordlist[2]);
+ strncpy(th_datestr, t, sizeof(th_datestr));
+ th_datestr[sizeof(th_datestr) - 1] = '\0';
+ } else
+ th_datestr[0] = '\0';
+ if (words > 3) {
+ t = unescape(wordlist[3]);
+ strncpy(th_version, t, sizeof(th_version));
+ th_version[sizeof(th_version) - 1] = '\0';
+ } else
+ th_version[0] = '\0';
out_html("<HTML><HEAD>\n<TITLE>");
- out_html(page_and_sec);
+ out_html(th_page_and_sec);
out_html(" Manual Page");
out_html("</TITLE>\n</HEAD>\n<BODY>");
- out_html("<TABLE WIDTH=100%>\n");
- out_html("<TH ALIGN=LEFT>");
- out_html(page_and_sec);
- out_html("<TH ALIGN=CENTER>");
- out_html(unescape(wordlist[2]));
- out_html("<TH ALIGN=RIGHT>");
- out_html(page_and_sec);
- out_html("\n</TABLE>\n");
+
+ outputPageHeader(th_page_and_sec, th_datestr, th_page_and_sec);
+
out_html("<BR><A HREF=\"#index\">Index</A>\n");
*sl = '\n';
out_html("<HR>\n");
out_html(NEWLINE);
if (output_possible) {
+ outputPageFooter(th_version, th_datestr, th_page_and_sec);
/* for mosaic users */
fputs("<HR>\n<A NAME=\"index\"> </A><H2>Index</H2>\n<DL>\n", stdout);
manidx[mip] = 0;
-BUILD_DIR=/usr/local/build/bash/bash-current
+BUILD_DIR=/usr/local/build/chet/bash/bash-current
THIS_SH=$BUILD_DIR/bash
PATH=$PATH:$BUILD_DIR
}`
echo c4 is $c
+# fixed in bash-3.1
+echo 'exec <&3' | ${THIS_SH} 3<&0
projects / thirdparty / bash.git / commitdiff
