Learn how easy it is to sync an existing GitHub or Google Code repo to a SourceForge project! See Demo

Close

Commit [458129] default Maximize Restore History

synched witb GNU Savannah CVS

sds sds 2003-12-10

<< < 1 .. 5 6 7 (Page 7 of 7)
added impnotes/terminal.html
added impnotes/tokens.html
added impnotes/type-class-dict.html
added impnotes/type-class-int.html
added impnotes/types-classes.html
added impnotes/unspecific.html
added impnotes/valid-patterns.html
added impnotes/vm.html
added impnotes/weak.html
added wanted.html
added wildcard.html
removed fibjap-emacs.gif
removed fibjap-xterm.gif
removed fibjap.lsp
copied clreadline.html -> regexp.html
copied patent_button.gif -> patent_button.png
impnotes/terminal.html Diff Switch to side-by-side view
Loading...
impnotes/tokens.html Diff Switch to side-by-side view
Loading...
impnotes/type-class-dict.html Diff Switch to side-by-side view
Loading...
impnotes/type-class-int.html Diff Switch to side-by-side view
Loading...
impnotes/types-classes.html Diff Switch to side-by-side view
Loading...
impnotes/unspecific.html Diff Switch to side-by-side view
Loading...
impnotes/valid-patterns.html Diff Switch to side-by-side view
Loading...
impnotes/vm.html Diff Switch to side-by-side view
Loading...
impnotes/weak.html Diff Switch to side-by-side view
Loading...
wanted.html Diff Switch to side-by-side view
Loading...
wildcard.html Diff Switch to side-by-side view
Loading...
fibjap-emacs.gif
File was removed.
fibjap-xterm.gif
File was removed.
fibjap.lsp
File was removed.
clreadline.html to regexp.html
--- a/clreadline.html
+++ b/regexp.html
@@ -1,1006 +1,776 @@
+<HTML>
 <HEAD>
-<TITLE> CLISP-READLINE manual page </TITLE>
+<!-- Created by texi2html 1.56k from regexp.texinfo on 12 September 2001 -->
+
+<TITLE>Untitled Document</TITLE>
 </HEAD>
 <BODY>
-<H1>CLISP-READLINE manual page</H1>
-
+<H1>Untitled Document</H1>
+<P>
+<P><HR><P>
+<H1>Table of Contents</H1>
 <UL>
-<LI> <A HREF="#Name">Name</A>
-<LI> <A HREF="#Notation">Notation</A>
-<LI> <A HREF="#Initialization File">Initialization File</A>
-     <UL>
-     <LI> <A HREF="#Key Bindings">Key Bindings</A>
-     <LI> <A HREF="#Variables">Variables</A>
-     <LI> <A HREF="#Conditional Constructs">Conditional Constructs</A>
-     </UL>
-<LI> <A HREF="#Searching">Searching</A>
-<LI> <A HREF="#Editing Commands">Editing Commands</A>
-     <UL>
-     <LI> <A HREF="#Commands for Moving">Commands for Moving</A>
-     <LI> <A HREF="#Commands for Manipulating the History">Commands for Manipulating the History</A>
-     <LI> <A HREF="#Commands for Changing Text">Commands for Changing Text</A>
-     <LI> <A HREF="#Killing and Yanking">Killing and Yanking</A>
-     <LI> <A HREF="#Numeric Arguments">Numeric Arguments</A>
-     <LI> <A HREF="#Completing">Completing</A>
-     <LI> <A HREF="#Keyboard Macros">Keyboard Macros</A>
-     <LI> <A HREF="#Miscellaneous"></A>
-     </UL>
-<LI> <A HREF="#Default Key Bindings">Default Key Bindings</A>
-     <UL>
-     <LI> <A HREF="#Key Bindings in Emacs Mode">Emacs Mode</A>
-     <LI> <A HREF="#Key Bindings in VI Mode">VI Mode bindings</A>
-     </UL>
-<LI> <A HREF="#See also">See also</A>
-<LI> <A HREF="#Files">Files</A>
-<LI> <A HREF="#Authors">Authors</A>
-<LI> <A HREF="#Bug Reports">Bug Reports</A>
-<LI> <A HREF="#Bugs">Bugs</A>
+<LI><A NAME="TOC1" HREF="regexp.html#SEC1">Regular expressions</A>
+<LI><A NAME="TOC2" HREF="regexp.html#SEC2">Regular Expressions</A>
+<UL>
+<LI><A NAME="TOC3" HREF="regexp.html#SEC3">Syntax of Regular Expressions</A>
 </UL>
