trenamed - plan9port - [fork] Plan 9 from user space
(HTM) git clone git://src.adamsgaard.dk/plan9port
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
(DIR) commit 12fdfd7b841d93e02a1d26e8e720290921107972
(DIR) parent aae5c0bc63ab42eae180f6a013ddf378d76a82a1
(HTM) Author: rsc <devnull@localhost>
Date: Fri, 14 Jan 2005 19:27:13 +0000
renamed
Diffstat:
D man/man3/9pcmdbuf.3 | 118 -------------------------------
D man/man3/9pfid.3 | 204 -------------------------------
D man/man3/9pfile.3 | 223 ------------------------------
D man/man3/intmap.3 | 126 -------------------------------
D man/man3/regexp9.3 | 212 ------------------------------
D man/man7/regexp9.7 | 150 -------------------------------
6 files changed, 0 insertions(+), 1033 deletions(-)
---
(DIR) diff --git a/man/man3/9pcmdbuf.3 b/man/man3/9pcmdbuf.3
t@@ -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)
(DIR) diff --git a/man/man3/9pfid.3 b/man/man3/9pfid.3
t@@ -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)
(DIR) diff --git a/man/man3/9pfile.3 b/man/man3/9pfile.3
t@@ -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.
(DIR) diff --git a/man/man3/intmap.3 b/man/man3/intmap.3
t@@ -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).
(DIR) diff --git a/man/man3/regexp9.3 b/man/man3/regexp9.3
t@@ -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.
(DIR) diff --git a/man/man7/regexp9.7 b/man/man7/regexp9.7
t@@ -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)