renamed

6 files changed, 0 insertions, 1033 deletions

diff --git a/man/man3/9pcmdbuf.3 b/man/man3/9pcmdbuf.3
deleted file mode 100644
index cd1c7318..00000000
--- a/man/man3/9pcmdbuf.3
+++ /dev/null
@@ -1,118 +0,0 @@
-.TH 9PCMDBUF 3
-.SH NAME
-Cmdbuf, parsecmd, respondcmderror, lookupcmd \- control message parsing
-.SH SYNOPSIS
-.ft L
-.nf
-#include <u.h>
-#include <libc.h>
-#include <fcall.h>
-#include <thread.h>
-#include <9p.h>
-.fi
-.PP
-.ft L
-.nf
-.ta \w'\fL1234'u +\w'\fL12345678'u
-typedef struct Cmdbuf
-{
-	char	*buf;
-	char	**f;
-	int	nf;
-} Cmdbuf;
-
-typedef struct Cmdtab
-{
-	int	index;
-	char	*cmd;
-	int	narg;
-};
-
-Cmdbuf	*parsecmd(char *p, int n)
-Cmdtab	*lookupcmd(Cmdbuf *cb, Cmdtab *tab, int ntab)
-void	respondcmderror(Req *r, Cmdbuf *cb, char *fmt, ...)
-.fi
-.SH DESCRIPTION
-These data structures and functions provide parsing of textual control messages.
-.PP
-.I Parsecmd
-treats the
-.I n
-bytes at
-.I p
-(which need not be NUL-terminated) as a UTF string and splits it
-using
-.I tokenize
-(see
-.IR getfields (3)).
-It returns a
-.B Cmdbuf
-structure holding pointers to each field in the message.
-.PP
-.I Lookupcmd
-walks through the array
-.IR ctab ,
-which has
-.I ntab
-entries,
-looking for the first
-.B Cmdtab
-that matches the parsed command.
-(If the parsed command is empty,
-.I lookupcmd
-returns nil immediately.)
-A
-.B Cmdtab
-matches the command if
-.I cmd
-is equal to
-.IB cb -> f [0]
-or if
-.I cmd
-is 
-.LR * .
-Once a matching
-.B Cmdtab
-has been found, if
-.I narg
-is not zero, then the parsed command
-must have exactly
-.I narg
-fields (including the command string itself).
-If the command has the wrong number of arguments,
-.I lookupcmd
-returns nil.
-Otherwise, it returns a pointer to the
-.B Cmdtab
-entry.
-If
-.I lookupcmd
-does not find a matching command at all,
-it returns nil.
-Whenever
-.I lookupcmd
-returns nil, it sets the system error string.
-.PP
-.I Respondcmderror
-resoponds to request
-.I r
-with an error of the form
-`\fIfmt\fB:\fI cmd\fR,'
-where
-.I fmt
-is the formatted string and
-.I cmd
-is a reconstruction of the parsed command.
-Fmt
-is often simply
-.B "%r" .
-.SH EXAMPLES
-This interface is not used in any distributed 9P servers.
-It was lifted from the Plan 9 kernel.
-Almost any kernel driver
-.RB ( \*9/src/9/*/dev*.c )
-is a good example.
-.SH SOURCE
-.B \*9/src/lib9p/parse.c
-.SH SEE ALSO
-.IR 9p (3)
diff --git a/man/man3/9pfid.3 b/man/man3/9pfid.3
deleted file mode 100644
index 62251433..00000000
--- a/man/man3/9pfid.3
+++ /dev/null
@@ -1,204 +0,0 @@
-.TH 9PFID 3
-.SH NAME
-Fid, Fidpool, allocfidpool, freefidpool, allocfid, closefid, lookupfid, removefid,
-Req, Reqpool, allocreqpool, freereqpool, allocreq, closereq, lookupreq, removereq \- 9P fid, request tracking
-.SH SYNOPSIS
-.ft L
-.nf
-#include <u.h>
-#include <libc.h>
-#include <fcall.h>
-#include <thread.h>
-#include <9p.h>
-.fi
-.PP
-.ft L
-.nf
-.ta \w'\fL    'u +\w'\fLulong 'u
-typedef struct Fid
-{
-	ulong	fid;
-	char	omode;  /* -1 if not open */
-	char	*uid;
-	Qid	qid;
-	File	*file;
-	void	*aux;
-	\fI...\fP
-} Fid;
-.fi
-.PP
-.ft L
-.nf
-.ta \w'\fL    'u +\w'\fLulong 'u
-typedef struct Req
-{
-	ulong	tag;
-	Fcall	ifcall;
-	Fcall	ofcall;
-	Req	*oldreq;
-	void	*aux;
-	\fI...\fP
-} Req;
-.fi
-.PP
-.ft L
-.nf
-.ta \w'\fLFidpool* 'u
-Fidpool*	allocfidpool(void (*destroy)(Fid*))
-void	freefidpool(Fidpool *p)
-Fid*	allocfid(Fidpool *p, ulong fid)
-Fid*	lookupfid(Fidpool *p, ulong fid)
-void	closefid(Fid *f)
-void	removefid(Fid *f)
-.fi
-.PP
-.ft L
-.nf
-.ta \w'\fLReqpool* 'u
-Reqpool*	allocreqpool(void (*destroy)(Req*))
-void	freereqpool(Reqpool *p)
-Req*	allocreq(Reqpool *p, ulong tag)
-Req*	lookupreq(Reqpool *p, ulong tag)
-void	closereq(Req *f)
-void	removereq(Req *r)
-.fi
-.SH DESCRIPTION
-These routines provide management of 
-.B Fid
-and
-.B Req
-structures from 
-.BR Fidpool s
-and
-.BR Reqpool s.
-They are primarily used by the 9P server loop
-described in 
-.IR 9p (3).
-.PP
-.B Fid
-structures are intended to represent
-active fids in a 9P connection, as 
-.B Chan
-structures do in the Plan 9 kernel.
-The
-.B fid
-element is the integer fid used in the 9P 
-connection.
-.B Omode
-is the mode under which the fid was opened, or 
-.B -1 
-if this fid has not been opened yet.
-Note that in addition to the values 
-.BR OREAD ,
-.BR OWRITE ,
-and
-.BR ORDWR ,
-.B omode
-can contain the various flags permissible in
-an open call.
-To ignore the flags, use
-.BR omode&OMASK .
-.B Omode
-should not be changed by the client.
-The fid derives from a successful authentication by
-.BR uid .
-.B Qid
-contains the qid returned in the last successful
-.B walk
-or
-.B create
-transaction involving the fid.
-In a file tree-based server, the 
-.BR Fid 's
-.B file
-element points at a
-.B File
-structure 
-(see
-.IR 9pfile (3))
-corresponding to the fid.
-The
-.B aux
-member is intended for use by the
-client to hold information specific to a particular
-.BR Fid .
-With the exception of 
-.BR aux ,
-these elements should be treated
-as read-only by the client.
-.PP
-.I Allocfidpool
-creates a new 
-.BR Fidpool .
-.I Freefidpool
-destroys such a pool.
-.I Allocfid
-returns a new
-.B Fid
-whose fid number is
-.IR fid .
-There must not already be an extant
-.B Fid
-with that number in the pool.
-Once a 
-.B Fid
-has been allocated, it can be looked up by 
-fid number using
-.IR lookupfid .
-.BR Fid s
-are reference counted: both 
-.I allocfid
-and
-.I lookupfid
-increment the reference count on the 
-.B Fid
-structure before
-returning.
-When a reference to a 
-.B Fid
-is no longer needed, 
-.I closefid
-should be called to note the destruction of the reference.
-When the last reference to a 
-.B Fid
-is removed, if
-.I destroy
-(supplied when creating the fid pool)
-is not zero, it is called with the 
-.B Fid
-as a parameter.
-It should perform whatever cleanup is necessary
-regarding the
-.B aux
-element.
-.I Removefid
-is equivalent to
-.I closefid
-but also removes the
-.B Fid
-from the pool.
-Note that due to lingering references,
-the return of
-.I removefid
-may not mean that
-.I destroy
-has been called.
-.PP
-.IR Allocreqpool ,
-.IR freereqpool ,
-.IR allocreq ,
-.IR lookupreq ,
-.IR closereq ,
-and
-.I removereq
-are analogous but
-operate on 
-.BR Reqpool s
-and
-.B Req
-structures.
-.SH SOURCE
-.B \*9/src/lib9p
-.SH SEE ALSO
-.IR 9p (3),
-.IR 9pfile (3)
diff --git a/man/man3/9pfile.3 b/man/man3/9pfile.3
deleted file mode 100644
index cf03eb25..00000000
--- a/man/man3/9pfile.3
+++ /dev/null
@@ -1,223 +0,0 @@
-.TH 9PFILE 3
-.SH NAME
-Tree, alloctree, freetree,
-File, createfile, closefile, removefile, walkfile,
-opendirfile, readdirfile, closedirfile, hasperm \- in-memory file hierarchy
-.SH SYNOPSIS
-.ft L
-.nf
-#include <u.h>
-#include <libc.h>
-#include <fcall.h>
-#include <thread.h>
-#include <9p.h>
-.fi
-.PP
-.ft L
-.nf
-.ta \w'\fLFile 'u
-typedef struct File
-{
-	Ref;
-	Dir;
-	void	*aux;
-	\fI...\fP
-} File;
-.fi
-.PP
-.ft L
-.nf
-.ta \w'\fLTree 'u
-typedef struct Tree
-{
-	File *root;
-	\fI...\fP
-} Tree;
-.fi
-.PP
-.ft L
-.nf
-.ta \w'\fLReaddir* 'u +4n +4n
-Tree*	alloctree(char *uid, char *gid, ulong mode,
-				void (*destroy)(File*))
-void	freetree(Tree *tree)
-File*	createfile(File *dir, char *name, char *uid,
-				ulong mode, void *aux)
-int	removefile(File *file)
-void	closefile(File *file)
-File*	walkfile(File *dir, char *path)
-Readdir*	opendirfile(File *dir)
-long	readdirfile(Readdir *rdir, char *buf, long n)
-void	closedirfile(Readdir *rdir)
-int	hasperm(File *file, char *uid, int p)
-.fi
-.SH DESCRIPTION
-.BR File s
-and
-.BR Tree s
-provide an in-memory file hierarchy 
-intended for use in 9P file servers.
-.PP
-.I Alloctree
-creates a new tree of files, and
-.I freetree
-destroys it.
-The root of the tree
-(also the
-.B root
-element in the structure)
-will have mode
-.I mode
-and be owned by user
-.I uid
-and group
-.IR gid .
-.I Destroy
-is used when freeing 
-.B File 
-structures and is described later.
-.PP
-.BR File s
-(including directories)
-other than the root are created using
-.IR createfile ,
-which attempts to create a file named
-.I name
-in the directory
-.IR dir .
-If created, the file will have owner
-.I uid 
-and have a group inherited from
-the directory.
-.I Mode
-and the permissions of 
-.I dir
-are used to calculate the permission bits for
-the file as described in
-.IR open (9p).
-It is permissible for
-.I name
-to be a slash-separated path rather than a single element.
-.PP
-.I Removefile
-removes a file from the file tree.
-The file will not be freed until the last
-reference to it has been removed.
-Directories may only be removed when empty.
-.I Removefile
-returns zero on success, \-1 on error.
-It is correct to consider
-.I removefile
-to be
-.I closefile
-with the side effect of removing the file
-when possible.
-.PP
-.I Walkfile
-evaluates
-.I path
-relative to the directory
-.IR dir ,
-returning the resulting file,
-or zero if the named file or any intermediate element
-does not exist.
-.PP
-The 
-.B File
-structure's
-.B aux
-pointer may be used by the client
-for
-.RB per- File
-storage.
-.BR File s
-are reference-counted: if not zero,
-.I destroy
-(specified in the call to
-.IR alloctree )
-will be called for each file when its 
-last reference is removed or when the tree is freed.
-.I Destroy
-should take care of any necessary cleanup related to
-.BR aux .
-When creating new file references by copying pointers,
-call 
-.I incref
-(see
-.IR lock (3))
-to update the reference count.
-To note the removal of a reference to a file, call
-.IR closefile .
-.I Createfile
-and
-.I walkfile 
-return new references.
-.IR Removefile ,
-.IR closefile ,
-and
-.I walkfile
-(but not
-.IR createfile )
-consume the passed reference.
-.PP
-Directories may be read, yielding a directory entry structure
-(see
-.IR stat (9p))
-for each file in the directory.
-In order to allow concurrent reading of directories,
-clients must obtain a
-.B Readdir
-structure by calling 
-.I opendirfile
-on a directory.
-Subsequent calls to
-.I readdirfile
-will each yield an integral number of machine-independent
-stat buffers, until end of directory.
-When finished, call
-.I closedirfile
-to free the
-.BR Readdir .
-.PP
-.I Hasperm
-does simplistic permission checking; it assumes only
-one-user groups named by uid and returns non-zero if
-.I uid
-has permission 
-.I p
-(a bitwise-or of
-.BR AREAD ,
-.BR AWRITE
-and
-.BR AEXEC )
-according to
-.IB file ->mode \fR.
-9P servers written using
-.B File
-trees will do standard permission checks automatically;
-.I hasperm
-may be called explicitly to do additional checks.
-A 9P server may link against a different
-.I hasperm
-implementation to provide more complex groups.
-.SH EXAMPLE
-The following code correctly handles references
-when elementwise walking a path and creating a file.
-.IP
-.EX
-f = tree->root;
-incref(f);
-for(i=0; i<n && f!=nil; i++)
-	f = walkfile(f, elem[i]);
-if(f == nil)
-	return nil;
-nf = createfile(f, "foo", "nls", 0666, nil);
-closefile(f);
-return nf;
-.EE
-.SH SOURCE
-.B \*9/src/lib9p/file.c
-.SH SEE ALSO
-.IR 9p (3)
-.SH BUGS
-The reference counting is cumbersome.
diff --git a/man/man3/intmap.3 b/man/man3/intmap.3
deleted file mode 100644
index d0d3a82c..00000000
--- a/man/man3/intmap.3
+++ /dev/null
@@ -1,126 +0,0 @@
-.TH INTMAP 3
-.SH NAME
-Intmap, allocmap, freemap, insertkey, caninsertkey, lookupkey,
-deletekey \- integer to data structure maps
-.SH SYNOPSIS
-.ft L
-.nf
-#include <u.h>
-#include <libc.h>
-#include <fcall.h>
-#include <thread.h>
-#include <9p.h>
-.fi
-.PP
-.ft L
-.nf
-.ta \w'\fLIntmap* 'u
-Intmap*	allocmap(void (*inc)(void*))
-void	freemap(Intmap *map, void (*dec)(void*))
-void*	lookupkey(Intmap *map, ulong key)
-void*	insertkey(Intmap *map, ulong key, void *val)
-int	caninsertkey(Intmap *map, ulong key, void *val)
-void*	lookupkey(Intmap *map, ulong key)
-void*	deletekey(Intmap *map, ulong key)
-.fi
-.SH DESCRIPTION
-An
-.B Intmap
-is an arbitrary mapping from integers to pointers.
-.I Allocmap
-creates a new map, and
-.I freemap
-destroys it.
-The
-.I inc
-function is called each time a new pointer is added
-to the map; similarly, 
-.I dec
-is called on each pointer left in the map
-when it is being freed.
-Typically these functions maintain reference counts.
-New entries are added to the map by calling
-.IR insertkey ,
-which will return the previous value
-associated with the given
-.IR key ,
-or zero if there was no previous value.
-.I Caninsertkey
-is like
-.I insertkey
-but only inserts 
-.I val
-if there is no current mapping.
-It returns 1 if
-.I val
-was inserted, 0 otherwise.
-.I Lookupkey
-returns the pointer associated with
-.IR key ,
-or zero if there is no such pointer.
-.I Deletekey
-removes the entry for 
-.I id
-from the map, returning the
-associated pointer, if any.
-.PP
-Concurrent access to
-.BR Intmap s
-is safe, 
-moderated via a 
-.B QLock 
-stored in the 
-.B Intmap
-structure.
-.PP
-In anticipation of the storage of reference-counted
-structures, an increment function 
-.I inc
-may be specified
-at map creation time.
-.I Lookupkey
-calls
-.I inc 
-(if non-zero)
-on pointers before returning them.
-If the reference count adjustments were
-left to the caller (and thus not protected by the lock),
-it would be possible to accidentally reclaim a structure
-if, for example, it was deleted from the map and its
-reference count decremented between the return
-of 
-.I insertkey
-and the external increment.
-.IR Insertkey
-and
-.IR caninsertkey
-do
-.I not
-call
-.I inc
-when inserting 
-.I val
-into the map, nor do
-.I insertkey
-or
-.I deletekey
-call
-.I inc
-when returning old map entries.
-The rationale is that calling
-an insertion function transfers responsibility for the reference
-to the map, and responsibility is given back via the return value of
-.I deletekey
-or the next
-.IR insertkey .
-.PP
-.BR Intmap s
-are used by the 9P library to implement
-.BR Fidpool s
-and
-.BR Reqpool s.
-.SH SOURCE
-.B \*9/src/lib9p/intmap.c
-.SH SEE ALSO
-.IR 9p (3),
-.IR 9pfid (3).
diff --git a/man/man3/regexp9.3 b/man/man3/regexp9.3
deleted file mode 100644
index 12e9b71c..00000000
--- a/man/man3/regexp9.3
+++ /dev/null
@@ -1,212 +0,0 @@
-.TH REGEXP9 3
-.SH NAME
-regcomp, regcomplit, regcompnl, regexec, regsub, rregexec, rregsub, regerror \- regular expression
-.SH SYNOPSIS
-.B #include <u.h>
-.br
-.B #include <libc.h>
-.br
-.B #include <regexp.h>
-.PP
-.ta \w'\fLRegprog 'u
-.B
-Reprog	*regcomp(char *exp)
-.PP
-.B
-Reprog	*regcomplit(char *exp)
-.PP
-.B
-Reprog	*regcompnl(char *exp)
-.PP
-.nf
-.B
-int  regexec(Reprog *prog, char *string, Resub *match, int msize)
-.PP
-.nf
-.B
-void regsub(char *source, char *dest, int dlen, Resub *match, int msize)
-.PP
-.nf
-.B
-int  rregexec(Reprog *prog, Rune *string, Resub *match, int msize)
-.PP
-.nf
-.B
-void rregsub(Rune *source, Rune *dest, int dlen, Resub *match, int msize)
-.PP
-.B
-void regerror(char *msg)
-.SH DESCRIPTION
-.I Regcomp
-compiles a
-regular expression and returns
-a pointer to the generated description.
-The space is allocated by
-.IR malloc (3)
-and may be released by
-.IR free .
-Regular expressions are exactly as in
-.IR regexp9 (7).
-.PP
-.I Regcomplit
-is like
-.I regcomp
-except that all characters are treated literally.
-.I Regcompnl
-is like
-.I regcomp
-except that the
-.B .
-metacharacter matches all characters, including newlines.
-.PP
-.I Regexec
-matches a null-terminated
-.I string
-against the compiled regular expression in
-.IR prog .
-If it matches,
-.I regexec
-returns
-.B 1
-and fills in the array
-.I match
-with character pointers to the substrings of
-.I string
-that correspond to the
-parenthesized subexpressions of 
-.IR exp :
-.BI match[ i ].sp
-points to the beginning and
-.BI match[ i ].ep
-points just beyond
-the end of the
-.IR i th
-substring.
-(Subexpression
-.I i
-begins at the
-.IR i th
-left parenthesis, counting from 1.)
-Pointers in
-.B match[0]
-pick out the substring that corresponds to
-the whole regular expression.
-Unused elements of
-.I match
-are filled with zeros.
-Matches involving
-.LR * ,
-.LR + ,
-and 
-.L ?
-are extended as far as possible.
-The number of array elements in 
-.I match
-is given by
-.IR msize .
-The structure of elements of
-.I match 
-is:
-.IP
-.EX
-typedef struct {
-	union {
-	   char *sp;
-	   Rune *rsp;
-	};
-	union {
-	   char *ep;
-	   Rune *rep;
-	};
-} Resub;
-.EE
-.LP
-If
-.B match[0].sp
-is nonzero on entry,
-.I regexec
-starts matching at that point within
-.IR string .
-If
-.B match[0].ep
-is nonzero on entry,
-the last character matched is the one
-preceding that point.
-.PP
-.I Regsub
-places in
-.I dest
-a substitution instance of
-.I source
-in the context of the last
-.I regexec
-performed using
-.IR match .
-Each instance of
-.BI \e n\f1,
-where
-.I n
-is a digit, is replaced by the
-string delimited by
-.BI match[ n ].sp
-and
-.BI match[ n ].ep\f1.
-Each instance of 
-.L &
-is replaced by the string delimited by
-.B match[0].sp
-and
-.BR match[0].ep .
-The substitution will always be null terminated and
-trimmed to fit into dlen bytes.
-.PP
-.IR Regerror ,
-called whenever an error is detected in
-.IR regcomp ,
-writes the string
-.I msg
-on the standard error file and exits.
-.I Regerror
-can be replaced to perform
-special error processing.
-If the user supplied
-.I regerror
-returns rather than exits,
-.I regcomp
-will return 0. 
-.PP
-.I Rregexec
-and
-.I rregsub
-are variants of 
-.I regexec
-and
-.I regsub
-that use strings of
-.B Runes
-instead of strings of
-.BR chars .
-With these routines, the 
-.I rsp
-and
-.I rep
-fields of the
-.I match
-array elements should be used.
-.SH SOURCE
-.B \*9/src/libregexp
-.SH "SEE ALSO"
-.IR grep (1)
-.SH DIAGNOSTICS
-.I Regcomp
-returns 
-.B 0
-for an illegal expression
-or other failure.
-.I Regexec
-returns 0
-if
-.I string
-is not matched.
-.SH BUGS
-There is no way to specify or match a NUL character; NULs terminate patterns and strings.
diff --git a/man/man7/regexp9.7 b/man/man7/regexp9.7
deleted file mode 100644
index 14a90d0f..00000000
--- a/man/man7/regexp9.7
+++ /dev/null
@@ -1,150 +0,0 @@
-.TH REGEXP9 7
-.de EX
-.nf
-.ft B
-..
-.de EE
-.fi
-.ft R
-..
-.de LR
-.if t .BR \\$1 \\$2
-.if n .RB ` \\$1 '\\$2
-..
-.de L
-.nh
-.if t .B \\$1
-.if n .RB ` \\$1 '
-..
-.SH NAME
-regexp9 \- Plan 9 regular expression notation
-.SH DESCRIPTION
-This manual page describes the regular expression
-syntax used by the Plan 9 regular expression library
-.IR regexp9 (3).
-It is the form used by
-.IR egrep (1)
-before
-.I egrep
-got complicated.
-.PP
-A 
-.I "regular expression"
-specifies
-a set of strings of characters.
-A member of this set of strings is said to be
-.I matched
-by the regular expression.  In many applications
-a delimiter character, commonly
-.LR / ,
-bounds a regular expression.
-In the following specification for regular expressions
-the word `character' means any character (rune) but newline.
-.PP
-The syntax for a regular expression
-.B e0
-is
-.IP
-.EX
-e3:  literal | charclass | '.' | '^' | '$' | '(' e0 ')'
-
-e2:  e3
-  |  e2 REP
-
-REP: '*' | '+' | '?'
-
-e1:  e2
-  |  e1 e2
-
-e0:  e1
-  |  e0 '|' e1
-.EE
-.PP
-A
-.B literal
-is any non-metacharacter, or a metacharacter
-(one of
-.BR .*+?[]()|\e^$ ),
-or the delimiter
-preceded by 
-.LR \e .
-.PP
-A
-.B charclass
-is a nonempty string
-.I s
-bracketed
-.BI [ \|s\| ]
-(or
-.BI [^ s\| ]\fR);
-it matches any character in (or not in)
-.IR s .
-A negated character class never
-matches newline.
-A substring 
-.IB a - b\f1,
-with
-.I a
-and
-.I b
-in ascending
-order, stands for the inclusive
-range of
-characters between
-.I a
-and
-.IR b .
-In 
-.IR s ,
-the metacharacters
-.LR - ,
-.LR ] ,
-an initial
-.LR ^ ,
-and the regular expression delimiter
-must be preceded by a
-.LR \e ;
-other metacharacters 
-have no special meaning and
-may appear unescaped.
-.PP
-A 
-.L .
-matches any character.
-.PP
-A
-.L ^
-matches the beginning of a line;
-.L $
-matches the end of the line.
-.PP
-The 
-.B REP
-operators match zero or more
-.RB ( * ),
-one or more
-.RB ( + ),
-zero or one
-.RB ( ? ),
-instances respectively of the preceding regular expression 
-.BR e2 .
-.PP
-A concatenated regular expression,
-.BR "e1\|e2" ,
-matches a match to 
-.B e1
-followed by a match to
-.BR e2 .
-.PP
-An alternative regular expression,
-.BR "e0\||\|e1" ,
-matches either a match to
-.B e0
-or a match to
-.BR e1 .
-.PP
-A match to any part of a regular expression
-extends as far as possible without preventing
-a match to the remainder of the regular expression.
-.SH "SEE ALSO"
-.IR regexp9 (3)