-<P>
-
-<HR>
-
-<H2><A NAME="Name">Name</A></H2>
-
-readline - get a line from a user with editing
-
-<H2><A NAME="Notation">Notation</A></H2>
-
-An  emacs-style  notation  is  used  to denote keystrokes.
-Control keys are denoted by <SAMP>C-</SAMP><VAR>key</VAR>,
-e.g.,  <SAMP>C-n</SAMP>  means  Control-<KBD>N</KBD>.  Similarly, <i>meta</i>
-keys are denoted by <SAMP>M-</SAMP><VAR>key</VAR> , so <SAMP>M-x</SAMP>
-means Meta-<KBD>X</KBD>.  (On keyboards without a <i>meta</i>
- key, <SAMP>M-</SAMP><VAR>x</VAR>
- means ESC <VAR>x</VAR> ,  i.e.,  press the Escape key then the <VAR>x</VAR>
- key.  This
-makes ESC the <i>meta prefix</i>.  The  combination  <SAMP>M-C-</SAMP><VAR>x</VAR>
-  means ESC-Control-<VAR>x</VAR> ,  or press the Escape key then hold the Control key while pressing the <i>x</i>
- key.)
-<P>
-
-Readline commands may be given  numeric  <i>arguments</i>,  which
-normally act as a repeat count.  Sometimes, however, it is
-the sign of the argument that is significant.   Passing  a
-negative  argument  to  a command that acts in the forward
-direction (e.g., <A HREF="#kill-line"><CODE>kill-line</CODE></A>) causes that command to act  in
-a  backward direction.  Commands whose behavior with arguments deviates from this are noted.
-<P>
-
-When a command is described  as  <i>killing</i> text,  the  text
-deleted  is saved for possible future retrieval (<i>yanking</i>).
-The killed text is  saved  in  a  <i>kill ring</i>.   Consecutive
-kills  cause  the  text  to  be accumulated into one unit,
-which can be yanked all at once.  Commands  which  do  not
-kill text separate the chunks of text on the kill ring.
-
-<H2><A NAME="Initialization File">Initialization File</A></H2>
-
-Readline  is customized by putting commands in an initialization
-file (the <A HREF="#~/.inputrc"><I>inputrc</I></A> file).
-The name of this file  is  taken  from  the
-value of the <CODE>INPUTRC</CODE> environment variable.
-If that variable is unset, the default is <A HREF="#~/.inputrc"><CODE>~/.inputrc</CODE></A>.
-When a program which uses the
-readline library starts up, the init file is read, and the
-key bindings and variables are set.  There are only a  few
-basic constructs allowed in the readline init file.  Blank
-lines are ignored.  Lines beginning with a <CODE>#</CODE> are comments.
-Lines  beginning with a <CODE>$</CODE> indicate conditional constructs.
-Other lines denote key  bindings  and  variable  settings.
-Each  program  using this library may add its own commands
-and bindings.
-<P>
-
-For example, placing
-<BLOCKQUOTE>
-<CODE>M-Control-u: universal-argument</CODE>
-</BLOCKQUOTE>
-or
-<BLOCKQUOTE>
-<CODE>C-Meta-u: universal-argument</CODE>
-</BLOCKQUOTE>
-into the <A HREF="#~/.inputrc"><I>inputrc</I></A> would make <SAMP>M-C-u</SAMP> execute the  readline
-command <A HREF="#universal-argument"><CODE>universal-argument</CODE></A>.
-<P>
-
-The  following  symbolic  character  names  are recognized
-while processing key bindings:
-<CODE>RUBOUT</CODE>, <CODE>DEL</CODE>, <CODE>ESC</CODE>, <CODE>LFD</CODE>,
-<CODE>NEWLINE</CODE>,  <CODE>RET</CODE>,  <CODE>RETURN</CODE>,  <CODE>SPC</CODE>,
-<CODE>SPACE</CODE>, and <CODE>TAB</CODE>.  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>).
-<P>
-
-<H3><A NAME="Key Bindings">Key Bindings</A></H3>
-
-The syntax for controlling key bindings in the  <A HREF="#~/.inputrc"><I>inputrc</I></A>
-file  is  simple.  All that is required is the name of the
-command or the text of a macro and a key sequence to which
-it  should  be  bound. The name may be specified in one of
-two ways: as a symbolic key name, possibly with  <CODE>Meta-</CODE> or
-<CODE>Control-</CODE> prefixes,  or as a key sequence.  When using the
-form
-<BLOCKQUOTE>
-<VAR>keyname</VAR><CODE>:</CODE> <VAR>function-name</VAR> or <VAR>macro</VAR>
-</BLOCKQUOTE>
-<VAR>keyname</VAR> is  the  name
-of a key spelled out in English.  For example:
-<BLOCKQUOTE>
-<PRE><CODE>Control-u: universal-argument
-Meta-Rubout: backward-kill-word
-Control-o: "&gt;&amp;output"
-</CODE></PRE>
-</BLOCKQUOTE>
-In the above example, <SAMP>C-u</SAMP>
- is bound to the function <A HREF="#universal-argument"><CODE>universal-argument</CODE></A>,  <SAMP>M-DEL</SAMP>
-  is  bound  to  the  function   <A HREF="#backward-kill-word"><CODE>backward-kill-word</CODE></A>,   and  <SAMP>C-o</SAMP>
-  is  bound  to  run  the  macro
-expressed on the right hand side (that is, to  insert  the
-text <SAMP>>&amp;output</SAMP>
- into the line).
-<P>
-
-In  the second form,
-<BLOCKQUOTE>
-<CODE>"</CODE><VAR>keyseq</VAR><CODE>":</CODE><VAR>function-name</VAR>
- or <VAR>macro</VAR>
-</BLOCKQUOTE>
-<VAR>keyseq</VAR> differs from <VAR>keyname</VAR> above in that strings denoting an
-entire  key  sequence  may  be  specified  by  placing the
-sequence within double quotes.  Some GNU Emacs  style  key
-escapes can be used, as in the following example.
-<BLOCKQUOTE>
-<PRE><CODE>"\C-u": universal-argument
-"\C-x\C-r": re-read-init-file
-"\e[11~": "Function Key 1"
-</CODE></PRE>
-</BLOCKQUOTE>
-In  this  example, <SAMP>C-u</SAMP>
- is again bound to the function <A HREF="#universal-argument"><CODE>universal-argument</CODE></A>.   <SAMP>C-x C-r</SAMP>
-  is  bound  to  the   function <A HREF="#re-read-init-file"><CODE>re-read-init-file</CODE></A>,  and <SAMP>ESC [ 1 1 ~</SAMP>
- is bound to insert the
-text <TT>Function Key 1</TT>.  The full set of GNU Emacs style escape sequences is
+<LI><A NAME="TOC4" HREF="regexp.html#SEC4">Examples</A>
+<UL>
+<LI><A NAME="TOC5" HREF="regexp.html#SEC5">Complex Regexp Example</A>
+<LI><A NAME="TOC6" HREF="regexp.html#SEC6">Common Regular Expressions Used in Editing</A>
+</UL>
+<LI><A NAME="TOC7" HREF="regexp.html#SEC7">The Regular Expression Module</A>
+</UL>
+<P><HR><P>
+<P>
+@newindex {fn}
+
+
+
+
+<H1><A NAME="SEC1" HREF="regexp.html#TOC1">Regular expressions</A></H1>
+
+<P>
+Regular expressions are patterns used in selecting text.
+
+
+<P>
+In addition to a specifying string literals, regular expressions can
+represent classes of strings.  Strings thus represented are said to be
+matched by the corresponding regular expression.  If it is possible for
+a regular expression to match several strings in a line, then the
+left-most longest match is the one selected.
+
+
+<P>
+The following symbols are used in constructing regular expressions:
+
+
+<DL COMPACT>
+
+<DT><CODE><VAR>c</VAR></CODE>
+<DD>
+Any character <VAR>c</VAR> not listed below, including <SAMP>`{'</SAMP>, <SAMP>`}'</SAMP>,
+<SAMP>`('</SAMP>, <SAMP>`)'</SAMP>, <SAMP>`&#60;'</SAMP> and <SAMP>`&#62;'</SAMP>, matches itself.
+
+<DT><CODE>\<VAR>c</VAR></CODE>
+<DD>
+Any backslash-escaped character <VAR>c</VAR>, other than <SAMP>`{'</SAMP>,
+`<SAMP>`}'</SAMP>, <SAMP>`('</SAMP>, <SAMP>`)'</SAMP>, <SAMP>`&#60;'</SAMP>, <SAMP>`&#62;'</SAMP>, <SAMP>`b'</SAMP>, <SAMP>`B'</SAMP>,
+<SAMP>`w'</SAMP>, <SAMP>`W'</SAMP>, <SAMP>`+'</SAMP> and <SAMP>`?'</SAMP>, matches itself.
+
+Note that <SAMP>`\'</SAMP> also has special meaning in the read syntax of Lisp
+strings, and must be quoted with <SAMP>`\'</SAMP>.  For
+example, the regular expression that matches the <SAMP>`\'</SAMP> character is
+<SAMP>`\\'</SAMP>.  To write a Lisp string that contains the characters
+<SAMP>`\\'</SAMP>, Lisp syntax requires you to quote each <SAMP>`\'</SAMP> with another
+<SAMP>`\'</SAMP>.  Therefore, the read syntax for a regular expression matching
+<SAMP>`\'</SAMP> is <CODE>"\\\\"</CODE>.
+<DT><CODE>.</CODE>
+<DD>
+Matches any single character.
+
+<DT><CODE>[<VAR>char-class</VAR>]</CODE>
+<DD>
+Matches any single character in <VAR>char-class</VAR>.  To include a <SAMP>`]'</SAMP>
+in <VAR>char-class</VAR>, it must be the first character.  A range of
+characters may be specified by separating the end characters of the
+range with a <SAMP>`-'</SAMP>, e.g., <SAMP>`a-z'</SAMP> specifies the lower case
+characters.  The following literal expressions can also be used in
+<VAR>char-class</VAR> to specify sets of characters:
+
+
+<PRE>
+[:alnum:] [:cntrl:] [:lower:] [:space:]
+[:alpha:] [:digit:] [:print:] [:upper:]
+[:blank:] [:graph:] [:punct:] [:xdigit:]
+</PRE>
+
+If <SAMP>`-'</SAMP> appears as the first or last character of <VAR>char-class</VAR>,
+then it matches itself.  All other characters in <VAR>char-class</VAR> match
+themselves.
+
+Patterns in
+<VAR>char-class</VAR>
+of the form:
+
+<PRE>
+[.<VAR>col-elm</VAR>.]
+[=<VAR>col-elm</VAR>=]
+</PRE>
+
+where <VAR>col-elm</VAR> is a <EM>collating element</EM> are interpreted
+according to <CODE>locale (5)</CODE> (not currently supported).  See
+<CODE>regex (3)</CODE> for an explanation of these constructs.
+
+<DT><CODE>[^<VAR>char-class</VAR>]</CODE>
+<DD>
+Matches any single character, other than newline, not in
+<VAR>char-class</VAR>.  <VAR>char-class</VAR> is defined as above.
+
+<DT><CODE>^</CODE>
+<DD>
+If <SAMP>`^'</SAMP> is the first character of a regular expression, then it
+anchors the regular expression to the beginning of a line.  Otherwise,
+it matches itself.
+
+<DT><CODE>$</CODE>
+<DD>
+If <SAMP>`$'</SAMP> is the last character of a regular expression, it anchors
+the regular expression to the end of a line.  Otherwise, it matches
+itself.
+
+<DT><CODE>\(<VAR>re</VAR>\)</CODE>
+<DD>
+Defines a (possibly null) subexpression <VAR>re</VAR>.
+Subexpressions may be nested.  A
+subsequent backreference of the form <SAMP>`\<VAR>n</VAR>'</SAMP>, where <VAR>n</VAR> is a
+number in the range [1,9], expands to the text matched by the <VAR>n</VAR>th
+subexpression. For example, the regular expression <SAMP>`\(a.c\)\1'</SAMP> matches
+the string <SAMP>`abcabc'</SAMP>, but not <SAMP>`abcadc'</SAMP>.
+Subexpressions are ordered relative to their left delimiter.
+
+<DT><CODE>*</CODE>
+<DD>
+Matches the single character regular expression or subexpression
+immediately preceding it zero or more times.  If <SAMP>`*'</SAMP> is the first
+character of a regular expression or subexpression, then it matches
+itself.  The <SAMP>`*'</SAMP> operator sometimes yields unexpected results.  For
+example, the regular expression <SAMP>`b*'</SAMP> matches the beginning of the
+string <SAMP>`abbb'</SAMP>, as opposed to the substring <SAMP>`bbb'</SAMP>, since a
+null match is the only left-most match.
+
+<DT><CODE>\{<VAR>n,m</VAR>\}</CODE>
+<DD>
+<DT><CODE>\{<VAR>n,</VAR>\}</CODE>
+<DD>
+<DT><CODE>\{<VAR>n</VAR>\}</CODE>
+<DD>
+Matches the single character regular expression or subexpression
+immediately preceding it at least <VAR>n</VAR> and at most <VAR>m</VAR> times.  If
+<VAR>m</VAR> is omitted, then it matches at least <VAR>n</VAR> times.  If the
+comma is also omitted, then it matches exactly <VAR>n</VAR> times.
+If any of these forms occurs first in a regular expression or subexpression,
+then it is interpreted literally (i.e., the regular expression <SAMP>`\{2\}'</SAMP>
+matches the string <SAMP>`{2}'</SAMP>, and so on).
+
+<DT><CODE>\&#60;</CODE>
+<DD>
+<DT><CODE>\&#62;</CODE>
+<DD>
+Anchors the single character regular expression or subexpression
+immediately following it to the beginning (in the case of <SAMP>`\&#60;'</SAMP>)
+or ending (in the case of <SAMP>`\&#62;'</SAMP>) of
+a <EM>word</EM>, i.e., in ASCII, a maximal string of alphanumeric characters,
+including the underscore (_).
+
+</DL>
+
+<P>
+The following extended operators are preceded by a backslash <SAMP>`\'</SAMP> to
+distinguish them from traditional <CODE>ed</CODE> syntax.
+
+
+<DL COMPACT>
+
+<DT><CODE>\`</CODE>
+<DD>
+<DT><CODE>\'</CODE>
+<DD>
+Unconditionally matches the beginning <SAMP>`\`'</SAMP> or ending <SAMP>`\''</SAMP> of a line.
+
+<DT><CODE>\?</CODE>
+<DD>
+Optionally matches the single character regular expression or subexpression
+immediately preceding it.  For example, the regular expression <SAMP>`a[bd]\?c'</SAMP>
+matches the strings <SAMP>`abc'</SAMP>, <SAMP>`adc'</SAMP> and <SAMP>`ac'</SAMP>.
+If <SAMP>`\?'</SAMP> occurs at the beginning
+of a regular expressions or subexpression, then it matches a literal <SAMP>`?'</SAMP>.
+
+<DT><CODE>\+</CODE>
+<DD>
+Matches the single character regular expression or subexpression
+immediately preceding it one or more times.  So the regular expression
+<SAMP>`a+'</SAMP> is shorthand for <SAMP>`aa*'</SAMP>.  If <SAMP>`\+'</SAMP> occurs at the
+beginning of a regular expression or subexpression, then it matches a
+literal <SAMP>`+'</SAMP>.
+
+<DT><CODE>\b</CODE>
+<DD>
+Matches the beginning or ending (null string) of a word.  Thus the regular
+expression <SAMP>`\bhello\b'</SAMP> is equivalent to <SAMP>`\&#60;hello\&#62;'</SAMP>.
+However, <SAMP>`\b\b'</SAMP>
+is a valid regular expression whereas <SAMP>`\&#60;\&#62;'</SAMP> is not.
+
+<DT><CODE>\B</CODE>
+<DD>
+Matches (a null string) inside a word.
+
+<DT><CODE>\w</CODE>
+<DD>
+Matches any character in a word.
+
+<DT><CODE>\W</CODE>
+<DD>
+Matches any character not in a word.
+
+</DL>
+
+
+
+<H1><A NAME="SEC2" HREF="regexp.html#TOC2">Regular Expressions</A></H1>
+<P>
+<A NAME="IDX1"></A>
+<A NAME="IDX2"></A>
+
+
+<P>
+  A <EM>regular expression</EM> (<EM>regexp</EM>, for short) is a pattern that
+denotes a (possibly infinite) set of strings.  Searching for matches for
+a regexp is a very powerful operation.  This section explains how to write
+regexps; the following section says how to search for them.
+
+
+
+
+<H2><A NAME="SEC3" HREF="regexp.html#TOC3">Syntax of Regular Expressions</A></H2>
+
+<P>
+  Regular expressions have a syntax in which a few characters are special
+constructs and the rest are <EM>ordinary</EM>.  An ordinary character is a
+simple regular expression which matches that character and nothing else.
+The special characters are <SAMP>`$'</SAMP>, <SAMP>`^'</SAMP>, <SAMP>`.'</SAMP>, <SAMP>`*'</SAMP>,
+<SAMP>`['</SAMP>, <SAMP>`]'</SAMP> and <SAMP>`\'</SAMP>; no new special
+characters will be defined in the future.  Any other character appearing
+in a regular expression is ordinary, unless a <SAMP>`\'</SAMP> precedes it.
+
+
+<P>
+For example, <SAMP>`f'</SAMP> is not a special character, so it is ordinary, and
+therefore <SAMP>`f'</SAMP> is a regular expression that matches the string
+<SAMP>`f'</SAMP> and no other string.  (It does <EM>not</EM> match the string
+<SAMP>`ff'</SAMP>.)  Likewise, <SAMP>`o'</SAMP> is a regular expression that matches
+only <SAMP>`o'</SAMP>.
+
+<P>
+Any two regular expressions <VAR>a</VAR> and <VAR>b</VAR> can be concatenated.  The
+result is a regular expression which matches a string if <VAR>a</VAR> matches
+some amount of the beginning of that string and <VAR>b</VAR> matches the rest of
+the string.
+
+<P>
+As a simple example, we can concatenate the regular expressions <SAMP>`f'</SAMP>
+and <SAMP>`o'</SAMP> to get the regular expression <SAMP>`fo'</SAMP>, which matches only
+the string <SAMP>`fo'</SAMP>.  Still trivial.  To do something more powerful, you
+need to use one of the special characters.  Here is a list of them:
+
+
+<DL COMPACT>
+
+<DT><KBD>. (Period)</KBD>
+<DD>
+<A NAME="IDX3"></A>
+is a special character that matches any single character.
+Using concatenation, we can make regular expressions like <SAMP>`a.b'</SAMP>, which
+matches any three-character string that begins with <SAMP>`a'</SAMP> and ends with
+<SAMP>`b'</SAMP>.
+<DT><KBD>*</KBD>
+<DD>
+<A NAME="IDX4"></A>
+is not a construct by itself; it is a suffix operator that means to
+repeat the preceding regular expression as many times as possible.  In
+<SAMP>`fo*'</SAMP>, the <SAMP>`*'</SAMP> applies to the <SAMP>`o'</SAMP>, so <SAMP>`fo*'</SAMP> matches
+one <SAMP>`f'</SAMP> followed by any number of <SAMP>`o'</SAMP>s.  The case of zero
+<SAMP>`o'</SAMP>s is allowed: <SAMP>`fo*'</SAMP> does match <SAMP>`f'</SAMP>.
+<SAMP>`*'</SAMP> always applies to the <EM>smallest</EM> possible preceding
+expression.  Thus, <SAMP>`fo*'</SAMP> has a repeating <SAMP>`o'</SAMP>, not a
+repeating <SAMP>`fo'</SAMP>.
+The matcher processes a <SAMP>`*'</SAMP> construct by matching, immediately,
+as many repetitions as can be found.  Then it continues with the rest
+of the pattern.  If that fails, backtracking occurs, discarding some
+of the matches of the <SAMP>`*'</SAMP>-modified construct in case that makes
+it possible to match the rest of the pattern.  For example, in matching
+<SAMP>`ca*ar'</SAMP> against the string <SAMP>`caaar'</SAMP>, the <SAMP>`a*'</SAMP> first
+tries to match all three <SAMP>`a'</SAMP>s; but the rest of the pattern is
+<SAMP>`ar'</SAMP> and there is only <SAMP>`r'</SAMP> left to match, so this try fails.
+The next alternative is for <SAMP>`a*'</SAMP> to match only two <SAMP>`a'</SAMP>s.
+With this choice, the rest of the regexp matches successfully.
+<DT><KBD>[ ... ]</KBD>
+<DD>
+<A NAME="IDX5"></A>
+<A NAME="IDX6"></A>
+<A NAME="IDX7"></A>
+<SAMP>`['</SAMP> begins a <EM>character set</EM>, which is terminated by a
+<SAMP>`]'</SAMP>.  In the simplest case, the characters between the two brackets
+form the set.  Thus, <SAMP>`[ad]'</SAMP> matches either one <SAMP>`a'</SAMP> or one
+<SAMP>`d'</SAMP>, and <SAMP>`[ad]*'</SAMP> matches any string composed of just <SAMP>`a'</SAMP>s
+and <SAMP>`d'</SAMP>s (including the empty string), from which it follows that
+<SAMP>`c[ad]*r'</SAMP> matches <SAMP>`cr'</SAMP>, <SAMP>`car'</SAMP>, <SAMP>`cdr'</SAMP>,
+<SAMP>`caddaar'</SAMP>, etc.
+The usual regular expression special characters are not special inside a
+character set.  A completely different set of special characters exists
+inside character sets: <SAMP>`]'</SAMP>, <SAMP>`-'</SAMP> and <SAMP>`^'</SAMP>.
+<SAMP>`-'</SAMP> is used for ranges of characters.  To write a range, write two
+characters with a <SAMP>`-'</SAMP> between them.  Thus, <SAMP>`[a-z]'</SAMP> matches any
+lower case letter.  Ranges may be intermixed freely with individual
+characters, as in <SAMP>`[a-z$%.]'</SAMP>, which matches any lower case letter
+or <SAMP>`$'</SAMP>, <SAMP>`%'</SAMP> or a period.
+The following literal expressions can also be used in
+<VAR>char-class</VAR> to specify sets of characters:
+
+
+<PRE>
+[:alnum:] [:cntrl:] [:lower:] [:space:]
+[:alpha:] [:digit:] [:print:] [:upper:]
+[:blank:] [:graph:] [:punct:] [:xdigit:]
+</PRE>
+
+To include a <SAMP>`]'</SAMP> in a character set, make it the first character.
+For example, <SAMP>`[]a]'</SAMP> matches <SAMP>`]'</SAMP> or <SAMP>`a'</SAMP>.  To include a
+<SAMP>`-'</SAMP>, write <SAMP>`-'</SAMP> as the first character in the set, or put
+immediately after a range.  (You can replace one individual character
+<VAR>c</VAR> with the range <SAMP>`<VAR>c</VAR>-<VAR>c</VAR>'</SAMP> to make a place to put the
+<SAMP>`-'</SAMP>).  There is no way to write a set containing just <SAMP>`-'</SAMP> and
+<SAMP>`]'</SAMP>.
+
+To include <SAMP>`^'</SAMP> in a set, put it anywhere but at the beginning of
+the set.
+
+<DT><KBD>[^ ... ]</KBD>
+<DD>
+<A NAME="IDX8"></A>
+<SAMP>`[^'</SAMP> begins a <EM>complement character set</EM>, which matches any
+character except the ones specified.  Thus, <SAMP>`[^a-z0-9A-Z]'</SAMP>
+matches all characters <EM>except</EM> letters and digits.
+<SAMP>`^'</SAMP> is not special in a character set unless it is the first
+character.  The character following the <SAMP>`^'</SAMP> is treated as if it
+were first (thus, <SAMP>`-'</SAMP> and <SAMP>`]'</SAMP> are not special there).
+
+Note that a complement character set can match a newline, unless
+newline is mentioned as one of the characters not to match.
+
+<DT><KBD>^</KBD>
+<DD>
+<A NAME="IDX9"></A>
+<A NAME="IDX10"></A>
+is a special character that matches the empty string, but only at
+the beginning of a line in the text being matched.  Otherwise it fails
+to match anything.  Thus, <SAMP>`^foo'</SAMP> matches a <SAMP>`foo'</SAMP> which occurs
+at the beginning of a line.
+
+When matching a string, <SAMP>`^'</SAMP> matches at the beginning of the string
+or after a newline character <SAMP>`\n'</SAMP>. 
+
+<DT><KBD>$</KBD>
+<DD>
+<A NAME="IDX11"></A>
+is similar to <SAMP>`^'</SAMP> but matches only at the end of a line.  Thus,
+<SAMP>`x+$'</SAMP> matches a string of one <SAMP>`x'</SAMP> or more at the end of a line.
+
+When matching a string, <SAMP>`$'</SAMP> matches at the end of the string
+or before a newline character <SAMP>`\n'</SAMP>.
+
+<DT><KBD>\</KBD>
+<DD>
+<A NAME="IDX12"></A>
+has two functions: it quotes the special characters (including
+<SAMP>`\'</SAMP>), and it introduces additional special constructs.
+
+Because <SAMP>`\'</SAMP> quotes special characters, <SAMP>`\$'</SAMP> is a regular
+expression which matches only <SAMP>`$'</SAMP>, and <SAMP>`\['</SAMP> is a regular
+expression which matches only <SAMP>`['</SAMP>, and so on.
+
+Note that <SAMP>`\'</SAMP> also has special meaning in the read syntax of Lisp
+strings, and must be quoted with <SAMP>`\'</SAMP>.  For
+example, the regular expression that matches the <SAMP>`\'</SAMP> character is
+<SAMP>`\\'</SAMP>.  To write a Lisp string that contains the characters
+<SAMP>`\\'</SAMP>, Lisp syntax requires you to quote each <SAMP>`\'</SAMP> with another
+<SAMP>`\'</SAMP>.  Therefore, the read syntax for a regular expression matching
+<SAMP>`\'</SAMP> is <CODE>"\\\\"</CODE>.</DL>
+
+<P>
+For the most part, <SAMP>`\'</SAMP> followed by any character matches only
+that character.  However, there are several exceptions: characters
+which, when preceded by <SAMP>`\'</SAMP>, are special constructs.  Such
+characters are always ordinary when encountered on their own.  Here
+is a table of <SAMP>`\'</SAMP> constructs:
+
+
+<DL COMPACT>
+
+<DT><KBD>\+</KBD>
+<DD>
+<A NAME="IDX13"></A>
+is a suffix operator similar to <SAMP>`*'</SAMP> except that the preceding
+expression must match at least once.  So, for example, <SAMP>`ca+r'</SAMP>
+matches the strings <SAMP>`car'</SAMP> and <SAMP>`caaaar'</SAMP> but not the string
+<SAMP>`cr'</SAMP>, whereas <SAMP>`ca*r'</SAMP> matches all three strings.
+
+<DT><KBD>\?</KBD>
+<DD>
+<A NAME="IDX14"></A>
+is a suffix operator similar to <SAMP>`*'</SAMP> except that the preceding
+expression can match either once or not at all.  For example,
+<SAMP>`ca?r'</SAMP> matches <SAMP>`car'</SAMP> or <SAMP>`cr'</SAMP>, but does not match anyhing
+else.
+
+<DT><KBD>\|</KBD>
+<DD>
+<A NAME="IDX15"></A>
+<A NAME="IDX16"></A>
+specifies an alternative.
+Two regular expressions <VAR>a</VAR> and <VAR>b</VAR> with <SAMP>`\|'</SAMP> in
+between form an expression that matches anything that either <VAR>a</VAR> or
+<VAR>b</VAR> matches.
+Thus, <SAMP>`foo\|bar'</SAMP> matches either <SAMP>`foo'</SAMP> or <SAMP>`bar'</SAMP>
+but no other string.
+<SAMP>`\|'</SAMP> applies to the largest possible surrounding expressions.  Only a
+surrounding <SAMP>`\( ... \)'</SAMP> grouping can limit the grouping power of
+<SAMP>`\|'</SAMP>.
+Full backtracking capability exists to handle multiple uses of <SAMP>`\|'</SAMP>.
+
+<DT><KBD>\( ... \)</KBD>
+<DD>
+<A NAME="IDX17"></A>
+<A NAME="IDX18"></A>
+<A NAME="IDX19"></A>
+is a grouping construct that serves three purposes:
+
+
+<OL>
+<LI>
+
+To enclose a set of <SAMP>`\|'</SAMP> alternatives for other operations.
+Thus, <SAMP>`\(foo\|bar\)x'</SAMP> matches either <SAMP>`foox'</SAMP> or <SAMP>`barx'</SAMP>.
+
+<LI>
+
+To enclose an expression for a suffix operator such as <SAMP>`*'</SAMP> to act
+on.  Thus, <SAMP>`ba\(na\)*'</SAMP> matches <SAMP>`bananana'</SAMP>, etc., with any
+(zero or more) number of <SAMP>`na'</SAMP> strings.
+<LI>
+
+To record a matched substring for future reference.
+</OL>
+
+This last application is not a consequence of the idea of a
+parenthetical grouping; it is a separate feature which happens to be
+assigned as a second meaning to the same <SAMP>`\( ... \)'</SAMP> construct
+because there is no conflict in practice between the two meanings.
+Here is an explanation of this feature:
+
+<DT><KBD>\<VAR>digit</VAR></KBD>
+<DD>
+matches the same text which matched the <VAR>digit</VAR>th occurrence of a
+<SAMP>`\( ... \)'</SAMP> construct.
+
+In other words, after the end of a <SAMP>`\( ... \)'</SAMP> construct.  the
+matcher remembers the beginning and end of the text matched by that
+construct.  Then, later on in the regular expression, you can use
+<SAMP>`\'</SAMP> followed by <VAR>digit</VAR> to match that same text, whatever it
+may have been.
+
+The strings matching the first nine <SAMP>`\( ... \)'</SAMP> constructs
+appearing in a regular expression are assigned numbers 1 through 9 in
+the order that the open parentheses appear in the regular expression.
+So you can use <SAMP>`\1'</SAMP> through <SAMP>`\9'</SAMP> to refer to the text matched
+by the corresponding <SAMP>`\( ... \)'</SAMP> constructs.
+
+For example, <SAMP>`\(.*\)\1'</SAMP> matches any newline-free string that is
+composed of two identical halves.  The <SAMP>`\(.*\)'</SAMP> matches the first
+half, which may be anything, but the <SAMP>`\1'</SAMP> that follows must match
+the same exact text.
+
+<DT><KBD>\w</KBD>
+<DD>
+<A NAME="IDX20"></A>
+matches any word-constituent character.
+
+<DT><KBD>\W</KBD>
+<DD>
+<A NAME="IDX21"></A>
+matches any character that is not a word-constituent.
+</DL>
+
+<P>
+  These regular expression constructs match the empty string--that is,
+they don't use up any characters--but whether they match depends on the
+context.
+
+
+<DL COMPACT>
+
+<DT><KBD>\`</KBD>
+<DD>
+<A NAME="IDX22"></A>
+matches the empty string, but only at the beginning
+of the buffer or string being matched against.
+
+<DT><KBD>\'</KBD>
+<DD>
+<A NAME="IDX23"></A>
+matches the empty string, but only at the end of
+the buffer or string being matched against.
+
+<DT><KBD>\b</KBD>
+<DD>
+<A NAME="IDX24"></A>
+matches the empty string, but only at the beginning or
+end of a word.  Thus, <SAMP>`\bfoo\b'</SAMP> matches any occurrence of
+<SAMP>`foo'</SAMP> as a separate word.  <SAMP>`\bballs?\b'</SAMP> matches
+<SAMP>`ball'</SAMP> or <SAMP>`balls'</SAMP> as a separate word.
+<DT><KBD>\B</KBD>
+<DD>
+<A NAME="IDX25"></A>
+matches the empty string, but <EM>not</EM> at the beginning or
+end of a word.
+
+<DT><KBD>\&#60;</KBD>
+<DD>
+<A NAME="IDX26"></A>
+matches the empty string, but only at the beginning of a word.
+
+<DT><KBD>\&#62;</KBD>
+<DD>
+<A NAME="IDX27"></A>
+matches the empty string, but only at the end of a word.
+</DL>
+
+<P>
+<A NAME="IDX28"></A>
+  Not every string is a valid regular expression.  For example, a string
+with unbalanced square brackets is invalid (with a few exceptions, such
+as <SAMP>`[]]'</SAMP>, and so is a string that ends with a single <SAMP>`\'</SAMP>.  If
+an invalid regular expression is passed to any of the search functions,
+an <CODE>invalid-regexp</CODE> error is signaled.
+
+
+
+
+<H1><A NAME="SEC4" HREF="regexp.html#TOC4">Examples</A></H1>
+
+
+<H2><A NAME="SEC5" HREF="regexp.html#TOC5">Complex Regexp Example</A></H2>
+
+<P>
+  Here is a complicated regexp, used by Emacs to recognize the end of a
+sentence together with any whitespace that follows.  It is the value of
+the variable <CODE>sentence-end</CODE>.  
+
+
+<P>
+  First, we show the regexp as a string in C syntax to distinguish
+spaces from tab characters.  The string constant begins and ends with a
+double-quote.  <SAMP>`\"'</SAMP> stands for a double-quote as part of the
+string, <SAMP>`\\'</SAMP> for a backslash as part of the string, <SAMP>`\t'</SAMP> for a
+tab and <SAMP>`\n'</SAMP> for a newline.
+
+
+
+<PRE>
+"[.?!][]\"')}]*\\($\\| $\\|\t\\|  \\)[ \t\n]*"
+</PRE>
+
+<P>
+  In contrast, in Lisp, you have to type the tab as Ctrl-V Ctrl-I, producing
+the following:
+
+
+
+<PRE>
+sentence-end
+=>
+"[.?!][]\"')}]*\\($\\| $\\|  \\|  \\)[       
+]*"
+</PRE>
+
+<P>
+In this output, tab and newline appear as themselves.
+
+
+<P>
+  This regular expression contains four parts in succession and can be
+deciphered as follows:
+
+
+<DL COMPACT>
+
+<DT><CODE>[.?!]</CODE>
+<DD>
+The first part of the pattern consists of three characters, a period, a
+question mark and an exclamation mark, within square brackets.  The
+match must begin with one of these three characters.
+
+<DT><CODE>[]\"')}]*</CODE>
+<DD>
+The second part of the pattern matches any closing braces and quotation
+marks, zero or more of them, that may follow the period, question mark
+or exclamation mark.  The <CODE>\"</CODE> is C or Lisp syntax for a double-quote in
+a string.  The <SAMP>`*'</SAMP> at the end indicates that the immediately
+preceding regular expression (a character set, in this case) may be
+repeated zero or more times.
+
+<DT><CODE>\\($\\| \\|\t\\|  \\)</CODE>
+<DD>
+The third part of the pattern matches the whitespace that follows the
+end of a sentence: the end of a line, or a tab, or two spaces.  The
+double backslashes mark the parentheses and vertical bars as regular
+expression syntax; the parentheses mark the group and the vertical bars
+separate alternatives.  The dollar sign is used to match the end of a
+line.
+
+<DT><CODE>[ \t\n]*</CODE>
+<DD>
+Finally, the last part of the pattern matches any additional whitespace
+beyond the minimum needed to end a sentence.
+</DL>
+
+
+
+<H2><A NAME="SEC6" HREF="regexp.html#TOC6">Common Regular Expressions Used in Editing</A></H2>
+<P>
+<A NAME="IDX29"></A>
+<A NAME="IDX30"></A>
+
+
+<P>
+  This section describes some common regular expressions
+used for certain purposes in editing:
+
+
+<P>
+Page delimiter:
+This is the regexp describing line-beginnings that separate pages.  A good
+value is <CODE>(string #\Page)</CODE>.
+
+
+<P>
+Paragraph separator:
+This is the regular expression for recognizing the beginning of a line
+that separates paragraphs.  A good value is (in C syntax) <CODE>"^[
+\t\f]*$"</CODE>, which is a line that consists entirely of spaces, tabs, and
+form feeds.
+
+
+<P>
+Paragraph start:
+This is the regular expression for recognizing the beginning of a line
+that starts <EM>or</EM> separates paragraphs.  A good value is (in C syntax)
+<CODE>"^[ \t\n\f]"</CODE>, which matches a line starting with a space, tab,
+newline, or form feed.
+
+
+<P>
+Sentence end:
+This is the regular expression describing the end of a sentence.  (All
+paragraph boundaries also end sentences, regardless.)  A good value
+is (in C syntax, again):
+
+
+
+<PRE>
+"[.?!][]\"')}]*\\($\\|\t\\| \\)[ \t\n]*"
+</PRE>
+
+<P>
+This means a period, question mark or exclamation mark, followed by a
+closing brace, followed by tabs, spaces or new lines.
+
+
+
+
+<H1><A NAME="SEC7" HREF="regexp.html#TOC7">The Regular Expression Module</A></H1>
+
+<P>
 <DL>
-<DT><CODE>\C-</CODE> <DD>control prefix
-<DT><CODE>\M-</CODE> <DD>meta prefix
-<DT><CODE>\e </CODE> <DD>an escape character
-<DT><CODE>\\ </CODE> <DD>backslash
-<DT><CODE>\" </CODE> <DD>literal "
-<DT><CODE>\' </CODE> <DD>literal '
-</DL>
-In addition to the GNU Emacs style escape sequences, a
-second set of backslash escapes is available:
+<DT><U>Function:</U> <B>match</B> <I>regexp string &#38;key start end</I>
+<DD><A NAME="IDX31"></A>
+This function returns as first value a <CODE>match</CODE> structure containing
+the indices of the start and end of the first match for
+the regular expression <VAR>regexp</VAR> in <VAR>string</VAR>, or <CODE>nil</CODE> if
+there is no match.  If <VAR>start</VAR> is non-<CODE>nil</CODE>, the search starts
+at that index in <VAR>string</VAR>. If <VAR>end</VAR> is non-<CODE>nil</CODE>, only
+<CODE>(subseq <VAR>string</VAR> <VAR>start</VAR> <VAR>end</VAR>)</CODE> is considered.
+
+
+<P>
+For example,
+
+
+
+<PRE>
+(match "quick" "The quick brown fox jumped quickly.")
+     => #S(match :start 4 :end 9)
+(match "quick" "The quick brown fox jumped quickly." :start 8)
+     => #S(match :start 27 :end 32)
+(match "quick" "The quick brown fox jumped quickly."
+       :start 8 :end 30)
+     => nil
+</PRE>
+
+<P>
+The index of the first character of the
+string is 0, the index of the second character is 1, and so on.
+
+
+<P>
+The next values are <CODE>match</CODE> structures for every <SAMP>`\( ... \)'</SAMP>
+contruct in <VAR>regexp</VAR>, in the order that the open parentheses appear
+in <VAR>regexp</VAR>.
+</DL>
+
+
+<P>
 <DL>
-<DT><CODE>\a</CODE> <DD>alert (bell)
-<DT><CODE>\b</CODE> <DD>backspace
-<DT><CODE>\d</CODE> <DD>delete
-<DT><CODE>\f</CODE> <DD>form feed
-<DT><CODE>\n</CODE> <DD>newline
-<DT><CODE>\r</CODE> <DD>carriage return
-<DT><CODE>\t</CODE> <DD>horizontal tab
-<DT><CODE>\v</CODE> <DD>vertical tab
-<DT><CODE>\<VAR>nnn</VAR></CODE> <DD>the character whose ASCII code is the  octal
-                                     value <VAR>nnn</VAR> (one to three digits)
-<DT><CODE>\x<VAR>nnn</VAR></CODE> <DD>the  character  whose ASCII code is the
-                                      hexadecimal value <VAR>nnn</VAR> (one to three digits)
-</DL>
-When entering the text of a macro, single or double quotes
-should  be  used to indicate a macro definition.  Unquoted
-text is assumed to be a  function  name.   In the macro body,
-the backslash escapes described above are expanded.  Backslash
-will quote any other character in  the  macro  text,
-including " and '. 
-<P>
-<CODE><B>Bash</B></CODE> allows the current readline key bindings to  be  displayed
-  or  modified  with  the <CODE>bind</CODE> builtin command.  The
-editing mode may be switched  during  interactive  use  by
-using  the  <CODE>-o</CODE>  option  to the <CODE>set</CODE> builtin command.  Other
-programs using this library  provide  similar  mechanisms.
-The  <A HREF="#~/.inputrc"><I>inputrc</I></A> file  may be edited and re-read if a program
-does not provide any other means to incorporate new  bindings.
-
-<H3><A NAME="Variables">Variables</A></H3>
-
-Readline  has  variables  that can be used to further customize its
-behavior.  A variable may be set in the <A HREF="#~/.inputrc"><I>inputrc</I></A>
-file with a statement of the form
-<BLOCKQUOTE>
-<CODE>set</CODE> <VAR>variable-name</VAR> <VAR>value</VAR>
-</BLOCKQUOTE>
-<P>
-
-Except where noted, readline variables can take the values
-<CODE>On</CODE> or <CODE>Off</CODE>.
-The variables and their default values are:
+<DT><U>Function:</U> <B>match-start</B> <I>match</I>
+<DD><A NAME="IDX32"></A>
+Extracts the start index of <VAR>match</VAR>.
+</DL>
+
+
+<P>
 <DL>
-<DT> <A NAME="bell-style"><CODE>bell-style</CODE></A> (<CODE>audible</CODE>)
-<DD> Controls what happens when readline wants  to  ring
-the  terminal bell.  If set to <CODE>none</CODE>, readline never
-rings the bell.  If set to <CODE>visible</CODE>, readline uses a
-visible  bell if one is available.  If set to <CODE>audible</CODE>,
-readline attempts to ring the terminal's bell.
-<DT> <A NAME="comment-begin"><CODE>comment-begin</CODE></A> (``<CODE>;</CODE>'')
-<DD> The  string  that  is  inserted in vi mode when the
-<A HREF="#insert-comment"><CODE>insert-comment</CODE></A> command is executed.  This command
-is bound to <CODE>M-#</CODE> in emacs mode and to <CODE>#</CODE> in vi command mode.
-<DT> <A NAME="completion-ignore-case"><CODE>completion-ignore-case</CODE></A> (<CODE>Off</CODE>)
-<DD> If  set  to <CODE>On</CODE>, readline performs filename matching
-and completion in a case-insensitive fashion.
-<DT> <A NAME="blink-matching-paren"><CODE>blink-matching-paren</CODE></A> (<CODE>On</CODE>)
-<DD> If set to <CODE>On</CODE>, readline will display the corresponding opening parenthesis when a closing  parenthesis
-is typed.
-<DT> <A NAME="completion-query-items"><CODE>completion-query-items</CODE></A> (<CODE>100</CODE>)
-<DD> This  determines  when  the  user  is queried about
-viewing the number of possible  completions  generated  by
-the <A HREF="#possible-completions"><CODE>possible-completions</CODE></A> command.  It may
-be set to any integer value greater than  or  equal
-to  zero.  If the number of possible completions is
-greater than or equal to the value  of  this  variable, the
-user is asked whether or not he wishes to
-view them; otherwise they are simply listed on  the
-terminal.
-<DT> <A NAME="disable-completion"><CODE>disable-completion</CODE></A> (<CODE>Off</CODE>)
-<DD> If set to On, readline will  inhibit  word  completion.
-Completion characters will be inserted into
-the line as if they had been mapped to <CODE>self-insert</CODE>.
-<DT> <A NAME="editing-mode"><CODE>editing-mode</CODE></A> (<CODE>emacs</CODE>)
-<DD> Controls  whether readline begins with a set of key
-bindings similar to <CODE><B>emacs</B></CODE> or <CODE><B>vi</B></CODE>.
-<A HREF="#editing-mode"><CODE>editing-mode</CODE></A> can
-be set to either <CODE>emacs</CODE> or <CODE>vi</CODE>.
-<DT> <A NAME="enable-keypad"><CODE>enable-keypad</CODE></A> (<CODE>Off</CODE>)
-<DD> When  set  to  <CODE>On</CODE>,  readline will try to enable the
-application keypad when it is called.  Some systems
-need this to enable the arrow keys.
-<DT> <A NAME="expand-tilde"><CODE>expand-tilde</CODE></A> (<CODE>Off</CODE>)
-<DD>If  set  to  <CODE>on</CODE>,  tilde expansion is performed when
-readline attempts word completion.
-<DT> <A NAME="horizontal-scroll-mode"><CODE>horizontal-scroll-mode</CODE></A> (<CODE>Off</CODE>)
-<DD> When set to <CODE>On</CODE>, makes readline use  a  single  line
-for  display, scrolling the input horizontally on a
-single screen line when it becomes longer than  the
-screen width rather than wrapping to a new line.
-<DT> <A NAME="keymap"><CODE>keymap</CODE></A> (<CODE>emacs</CODE>)
-<DD> Set  the current readline keymap.  The set of legal
-keymap names is <CODE>emacs</CODE>, <CODE>emacs-standard</CODE>,  <CODE>emacs-meta</CODE>,
-<CODE>emacs-ctlx</CODE>, <CODE>vi</CODE>, <CODE>vi-move</CODE>, <CODE>vi-command</CODE>,
-and <CODE>vi-insert</CODE>.  <CODE>vi</CODE> is equivalent to <CODE>vi-command</CODE>;
-<CODE>emacs</CODE> is equivalent
-to <CODE>emacs-standard</CODE>.  The default value is <CODE>emacs</CODE>; the
-value of  <A HREF="#editing-mode"><CODE>editing-mode</CODE></A>  also  affects  the  default
-keymap.
-<DT> <A NAME="mark-directories"><CODE>mark-directories</CODE></A> (<CODE>On</CODE>)
-<DD>If  set  to  <CODE>On</CODE>,  completed directory names have a
-slash appended.
-<DT> <A NAME="mark-modified-lines"><CODE>mark-modified-lines</CODE></A> (<CODE>Off</CODE>)
-<DD> If set to <CODE>On</CODE>, history lines that have been modified
-are displayed with a preceding asterisk (<CODE>*</CODE>).
-<DT> <A NAME="convert-meta"><CODE>convert-meta</CODE></A> (<CODE>On</CODE>)
-<DD> If set to <CODE>On</CODE>, readline will convert characters with
-the eighth bit set to  an  ASCII  key  sequence  by
-stripping  the  eighth bit and prepending an escape
-character (in effect,  using  escape  as  the  <i>meta prefix</i>).
-<DT> <A NAME="meta-flag"><CODE>meta-flag</CODE></A> (<CODE>Off</CODE>)
-<DD> If set to <CODE>On</CODE>, readline will enable eight-bit  input
-(that  is,  it will not strip the high bit from the
-characters it reads), regardless of what the terminal claims it can support.
-<DT> <A NAME="output-meta"><CODE>output-meta</CODE></A> (<CODE>Off</CODE>)
-<DD> If set to <CODE>On</CODE>, readline will display characters with
-the eighth bit set directly rather than as a  meta-
-prefixed escape sequence.
-<DT> <A NAME="print-completions-horizontally"><CODE>print-completions-horizontally</CODE></A> (<CODE>Off</CODE>)
-<DD> If set to <CODE>On</CODE>,  readline  will  display  completions
-with  matches  sorted  horizontally in alphabetical
-order, rather than down the screen.
-<DT> <A NAME="show-all-if-ambiguous"><CODE>show-all-if-ambiguous</CODE></A> (<CODE>Off</CODE>)
-<DD> This  alters the default behavior of the completion
-functions.  If set to <CODE>on</CODE>,  words  which  have  more
-than  one  possible completion cause the matches to
-be listed immediately instead of ringing the  bell.
-<DT> <A NAME="visible-stats"><CODE>visible-stats</CODE></A> (<CODE>Off</CODE>)
-<DD> If set to <CODE>On</CODE>, a character denoting a file's type as
-reported  by  <CODE>stat</CODE>(2)  is  appended to the filename
-when listing possible completions.
-</DL>
-
-<H3><A NAME="Conditional Constructs">Conditional Constructs</A></H3>
-
-Readline implements a facility similar in  spirit  to  the
-conditional  compilation  features  of  the C preprocessor
-which allows key bindings and variable settings to be performed
-as  the  result  of tests.  There are four parser
-directives used.
-
+<DT><U>Function:</U> <B>match-end</B> <I>match</I>
+<DD><A NAME="IDX33"></A>
+Extracts the end index of <VAR>match</VAR>.
+</DL>
+
+
+<P>
 <DL>
-
-<DT> <A NAME="$if"><CODE>$if</CODE></A>
-<DD> The <A HREF="#$if"><CODE>$if</CODE></A> construct allows bindings to be made  based
-on  the  editing  mode, the terminal being used, or
-the application using readline.  The  text  of  the
-test  extends to the end of the line; no characters
-are required to isolate it.
+<DT><U>Function:</U> <B>match-string</B> <I>string match</I>
+<DD><A NAME="IDX34"></A>
+Extracts the substring of <VAR>string</VAR> corresponding to a given pair of
+start and end indices. The result is shared with <VAR>string</VAR>. If you want
+a freshly consed string, use <CODE>copy-string</CODE> or
+<CODE>(coerce (match-string ...) 'simple-string)</CODE>.
+</DL>
+
+
+<P>
 <DL>
-<DT> <A NAME="mode"><CODE>mode</CODE></A>
-<DD> The <CODE>mode=</CODE> form of the <A HREF="#$if"><CODE>$if</CODE></A> directive is  used
-to  test  whether readline is in <CODE>emacs</CODE> or <CODE>vi</CODE>
-mode.  This may be used in conjunction  with
-the <CODE>set keymap</CODE> command, for instance, to set
-bindings in the  <CODE>emacs-standard</CODE>
-and  <CODE>emacs-ctlx</CODE> keymaps  only  if readline is starting
-out in <CODE>emacs</CODE> mode.
-<DT> <A NAME="term"><CODE>term</CODE></A>
-<DD> The  <CODE>term=</CODE>  form  may  be  used  to  include
-terminal-specific  key  bindings, perhaps to
-bind the key sequences output by the  terminal's
-function keys.  The word on the right
-side of the <CODE>=</CODE> is  tested  against  the  full
-name  of the terminal and the portion of the
-terminal name  before  the  first  <CODE>-</CODE>.   This
-allows  <CODE>sun</CODE> to  match both <CODE>sun</CODE>
-and <CODE>sun-cmd</CODE>,
-for instance.
-<DT> <A NAME="application"><CODE>application</CODE></A>
-<DD> The <A HREF="#application"><CODE>application</CODE></A> construct is used to include
-application-specific settings.  Each program
-using the readline library sets the <i>application name</i>,
-and  an initialization file can
-test for a particular value.  This could  be
-used to bind key sequences to functions useful
-for a specific program.   For  instance,
-the  following  command  adds a key sequence
-that quotes the current or previous word  in
-Bash:
-<BLOCKQUOTE>
-<PRE><CODE><B>$if</B> bash
-# Quote the current or previous word
-"\C-xq": "\eb\"\ef\""
-<B>$endif</B>
-</CODE></PRE>
-</BLOCKQUOTE>
-</DL>
-
-<DT> <A NAME="$endif"><CODE>$endif</CODE></A>
-<DD> This  command,  as seen in the previous example,
-terminates an <A HREF="#$if"><CODE>$if</CODE></A> command.
-
-<DT> <A NAME="$else"><CODE>$else</CODE></A>
-<DD> Commands in this branch of the  <A HREF="#$if"><CODE>$if</CODE></A>  directive  are
-executed if the test fails.
-
-<DT> <A NAME="$include"><CODE>$include</CODE></A>
-<DD> This directive takes a single filename as an  argument
-and  reads  commands  and  bindings from that
-file.  For example, the following  directive  would
-read <CODE>/etc/inputrc</CODE>:
-
-<PRE><CODE><B>$include</B> /etc/inputrc
-</CODE></PRE>
-
-</DL>
-
-<H2><A NAME="Searching">Searching</A></H2>
-
-Readline  provides commands for searching through the command
-history for  lines  containing  a  specified  string.
-There  are two search modes: <I>incremental</I> and <I>non-incremental</I>.
-<P>
-Incremental searches begin before the  user  has  finished
-typing the search string.  As each character of the search
-string is typed, readline displays the next entry from the
-history  matching the string typed so far.  An incremental
-search requires only as many characters as needed to  find
-the  desired  history entry.  The Escape character is used
-to terminate an incremental search.  Control-J  will  also
-terminate the search.  Control-G will abort an incremental
-search and restore the original line.  When the search  is
-terminated, the history entry containing the search string
-becomes the current line.  To find other matching  entries
-in the history list, type Control-S or Control-R as appropriate.
-This will search backward or forward in the  history
-for the next line matching the search string typed so
-far.  Any other key sequence bound to a  readline  command
-will  terminate  the search and execute that command.  For
-instance, a newline will terminate the search  and  accept
-the  line,  thereby executing the command from the history
-list.
-<P>
-Non-incremental searches read  the  entire  search  string
-before starting 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.
-
-<H2><A NAME="Editing Commands">Editing Commands</A></H2>
-
-The  following  is a list of the names of the commands and
-the default key sequences to which they are bound.   Command
-names  without  an  accompanying  key  sequence  are
-unbound by default.
-
-<H3><A NAME="Commands for Moving">Commands for Moving</A></H3>
-
-<DL>
-<DT> <A NAME="beginning-of-line"><CODE>beginning-of-line</CODE></A> (<SAMP>C-a</SAMP>)
-<DD> Move to the start of the current line.
-<DT> <A NAME="end-of-line"><CODE>end-of-line</CODE></A> (<SAMP>C-e</SAMP>)
-<DD> Move to the end of the line.
-<DT> <A NAME="forward-char"><CODE>forward-char</CODE></A> (<SAMP>C-f</SAMP>)
-<DD> Move forward a character.
-<DT> <A NAME="backward-char"><CODE>backward-char</CODE></A> (<SAMP>C-b</SAMP>)
-<DD> Move back a character.
-<DT> <A NAME="forward-word"><CODE>forward-word</CODE></A> (<SAMP>M-f</SAMP>)
-<DD> Move forward to the end of the  next  word.   Words
-are  composed  of  alphanumeric characters (letters
-and digits).
-<DT> <A NAME="backward-word"><CODE>backward-word</CODE></A> (<SAMP>M-b</SAMP>)
-<DD> Move back to the start of this,  or  the  previous,
-word.   Words  are composed of alphanumeric characters (letters and digits).
-<DT> <A NAME="clear-screen"><CODE>clear-screen</CODE></A> (<SAMP>C-l</SAMP>)
-<DD> Clear the screen leaving the current  line  at  the
-top  of  the screen.  With an argument, refresh the
-current line without clearing the screen.
-<DT> <A NAME="redraw-current-line"><CODE>redraw-current-line</CODE></A>
-<DD> Refresh the current  line.
-</DL>
-
-<H3><A NAME="Commands for Manipulating the History">Commands for Manipulating the History</A></H3>
-
-<DL>
-<DT> <A NAME="accept-line"><CODE>accept-line</CODE></A> (<SAMP>Newline</SAMP>, <SAMP>Return</SAMP>)
-<DD> Accept  the line regardless of where the cursor is.
-If this line is non-empty, add it  to  the  history
-list.  If the line is a modified history line, then
-restore the history line to its original state.
-<DT> <A NAME="previous-history"><CODE>previous-history</CODE></A> (<SAMP>C-p</SAMP>)
-<DD> Fetch the previous command from the  history  list,
-moving back in the list.
-<DT> <A NAME="next-history"><CODE>next-history</CODE></A> (<SAMP>C-n</SAMP>)
-<DD> Fetch  the next command from the history list, moving
-forward in the list.
-<DT> <A NAME="beginning-of-history"><CODE>beginning-of-history</CODE></A> (<SAMP>M-&lt;</SAMP>)
-<DD> Move to the first line in the history.
-<DT> <A NAME="end-of-history"><CODE>end-of-history</CODE></A> (<SAMP>M-&gt;</SAMP>)
-<DD> Move to the end of the  input  history,  i.e.,  the
-line currently being entered.
-<DT> <A NAME="reverse-search-history"><CODE>reverse-search-history</CODE></A> (<SAMP>C-r</SAMP>)
-<DD> Search  backward  starting  at the current line and
-moving `up' through the history as necessary.  This
-is an incremental search.
-<DT> <A NAME="forward-search-history"><CODE>forward-search-history</CODE></A> (<SAMP>C-s</SAMP>)
-<DD> Search  forward  starting  at  the current line and
-moving `down' through  the  history  as  necessary.
-This is an incremental search.
-<DT> <A NAME="non-incremental-reverse-search-history"><CODE>non-incremental-reverse-search-history</CODE></A> (<SAMP>M-p</SAMP>)
-<DD> Search backward through the history starting at the
-current line using a non-incremental search  for  a
-string supplied by the user.
-<DT> <A NAME="non-incremental-forward-search-history"><CODE>non-incremental-forward-search-history</CODE></A> (<SAMP>M-n</SAMP>)
-<DD> Search   forward   through   the  history  using  a
-non-incremental search for a string supplied by the
-user.
-<DT> <A NAME="history-search-forward"><CODE>history-search-forward</CODE></A>
-<DD> Search  forward  through the history for the string
-of characters between the start of the current line
-and the current cursor position (the <I>point</I>).   This
-is a non-incremental search.
-<DT> <A NAME="history-search-backward"><CODE>history-search-backward</CODE></A>
-<DD> Search backward through the history for the  string
-of characters between the start of the current line
-and the point.  This is  a  non-incremental search.
-<DT> <A NAME="yank-nth-arg"><CODE>yank-nth-arg</CODE></A> (<SAMP>M-C-y</SAMP>)
-<DD> Insert  the  first argument to the previous command
-(usually the second word on the previous  line)  at
-point (the current cursor position).  With an argument <VAR>n</VAR>,
-insert  the  <VAR>n</VAR> th  word  from  the  previous
-command  (the  words  in the previous command begin
-with word 0).  A negative argument inserts the  <VAR>n</VAR> th
-word from the end of the previous command.
-<DT> <A NAME="yank-last-arg"><CODE>yank-last-arg</CODE></A> (<SAMP>M-.</SAMP>, <SAMP>M-_</SAMP>)
-<DD> Insert  the  last  argument to the previous command
-(the last word  of  the  previous  history  entry).
-With an argument, behave exactly like <CODE>yank-nth-arg</CODE>.
-Successive calls to <A HREF="#yank-last-arg"><CODE>yank-last-arg</CODE></A> move back through
-the  history  list,  inserting the last argument of
-each line in turn.
-</DL>
-
-<H3><A NAME="Commands for Changing Text">Commands for Changing Text</A></H3>
-
-<DL>
-<DT> <A NAME="delete-char"><CODE>delete-char</CODE></A> (<SAMP>C-d</SAMP>)
-<DD> Delete the character under the cursor.  If point is
-at the beginning of the line, there are no  characters
-in the line, and the last character typed was
-not bound to <CODE>delete-char</CODE>, then return EOF.
-<DT> <A NAME="backward-delete-char"><CODE>backward-delete-char</CODE></A> (<SAMP>Rubout</SAMP>)
-<DD> Delete the character behind the cursor.  When given
-a  numeric  argument,  save the deleted text on the
-kill ring.
-<DT> <A NAME="quoted-insert"><CODE>quoted-insert</CODE></A> (<SAMP>C-q</SAMP>, <SAMP>C-v</SAMP>)
-<DD> Add the next character that you type  to  the  line
-verbatim.   This  is  how to insert characters like
-<SAMP>C-q</SAMP>, for example.
-<DT> <A NAME="tab-insert"><CODE>tab-insert</CODE></A> (<SAMP>M-TAB</SAMP>)
-<DD> Insert a tab character.
-<DT> <A NAME="self-insert"><CODE>self-insert</CODE></A> (<SAMP>a</SAMP>, <SAMP>b</SAMP>, <SAMP>A</SAMP>, <SAMP>1</SAMP>, <SAMP>!</SAMP>, ...)
-<DD> Insert the character typed.
-<DT> <A NAME="transpose-chars"><CODE>transpose-chars</CODE></A> (<SAMP>C-t</SAMP>)
-<DD> Drag the character before point  forward  over  the
-character  at  point.  Point moves forward as well.
-If point is at the end of the line, then  transpose
-the  two  characters  before point.  Negative arguments don't work.
-<DT> <A NAME="transpose-words"><CODE>transpose-words</CODE></A> (<SAMP>M-t</SAMP>)
-<DD> Drag the word behind the cursor past  the  word  in
-front  of  the  cursor  moving the cursor over that
-word as well.
-<DT> <A NAME="upcase-word"><CODE>upcase-word</CODE></A> (<SAMP>M-u</SAMP>)
-<DD> Uppercase the current (or following) word.  With  a
-negative argument, uppercase the previous word, but do not
-move point.
-<DT> <A NAME="downcase-word"><CODE>downcase-word</CODE></A> (<SAMP>M-l</SAMP>)
-<DD> Lowercase the current (or following) word.  With  a
-negative argument, lowercase the previous word, but do not
-move point.
-<DT> <A NAME="capitalize-word"><CODE>capitalize-word</CODE></A> (<SAMP>M-c</SAMP>)
-<DD> Capitalize the current (or following) word.  With a
-negative argument, capitalize the previous word, but do not
-move point.
-</DL>
-
-<H3><A NAME="Killing and Yanking">Killing and Yanking</A></H3>
-
-<DL>
-<DT> <A NAME="kill-line"><CODE>kill-line</CODE></A> (<SAMP>C-k</SAMP>)
-<DD> Kill the text from the current cursor  position  to
-the end of the line.
-<DT> <A NAME="backward-kill-line"><CODE>backward-kill-line</CODE></A> (<SAMP>C-x Rubout</SAMP>)
-<DD> Kill backward to the beginning of the line.
-<DT> <A NAME="unix-line-discard"><CODE>unix-line-discard</CODE></A> (<SAMP>C-u</SAMP>)
-<DD> Kill  backward  from  point to the beginning of the
-line. The killed text is saved on the kill-ring.
-<DT> <A NAME="kill-whole-line"><CODE>kill-whole-line</CODE></A>
-<DD> Kill all characters on the current line, no  matter
-where  the cursor is.
-<DT> <A NAME="kill-word"><CODE>kill-word</CODE></A> (<SAMP>M-d</SAMP>)
-<DD> Kill from the cursor to  the  end  of  the  current
-word,  or  if between words, to the end of the next
-word.  Word boundaries are the same as  those  used
-by <A HREF="#forward-word"><CODE>forward-word</CODE></A>.
-<DT> <A NAME="backward-kill-word"><CODE>backward-kill-word</CODE></A> (<SAMP>M-Rubout</SAMP>)
-<DD> Kill  the  word behind the cursor.  Word boundaries
-are the same as those used by <A HREF="#backward-word"><CODE>backward-word</CODE></A>.
-<DT> <A NAME="unix-word-rubout"><CODE>unix-word-rubout</CODE></A> (<SAMP>C-w</SAMP>)
-<DD> Kill the word behind the cursor, using white  space
-as  a  word boundary.  The word boundaries are different
-from <A HREF="#backward-kill-word"><CODE>backward-kill-word</CODE></A>.
-<DT> <A NAME="delete-horizontal-space"><CODE>delete-horizontal-space</CODE></A> (<SAMP>M-\</SAMP>)
-<DD> Delete all spaces and tabs around point.
-<DT> <A NAME="kill-region"><CODE>kill-region</CODE></A>
-<DD> Kill the text between the  point  and  <I>mark</I>  (saved
-cursor  position).  This text is referred to as the
-<I>region</I>.
-<DT> <A NAME="copy-region-as-kill"><CODE>copy-region-as-kill</CODE></A>
-<DD> Copy the text in the region to the kill buffer.
-<DT> <A NAME="copy-backward-word"><CODE>copy-backward-word</CODE></A>
-<DD> Copy the word before point to the kill buffer.  The
-word boundaries are the same as <A HREF="#backward-word"><CODE>backward-word</CODE></A>.
-<DT> <A NAME="copy-forward-word"><CODE>copy-forward-word</CODE></A>
-<DD> Copy  the  word following point to the kill buffer.
-The word boundaries are the same as <A HREF="forward-word"><CODE>forward-word</CODE></A>.
-<DT> <A NAME="yank"><CODE>yank</CODE></A> (<SAMP>C-y</SAMP>)
-<DD> Yank  the  top  of the kill ring into the buffer at
-the cursor.
-<DT> <A NAME="yank-pop"><CODE>yank-pop</CODE></A> (<SAMP>M-y</SAMP>)
-<DD> Rotate the kill ring, and yank the new  top.   Only
-works following <A HREF="#yank"><CODE>yank</CODE></A> or <A HREF="#yank-pop"><CODE>yank-pop</CODE></A>.
-</DL>
-
-<H3><A NAME="Numeric Arguments">Numeric Arguments</A></H3>
-
-<DL>
-<DT> <A NAME="digit-argument"><CODE>digit-argument</CODE></A> (<SAMP>M-0</SAMP>, <SAMP>M-1</SAMP>, ..., <SAMP>M--</SAMP>)
-<DD> Add  this  digit to the argument already accumulating,
-or start a new argument.  <SAMP>M--</SAMP>  starts  a  negative
-argument.
-<DT> <A NAME="universal-argument"><CODE>universal-argument</CODE></A>
-<DD> This is another way to  specify  an  argument.   If
-this  command  is  followed  by one or more digits,
-optionally with a leading minus sign, those  digits
-define the argument.  If the command is followed by
-digits, executing <A HREF="#universal-argument"><CODE>universal-argument</CODE></A> again ends the
-numeric  argument,  but is otherwise ignored.  As a
-special case, if this command is  immediately  fol-
-lowed  by  a  character  that is neither a digit or
-minus sign, the argument count for the next command
-is  multiplied by four.  The argument count is initially
-one, so executing this  function  the  first
-time  makes  the argument count four, a second time
-makes the argument count sixteen, and so on.
-</DL>
-
-<H3><A NAME="Completing">Completing</A></H3>
-
-<DL>
-<DT> <A NAME="complete"><CODE>complete</CODE></A> (<SAMP>TAB</SAMP>)
-<DD> Attempt  to  perform  completion on the text before
-point.  The actual completion performed is application-specific.
-<A HREF="clisp.html"><CODE><B>Clisp</B></CODE></A>, for instance, attempts completion
-of symbol names, of function names (if  the
-text  is  prefixed  by <CODE>(</CODE> or <CODE>#'</CODE>) or of filenames (if
-the text is prefixed by <CODE>#"</CODE>).  <CODE><B>Bash</B></CODE>,  on  the  other
-hand,  attempts  completion  treating the text as a
-variable (if the text begins with <CODE>$</CODE>), username  (if
-the  text  begins  with  <CODE>~</CODE>),  hostname (if the text
-begins with <CODE>@</CODE>), or command (including  aliases  and
-functions)  in  turn.   If none of these produces a
-match,  filename  completion  is  attempted.   <CODE><B>Gdb</B></CODE>,
-finally, allows completion of program functions and
-variables, and only  attempts  filename  completion
-under certain circumstances.
-<DT> <A NAME="possible-completions"><CODE>possible-completions</CODE></A> (<SAMP>M-?</SAMP>)
-<DD> List  the  possible  completions of the text before
-point.
-<DT> <A NAME="insert-completions"><CODE>insert-completions</CODE></A> (<SAMP>M-*</SAMP>)
-<DD> Insert all completions of  the  text  before  point
-that   would   have   been   generated   by  <A HREF="#possible-completions"><CODE>possible-completions</CODE></A>.
-<DT> <A NAME="menu-complete"><CODE>menu-complete</CODE></A>
-<DD>Similar  to  <A HREF="#complete"><CODE>complete</CODE></A>,  but replaces the word to be
-completed with a single match from the list of pos-
-sible completions.  Repeated execution of <A HREF="#menu-complete"><CODE>menu-complete</CODE></A>
-steps through the list  of  possible  comple-
-tions, inserting each match in turn.  At the end of
-the list of completions, the bell is rung  and  the
-original  text is restored.  An argument of <VAR>n</VAR> moves
-<VAR>n</VAR> positions forward in the list of matches; a nega-
-tive  argument may be used to move backward through
-the list.  This command is intended to be bound  to
-<CODE>TAB</CODE>, but is unbound by default.
-</DL>
-
-<H3><A NAME="Keyboard Macros">Keyboard Macros</A></H3>
-
-<DL>
-<DT> <A NAME="start-kbd-macro"><CODE>start-kbd-macro</CODE></A> (<SAMP>C-x (</SAMP>)
-<DD> Begin  saving the characters typed into the current
-keyboard macro.
-<DT> <A NAME="end-kbd-macro"><CODE>end-kbd-macro</CODE></A> (<SAMP>C-x )</SAMP>)
-<DD> Stop saving the characters typed into  the  current
-keyboard macro and store the definition.
-<DT> <A NAME="call-last-kbd-macro"><CODE>call-last-kbd-macro</CODE></A> (<SAMP>C-x e</SAMP>)
-<DD> Re-execute the last keyboard macro defined, by making the characters in the macro appear as if  typed
-at the keyboard.
-</DL>
-
-<H3><A NAME="Miscellaneous">Miscellaneous</A></H3>
-
-<DL>
-<DT> <A NAME="re-read-init-file"><CODE>re-read-init-file</CODE></A> (<SAMP>C-x C-r</SAMP>)
-<DD> Read  in the contents of the <A HREF="#~/.inputrc"><I>inputrc</I></A> file, and incorporate any bindings or variable  assignments  found
-there.
-<DT> <A NAME="abort"><CODE>abort</CODE></A> (<SAMP>C-g</SAMP>)
-<DD> Abort the current editing command and ring the terminal's   bell   (subject   to   the   setting   of
-<A HREF="#bell-style"><CODE>bell-style</CODE></A>).
-<DT> <A NAME="do-uppercase-version"><CODE>do-uppercase-version</CODE></A> (<SAMP>M-a</SAMP>, <SAMP>M-b</SAMP>, <SAMP>M-<VAR>x</VAR></SAMP>, ...)
-<DD> If  the  metafied character <VAR>x</VAR> is lowercase, run the
-command that is bound to the  corresponding  uppercase character.
-<DT> <A NAME="prefix-meta"><CODE>prefix-meta</CODE></A> (<SAMP>ESC</SAMP>)
-<DD> Metafy the next character typed.  <SAMP>ESC f</SAMP> is  equivalent to <SAMP>Meta-f</SAMP>.
-<DT> <A NAME="undo"><CODE>undo</CODE></A> (<SAMP>C-_</SAMP>, <SAMP>C-x C-u</SAMP>)
-<DD> Incremental  undo,  separately  remembered for each
-line.
-<DT> <A NAME="revert-line"><CODE>revert-line</CODE></A> (<SAMP>M-r</SAMP>)
-<DD> Undo all changes made to this line.  This  is  like
-executing  the <A HREF="#undo"><CODE>undo</CODE></A> command enough times to return the
-line to its initial state.
-<DT> <A NAME="tilde-expand"><CODE>tilde-expand</CODE></A> (<SAMP>M-~</SAMP>)
-<DD> Perform tilde expansion on the current word.
-<DT> <A NAME="set-mark"><CODE>set-mark</CODE></A> (<SAMP>C-@</SAMP>, <SAMP>M-<I>space</I></SAMP>)
-<DD> Set  the  mark  to the current point.  If a numeric
-argument is supplied, the mark is set to that position.
-<DT> <A NAME="exchange-point-and-mark"><CODE>exchange-point-and-mark</CODE></A> (<SAMP>C-x C-x</SAMP>)
-<DD> Swap  the  point with the mark.  The current cursor
-position is set to the saved position, and the  old
-cursor position is saved as the mark.
-<DT> <A NAME="character-search"><CODE>character-search</CODE></A> (<SAMP>C-]</SAMP>)
-<DD> A  character is read and point is moved to the next
-occurrence of that  character.   A  negative  count
-searches for previous occurrences.
-<DT> <A NAME="character-search-backward"><CODE>character-search-backward</CODE></A> (<SAMP>M-C-]</SAMP>)
-<DD> A  character is read and point is moved to the previous
-occurrence of  that  character.   A  negative
-count searches for subsequent occurrences.
-<DT> <A NAME="insert-comment"><CODE>insert-comment</CODE></A> (<SAMP>M-#</SAMP>)
-<DD> The value of the readline <CODE>comment-begin</CODE> variable is
-inserted at the beginning of the current line,  and
-the  line  is  accepted  as  if  a newline had been
-typed.  This makes the current line  a  shell  comment.
-<DT> <A NAME="dump-functions"><CODE>dump-functions</CODE></A>
-<DD> Print all of the functions and their  key  bindings
-to  the readline output stream.  If a numeric argument is supplied, the output is formatted in such a
-way that it can be made part of an <A HREF="#~/.inputrc"><I>inputrc</I></A> file.
-<DT> <A NAME="dump-variables"><CODE>dump-variables</CODE></A>
-<DD> Print all of the settable variables and their  values
-to  the  readline output stream.  If a numeric
-argument is supplied, the output  is  formatted  in
-such  a  way that it can be made part of an <A HREF="#~/.inputrc"><I>inputrc</I></A>
-file.
-<DT> <A NAME="dump-macros"><CODE>dump-macros</CODE></A>
-<DD> Print all of the readline key  sequences  bound  to
-macros  and  the  strings they ouput.  If a numeric
-argument is supplied, the output  is  formatted  in
-such  a  way that it can be made part of an <A HREF="#~/.inputrc"><I>inputrc</I></A>
-file.
-<DT> <A NAME="emacs-editing-mode"><CODE>emacs-editing-mode</CODE></A> (<SAMP>C-e</SAMP>)
-<DD> When  in  <CODE>vi</CODE>  editing mode, this causes a switch to
-<CODE>emacs</CODE> editing mode.
-<DT> <A NAME="vi-editing-mode"><CODE>vi-editing-mode</CODE></A> (<SAMP>M-C-j</SAMP>)
-<DD> When in <CODE>emacs</CODE> editing mode, this causes a switch to
-<CODE>vi</CODE> editing mode.
-</DL>
-
-<H2><A NAME="Default Key Bindings">Default Key Bindings</A></H2>
-
-The  following is a list of the default emacs and vi bindings.  Characters with the 8th  bit  set  are  written  as
-<SAMP>M-</SAMP><VAR>character</VAR>, and are referred to as <i>metafied</i>
- characters.
-The printable ASCII characters not mentioned in  the  list
-of  emacs  standard  bindings are bound to the <A HREF="#self-insert"><CODE>self-insert</CODE></A>
-function, which just inserts the given character into  the
-input  line.   In  vi  insertion  mode, all characters not
-specifically mentioned are bound to <A HREF="#self-insert"><CODE>self-insert</CODE></A>.
-Characters  assigned to signal generation by <A HREF="stty(1)"><CODE>stty</CODE></A>(1)
-or the terminal driver, such as <SAMP>C-Z</SAMP> or <SAMP>C-C</SAMP>,  retain  that  function.
-Upper  and lower case <i>metafied</i> characters are bound to the
-same function in the emacs mode meta keymap.  The  remaining
-characters are unbound, which causes readline to ring
-the bell (subject to the setting of the  <A HREF="#bell-style"><CODE>bell-style</CODE></A>  variable).
-
-<H3><A NAME="Key Bindings in Emacs Mode">Emacs Mode</A></H3>
-
-<DL>
-<DT> Emacs Standard bindings
-<DD> <PRE>
-"C-@"             <A HREF="#set-mark"><CODE>set-mark</CODE></A>
-"C-A"             <A HREF="#beginning-of-line"><CODE>beginning-of-line</CODE></A>
-"C-B"             <A HREF="#backward-char"><CODE>backward-char</CODE></A>
-"C-D"             <A HREF="#delete-char"><CODE>delete-char</CODE></A>
-"C-E"             <A HREF="#end-of-line"><CODE>end-of-line</CODE></A>
-"C-F"             <A HREF="#forward-char"><CODE>forward-char</CODE></A>
-"C-G"             <A HREF="#abort"><CODE>abort</CODE></A>
-"C-H"             <A HREF="#backward-delete-char"><CODE>backward-delete-char</CODE></A>
-"C-I"             <A HREF="#complete"><CODE>complete</CODE></A>
-"C-J"             <A HREF="#accept-line"><CODE>accept-line</CODE></A>
-"C-K"             <A HREF="#kill-line"><CODE>kill-line</CODE></A>
-"C-L"             <A HREF="#clear-screen"><CODE>clear-screen</CODE></A>
-"C-M"             <A HREF="#accept-line"><CODE>accept-line</CODE></A>
-"C-N"             <A HREF="#next-history"><CODE>next-history</CODE></A>
-"C-P"             <A HREF="#previous-history"><CODE>previous-history</CODE></A>
-"C-Q"             <A HREF="#quoted-insert"><CODE>quoted-insert</CODE></A>
-"C-R"             <A HREF="#reverse-search-history"><CODE>reverse-search-history</CODE></A>
-"C-S"             <A HREF="#forward-search-history"><CODE>forward-search-history</CODE></A>
-"C-T"             <A HREF="#transpose-chars"><CODE>transpose-chars</CODE></A>
-"C-U"             <A HREF="#unix-line-discard"><CODE>unix-line-discard</CODE></A>
-"C-V"             <A HREF="#quoted-insert"><CODE>quoted-insert</CODE></A>
-"C-W"             <A HREF="#unix-word-rubout"><CODE>unix-word-rubout</CODE></A>
-"C-Y"             <A HREF="#yank"><CODE>yank</CODE></A>
-"C-]"             <A HREF="#character-search"><CODE>character-search</CODE></A>
-"C-_"             <A HREF="#undo"><CODE>undo</CODE></A>
-" " to "/"        <A HREF="#self-insert"><CODE>self-insert</CODE></A>
-"0" to "9"        <A HREF="#self-insert"><CODE>self-insert</CODE></A>
-":" to "~"        <A HREF="#self-insert"><CODE>self-insert</CODE></A>
-"C-?"             <A HREF="#backward-delete-char"><CODE>backward-delete-char</CODE></A>
+<DT><U>Function:</U> <B>regexp-quote</B> <I>string</I>
+<DD><A NAME="IDX35"></A>
+This function returns a regular expression string that matches exactly
+<VAR>string</VAR> and nothing else.  This allows you to request an exact
+string match when calling a function that wants a regular expression.
+
+
+
+<PRE>
+(regexp-quote "^The cat$")
+     => "\\^The cat\\$"
 </PRE>
-<DT> Emacs Meta bindings
-<DD> <PRE>
-"<SAMP>M-C-G</SAMP>"           <A HREF="#abort"><CODE>abort</CODE></A>
-"<SAMP>M-C-H</SAMP>"           <A HREF="#backward-kill-word"><CODE>backward-kill-word</CODE></A>
-"<SAMP>M-C-I</SAMP>"           <A HREF="#tab-insert"><CODE>tab-insert</CODE></A>
-"<SAMP>M-C-J</SAMP>"           <A HREF="#vi-editing-mode"><CODE>vi-editing-mode</CODE></A>
-"<SAMP>M-C-M</SAMP>"           <A HREF="#vi-editing-mode"><CODE>vi-editing-mode</CODE></A>
-"<SAMP>M-C-R</SAMP>"           <A HREF="#revert-line"><CODE>revert-line</CODE></A>
-"<SAMP>M-C-Y</SAMP>"           <A HREF="#yank-nth-arg"><CODE>yank-nth-arg</CODE></A>
-"<SAMP>M-C-[</SAMP>"           <A HREF="#complete"><CODE>complete</CODE></A>
-"<SAMP>M-C-]</SAMP>"           <A HREF="#character-search-backward"><CODE>character-search-backward</CODE></A>
-"<SAMP>M-<I>space</I></SAMP>"             <A HREF="#set-mark"><CODE>set-mark</CODE></A>
-"<SAMP>M-#</SAMP>"             <A HREF="#insert-comment"><CODE>insert-comment</CODE></A>
-"<SAMP>M-&amp;</SAMP>"             <A HREF="#tilde-expand"><CODE>tilde-expand</CODE></A>
-"<SAMP>M-*</SAMP>"             <A HREF="#insert-completions"><CODE>insert-completions</CODE></A>
-"<SAMP>M--</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-.</SAMP>"             <A HREF="#yank-last-arg"><CODE>yank-last-arg</CODE></A>
-"<SAMP>M-0</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-1</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-2</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-3</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-4</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-5</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-6</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-7</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-8</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-9</SAMP>"             <A HREF="#digit-argument"><CODE>digit-argument</CODE></A>
-"<SAMP>M-&lt;</SAMP>"             <A HREF="#beginning-of-history"><CODE>beginning-of-history</CODE></A>
-"<SAMP>M-=</SAMP>"             <A HREF="#possible-completions"><CODE>possible-completions</CODE></A>
-"<SAMP>M-&gt;</SAMP>"             <A HREF="#end-of-history"><CODE>end-of-history</CODE></A>
-"<SAMP>M-?</SAMP>"             <A HREF="#possible-completions"><CODE>possible-completions</CODE></A>
-"<SAMP>M-B</SAMP>"             <A HREF="#backward-word"><CODE>backward-word</CODE></A>
-"<SAMP>M-C</SAMP>"             <A HREF="#capitalize-word"><CODE>capitalize-word</CODE></A>
-"<SAMP>M-D</SAMP>"             <A HREF="#kill-word"><CODE>kill-word</CODE></A>
-"<SAMP>M-F</SAMP>"             <A HREF="#forward-word"><CODE>forward-word</CODE></A>
-"<SAMP>M-L</SAMP>"             <A HREF="#downcase-word"><CODE>downcase-word</CODE></A>
-"<SAMP>M-N</SAMP>"             <A HREF="#non-incremental-forward-search-history"><CODE>non-incremental-forward-search-history</CODE></A>
-"<SAMP>M-O</SAMP>"             <CODE>arrow-key-prefix</CODE>
-"<SAMP>M-P</SAMP>"             <A HREF="#non-incremental-reverse-search-history"><CODE>non-incremental-reverse-search-history</CODE></A>
-"<SAMP>M-R</SAMP>"             <A HREF="#revert-line"><CODE>revert-line</CODE></A>
-"<SAMP>M-T</SAMP>"             <A HREF="#transpose-words"><CODE>transpose-words</CODE></A>
-"<SAMP>M-U</SAMP>"             <A HREF="#upcase-word"><CODE>upcase-word</CODE></A>
-"<SAMP>M-Y</SAMP>"             <A HREF="#yank-pop"><CODE>yank-pop</CODE></A>
-"<SAMP>M-\</SAMP>"             <A HREF="#delete-horizontal-space"><CODE>delete-horizontal-space</CODE></A>
-"<SAMP>M-~</SAMP>"             <A HREF="#tilde-expand"><CODE>tilde-expand</CODE></A>
-"<SAMP>M-C-?</SAMP>"           <CODE>backward-delete-word</CODE>
-"<SAMP>M-_</SAMP>"             <A HREF="#yank-last-arg"><CODE>yank-last-arg</CODE></A>
-</PRE>
-<DT> Emacs Control-X bindings
-<DD> <PRE>
-"C-XC-G"          <A HREF="#abort"><CODE>abort</CODE></A>
-"C-XC-R"          <A HREF="#re-read-init-file"><CODE>re-read-init-file</CODE></A>
-"C-XC-U"          <A HREF="#undo"><CODE>undo</CODE></A>
-"C-XC-X"          <A HREF="#exchange-point-and-mark"><CODE>exchange-point-and-mark</CODE></A>
-"C-X("            <A HREF="#start-kbd-macro"><CODE>start-kbd-macro</CODE></A>
-"C-X)"            <A HREF="#end-kbd-macro"><CODE>end-kbd-macro</CODE></A>
-"C-Xe"            <A HREF="#call-last-kbd-macro"><CODE>call-last-kbd-macro</CODE></A>
-"C-XC-?"          <A HREF="#backward-kill-line"><CODE>backward-kill-line</CODE></A>
-</PRE>
-</DL>
-
-<H3><A NAME="Key Bindings in VI Mode">VI Mode bindings</A></H3>
-
-<DL>
-<DT> VI Insert Mode functions
-<DD> <PRE>
-"C-D"             <CODE>vi-eof-maybe</CODE>
-"C-H"             <A HREF="#backward-delete-char"><CODE>backward-delete-char</CODE></A>
-"C-I"             <A HREF="#complete"><CODE>complete</CODE></A>
-"C-J"             <A HREF="#accept-line"><CODE>accept-line</CODE></A>
-"C-M"             <A HREF="#accept-line"><CODE>accept-line</CODE></A>
-"C-R"             <A HREF="#reverse-search-history"><CODE>reverse-search-history</CODE></A>
-"C-S"             <A HREF="#forward-search-history"><CODE>forward-search-history</CODE></A>
-"C-T"             <A HREF="#transpose-chars"><CODE>transpose-chars</CODE></A>
-"C-U"             <A HREF="#unix-line-discard"><CODE>unix-line-discard</CODE></A>
-"C-V"             <A HREF="#quoted-insert"><CODE>quoted-insert</CODE></A>
-"C-W"             <A HREF="#unix-word-rubout"><CODE>unix-word-rubout</CODE></A>
-"C-Y"             <A HREF="#yank"><CODE>yank</CODE></A>
-"C-["             <CODE>vi-movement-mode</CODE>
-"C-_"             <A HREF="#undo"><CODE>undo</CODE></A>
-" " to "~"        <A HREF="#self-insert"><CODE>self-insert</CODE></A>
-"C-?"             <A HREF="#backward-delete-char"><CODE>backward-delete-char</CODE></A>
-</PRE>
-<DT> VI Command Mode functions
-<DD> <PRE>
-"C-D"             <CODE>vi-eof-maybe</CODE>
-"C-E"             <A HREF="#emacs-editing-mode"><CODE>emacs-editing-mode</CODE></A>
-"C-G"             <A HREF="#abort"><CODE>abort</CODE></A>
-"C-H"             <A HREF="#backward-char"><CODE>backward-char</CODE></A>
-"C-J"             <A HREF="#accept-line"><CODE>accept-line</CODE></A>
-"C-K"             <A HREF="#kill-line"><CODE>kill-line</CODE></A>
-"C-L"             <A HREF="#clear-screen"><CODE>clear-screen</CODE></A>
-"C-M"             <A HREF="#accept-line"><CODE>accept-line</CODE></A>
-"C-N"             <A HREF="#next-history"><CODE>next-history</CODE></A>
-"C-P"             <A HREF="#previous-history"><CODE>previous-history</CODE></A>
-"C-Q"             <A HREF="#quoted-insert"><CODE>quoted-insert</CODE></A>
-"C-R"             <A HREF="#reverse-search-history"><CODE>reverse-search-history</CODE></A>
-"C-S"             <A HREF="#forward-search-history"><CODE>forward-search-history</CODE></A>
-"C-T"             <A HREF="#transpose-chars"><CODE>transpose-chars</CODE></A>
-"C-U"             <A HREF="#unix-line-discard"><CODE>unix-line-discard</CODE></A>
-"C-V"             <A HREF="#quoted-insert"><CODE>quoted-insert</CODE></A>
-"C-W"             <A HREF="#unix-word-rubout"><CODE>unix-word-rubout</CODE></A>
-"C-Y"             <A HREF="#yank"><CODE>yank</CODE></A>
-" "               <A HREF="#forward-char"><CODE>forward-char</CODE></A>
-"#"               <A HREF="#insert-comment"><CODE>insert-comment</CODE></A>
-"$"               <A HREF="#end-of-line"><CODE>end-of-line</CODE></A>
-"%"               <CODE>vi-match</CODE>
-"&amp;"               <CODE>vi-tilde-expand</CODE>
-"*"               <CODE>vi-complete</CODE>
-"+"               <A HREF="#next-history"><CODE>next-history</CODE></A>
-","               <CODE>vi-char-search</CODE>
-"-"               <A HREF="#previous-history"><CODE>previous-history</CODE></A>
-"."               <CODE>vi-redo</CODE>
-"/"               <CODE>vi-search</CODE>
-"0"               <A HREF="#beginning-of-line"><CODE>beginning-of-line</CODE></A>
-"1" to "9"        <CODE>vi-arg-digit</CODE>
-";"               <CODE>vi-char-search</CODE>
-"="               <CODE>vi-complete</CODE>
-"?"               <CODE>vi-search</CODE>
-"A"               <CODE>vi-append-eol</CODE>
-"B"               <CODE>vi-prev-word</CODE>
-"C"               <CODE>vi-change-to</CODE>
-"D"               <CODE>vi-delete-to</CODE>
-"E"               <CODE>vi-end-word</CODE>
-"F"               <CODE>vi-char-search</CODE>
-"G"               <CODE>vi-fetch-history</CODE>
-"I"               <CODE>vi-insert-beg</CODE>
-"N"               <CODE>vi-search-again</CODE>
-"P"               <CODE>vi-put</CODE>
-"R"               <CODE>vi-replace</CODE>
-"S"               <CODE>vi-subst</CODE>
-"T"               <CODE>vi-char-search</CODE>
-"U"               <A HREF="#revert-line"><CODE>revert-line</CODE></A>
-"W"               <CODE>vi-next-word</CODE>
-"X"               <A HREF="#backward-delete-char"><CODE>backward-delete-char</CODE></A>
-"Y"               <CODE>vi-yank-to</CODE>
-"\"               <CODE>vi-complete</CODE>
-"^"               <CODE>vi-first-print</CODE>
-"_"               <CODE>vi-yank-arg</CODE>
-"`"               <CODE>vi-goto-mark</CODE>
-"a"               <CODE>vi-append-mode</CODE>
-"b"               <CODE>vi-prev-word</CODE>
-"c"               <CODE>vi-change-to</CODE>
-"d"               <CODE>vi-delete-to</CODE>
-"e"               <CODE>vi-end-word</CODE>
-"f"               <CODE>vi-char-search</CODE>
-"h"               <A HREF="#backward-char"><CODE>backward-char</CODE></A>
-"i"               <CODE>vi-insertion-mode</CODE>
-"j"               <A HREF="#next-history"><CODE>next-history</CODE></A>
-"k"               <CODE>prev-history</CODE>
-"l"               <A HREF="#forward-char"><CODE>forward-char</CODE></A>
-"m"               <CODE>vi-set-mark</CODE>
-"n"               <CODE>vi-search-again</CODE>
-"p"               <CODE>vi-put</CODE>
-"r"               <CODE>vi-change-char</CODE>
-"s"               <CODE>vi-subst</CODE>
-"t"               <CODE>vi-char-search</CODE>
-"u"               <A HREF="#undo"><CODE>undo</CODE></A>
-"w"               <CODE>vi-next-word</CODE>
-"x"               <CODE>vi-delete</CODE>
-"y"               <CODE>vi-yank-to</CODE>
-"|"               <CODE>vi-column</CODE>
-"~"               <CODE>vi-change-case</CODE>
-</PRE>
-</DL>
-
-<H2><A NAME="See also">See also</A></H2>
-
-<UL>
-<LI> <EM>The Gnu Readline Library</EM>, Brian Fox
-<LI> <EM>The Gnu History Library</EM>, Brian Fox
-<LI> <A HREF="bash(1)"><CODE><B>bash</B></CODE></A>(1)
-</UL>
-
-<H2><A NAME="Files">Files</A></H2>
-
-<DL>
-<DT> <A NAME="~/.inputrc"><CODE>~/.inputrc</CODE></A>
-<DD> Individual readline initialization file
-</DL>
-
-<H2><A NAME="Authors">Authors</A></H2>
-
-<UL>
-<LI> Brian   Fox,   Free  Software  Foundation  (primary
-author)<BR>
-<TT>bfox@ai.MIT.Edu</TT>
-<LI>Chet Ramey, Case Western Reserve University<BR>
-<TT>chet@ins.CWRU.Edu</TT>
-<LI>Bruno Haible<BR>
-<TT>haible@clisp.cons.org</TT>
-</UL>
-
-<H2><A NAME="Bug Reports">Bug Reports</A></H2>
-
-If you find a bug in readline, you should report it.  Send
-mail to <TT>haible@clisp.cons.org</TT>.
-
-<H2><A NAME="Bugs">Bugs</A></H2>
-
-It's too big and too slow.
-<P>
-
-<HR>
-
-<ADDRESS>CLISP-READLINE manual page<BR>
-Bruno Haible &lt;haible@clisp.cons.org&gt;
-</ADDRESS>
-<P>
-Last modified: 11 October 1998.
-
+
+<P>
+One use of <CODE>regexp-quote</CODE> is to combine an exact string match with
+context described as a regular expression.
+</DL>
+
+
+<P><HR><P>
+This document was generated on 12 September 2001 using
+<A HREF="http://wwwinfo.cern.ch/dis/texi2html/">texi2html</A>&nbsp;1.56k.
 </BODY>
-
+</HTML>
patent_button.gif to patent_button.png
--- a/patent_button.gif
+++ b/patent_button.png
@@ -1,5 +1,5 @@
-GIF89aX$„˙˙˙
…@TI`˙ýĆÁ …G˙ý$3l@Ľ/-YX6C]oOTId–Ť3ŸŃoť&Kb­&6E4|DŢ@X$g@~%ĎçŸŃ–Ť,˙˙˙˙˙˙˙˙˙˙˙˙!ţŃThis GIF picture was created in the European Union. We do not intend to ask any license to Unisys. According to European Laws, (1) interfaces and formats can not be protected (2) Programmes can not be patented,X$@ţ` ŽdižhŞŽl[&	’BŇ@ˆú~@×ć€8âI#ôŤ&&"EiPŔşŻP D*ĂBWÇŽ‹Ă /|œŽœŔÉjÝ"őn_;RFeGŠd‹F‹4,	
-Z.›œž‚OQ€Ÿ¤Ľ&H#
-	0
7’‚5ƒľ?B4=#^tq´<>8Ł)Ş|		š3]Kc4щatź>nÍŔ$˛$xyUULâc9ŁÓ<€đzń"é5ózéőęôęŚ˘8p@†ß˜Č03„¨ZĐâaÄ]śžŮáöGW‘ZA)bň‘…1ƒ-ţ‚„ńâ%‚ť$ĚtşĆń$lqpf1†ÁŠŢB‰AĹRŔ™h@A‰ôě
ŞĄz­ńS˘˜ąd%rŁľŠÚírú”ćX]‹ćá0ŻžŤV´°­‡nk€.9…Hˆ66
:˜ŔBâŔ{ÓË	fd@"Nš‹
#KžLš˛ĺË)œ,ÄĚY„wžŚƒřŻ3eĘLô(}Nß;5řĺ‹-Ä=zúhĎ6á$UŒM:Xy
-•G&GŰ"	gD3­`0hpŔXź˙`TDH§›ŻhőIÇ”s˙šŞbvŽš+˝—Y_價fĎ”'Œ†3D Ž°ÁQÔ6EÂ`Ł<ˇQcÁČdĆkHI!Ç5euČ HcM\0ô„Aj9D¤QMQĐÎ! č1˘xš6_ńVŐU¨•PZ.FľWR<–ĺÔVh7v°Ř‡sČ}'œ-†Ř•Ü#÷‰ƒBŒ÷M	”SNIě R‡ŕč^25	؏9ŠH‚^ĽDË,‚–&˛ŕ5‚•9Ǣޑ°Zh°˜$ÓŚQŚ
-Efę駠†jZ;+‰PNG
+
+
IHDRX$MŹ=*TPLTE
…@TI`˙ýĆÁ …G˙ý$3l@Ľ/-YX6C]oOTId–Ť3ŸŃoť&Kb­&6E4|DŢ@X$g@~%ĎçŸŃ–Ť,ŚIçÇtEXtSoftwaregif2png 2.4.0MP&"ŮtEXtCommentThis GIF picture was created in the European Union. We do not intend to ask any license to Unisys. According to European Laws, (1) interfaces and formats can not be protected (2) Programmes can not be patented‘CÂ?IDATxÚľV	rŰ0$&ŚÜ´‘+Ľśű˙X€:<éĞq¨ąDŃË%¸8¨Bk+ԈTI‰ľ˝(ŰÍű˘•üÍúuĹoç’OTŸn<ƒ=Ť˝×˘Dg‡Řř‘vs•n[ąą_o3 ‰nmŔđH!ik*ÄĚ9*DRčÓV@&Ÿ@—Şo_°i—ømKlcčĹ°řNGeĆ0dÚ٪ꤏ1‡ŠˆĂ]GˆaTÜnŹ8Úta2 źŸÚ}wřő7Ş|	6“†tŠu݁áh›ŤÁáűPwk˜ŃZ;älۉť|„F‚HPţ,pŰ`裗ƒÇ …¤ńĽ†‹;ófÇĽ€Ś’+í.v;Zřaǧ):É\ă	›+[4śZď’î!ó`Őz>Üí̢z¸…%œwŽ<cîPV›b-gşxˆƒ°Ěq°ëlˇáŘŢ)S×ÁœQ^ĄěČH´ů5¸îŔH\ü;\™ŕiöL‹RE`h೧˘čd<ĎÖ߃+ŻftC<„EÂ؃•
XŽÂ3EœmlŚTƒŤ™üV¸Ś-3Ľ=ŃZ<řA°
G•c_Ať‚HÄŠŮ.íž$Ăě7‘×’¸6˛‹^†ĘwF]ű;|Wđ?˝Ý˗ĺîaâ—WđşÔć‰ĘO#FĄëEAu!f81ŽąaîăŢőť$ŒŃžŔNTÜĂ͚šŐ™ŽëZ(Čżź÷˘ě^PǑgâ&˙x{ýůňś¨ÇK–qäWĎfÁěHě^`b}ŘPý˘ v9ÄxˇčYvŁ0ÁÁŇMFMaž%慘Sc^TövÜ(÷ÓŮ~ăé”Ä~퉵Wě´¸qˆ‚ůăĎš-Z˛‹•xö¤ŒCoCŒŇXâ(¨V.8§!ˆĎ爎œÇa'žćqąěˆ™;,ˆ!Zé[^ˆ[<NEy!>M3­fęNŠpgźpD…Ś+1Ĺ×O:^z`Đ<Ń˙‰Ľs'ŽtłvÜđb˝
+Luâ)Řj|˛ő5¸ŸUňu“yv’%tý&ˆ/<$Mó)-Îߎ¸;UˇGť˙{ź^ôzmCݤôSŞŰĐlőmŃx^Ůüśzüźö
+hUz=IENDŽB`‚
<< < 1 .. 5 6 7 (Page 7 of 7)