Add mandoc-manpage for expr(1)

and mark it as finished in README.
Upon further checking, expr(1) turns out to be implicitly UTF-8 compliant.
This commit is contained in:
FRIGN 2015-01-25 16:49:46 +01:00
parent 1a8dfaca37
commit b98bf41ecc
3 changed files with 79 additions and 134 deletions

2
README
View File

@ -29,7 +29,7 @@ The following tools are implemented ('*' == finished, '#' == UTF-8 support,
=* echo yes none =* echo yes none
=* env yes none =* env yes none
#* expand yes none #* expand yes none
expr yes none =* expr yes none
=* false yes none =* false yes none
fold yes none fold yes none
grep yes none grep yes none

207
expr.1
View File

@ -1,12 +1,5 @@
.\" $OpenBSD: src/bin/expr/expr.1,v 1.22 2014/02/23 18:13:27 schwarze Exp $ .Dd January 25, 2015
.\" $NetBSD: expr.1,v 1.9 1995/04/28 23:27:13 jtc Exp $ .Dt EXPR 1 sbase\-VERSION
.\"
.\" Written by J.T. Conklin <jtc@netbsd.org>.
.\" Public domain.
.\"
.Dd $Mdocdate: September 3 2010 $
.Dt EXPR 1
.Os
.Sh NAME .Sh NAME
.Nm expr .Nm expr
.Nd evaluate expression .Nd evaluate expression
@ -14,143 +7,95 @@
.Nm expr .Nm expr
.Ar expression .Ar expression
.Sh DESCRIPTION .Sh DESCRIPTION
The
.Nm .Nm
utility evaluates evaluates
.Ar expression .Ar expression
and writes the result on standard output. and writes the result to stdout.
All operators are separate arguments to the
.Nm
utility.
Characters special to the command interpreter must be escaped.
.Pp .Pp
Operators are listed below in order of increasing precedence. There are two elemental expressions,
Operators with equal precedence are grouped within { } symbols. .Sy integer
.Bl -tag -width indent and
.It Ar expr1 | expr2 .Sy string.
Returns the evaluation of Let
.Ar expr1 .Sy expr
if it is neither an empty string nor zero; be a non-elemental expression and
otherwise, returns the evaluation of .Sy expr1 ,
.Ar expr2 . .Sy expr2
.It Ar expr1 Li & Ar expr2 arbitrary expressions. Then
Returns the evaluation of .Sy expr
.Ar expr1 has the recursive form
if neither expression evaluates to an empty string or zero; .Sy expr = [(] expr1 operand expr2 [)].
otherwise, returns zero. .Pp
.It Ar expr1 Li "{=, >, >=, <, <=, !=}" Ar expr2 With
Returns the results of integer comparison if both arguments are integers; .Sy operand
otherwise, returns the results of string comparison using the locale-specific being in oder of increasing precedence:
collation sequence. .Bl -tag -width Ds
The result of each comparison is 1 if the specified relation is true, .It |
or 0 if the relation is false. Evaluate to
.It Ar expr1 Li "{+, -}" Ar expr2 .Sy expr1
Returns the results of addition or subtraction of integer-valued arguments. if it is neither an empty string nor 0; otherwise evaluate to
.It Ar expr1 Li "{*, /, %}" Ar expr2 .Sy expr2 .
Returns the results of multiplication, integer division, or remainder of .It &
integer-valued arguments. Evaluate to
.It Ar expr1 Li : Ar expr2 .Sy expr1
The if
.Ql \&: .Sy expr1
operator matches and
.Ar expr1 .Sy expr2
are neither empty strings nor 0; otherwise evaluate to 0.
.It = > >= < <= !=
If
.Sy expr1
and
.Sy expr2
are integers, evaluate to 1 if the relation is true and 0 if it is false.
If
.Sy expr1
and
.Sy expr2
are strings, apply the relation to the return value of
.Xr strcmp 3 .
.It + -
If
.Sy expr1
and
.Sy expr2
are integers, evaluate to their sum or subtraction.
.It * / %
If
.Sy expr1
and
.Sy expr2
are integers, evaluate to their mulitplication, division or remainder.
.It :
Evaluate to the number of characters matched in
.Sy expr1
against against
.Ar expr2 , .Sy expr2 . expr2
which must be a basic regular expression. is anchored with an implicit '^'.
The regular expression is anchored
to the beginning of the string with an implicit
.Ql ^ .
.Pp .Pp
If the match succeeds and the pattern contains at least one regular You can't directly match the empty string, since zero matched characters
expression subexpression resolve equally to a failed match. To work around this limitation, use "expr X'' : 'X$' instead of "expr '' : '$'"
.Dq "\e(...\e)" ,
the string corresponding to
.Dq "\e1"
is returned;
otherwise, the matching operator returns the number of characters matched.
If the match fails and the pattern contains a regular expression subexpression
the null string is returned;
otherwise, returns 0.
.Pp
Note: the empty string cannot be matched using
.Bd -literal -offset indent
expr '' : '$'
.Ed
.Pp
This is because the returned number of matched characters
.Pq zero
is indistinguishable from a failed match, so
.Nm
returns failure
.Pq 0 .
To match the empty string, use a structure such as:
.Bd -literal -offset indent
expr X'' : 'X$'
.Ed
.El .El
.Pp
Parentheses are used for grouping in the usual manner.
.Sh EXIT STATUS .Sh EXIT STATUS
The .Bl -tag -width Ds
.Nm
utility exits with one of the following values:
.Pp
.Bl -tag -width Ds -offset indent -compact
.It 0 .It 0
The expression is neither an empty string nor 0. .Ar expression
is neither an empty string nor 0
.It 1 .It 1
The expression is an empty string or 0. .Ar expression
is an empty string or 0
.It 2 .It 2
The expression is invalid. .Ar expression
.It \*(Gt2 is invalid
An error occurred (such as memory allocation failure). .It > 2
An error occured
.El .El
.Sh EXAMPLES
Add 1 to the variable
.Va a :
.Bd -literal -offset indent
$ a=`expr $a + 1`
.Ed
.Pp
Return the filename portion of a pathname stored
in variable
.Va a .
The
.Ql //
characters act to eliminate ambiguity with the division operator:
.Bd -literal -offset indent
$ expr "//$a" \&: '.*/\e(.*\e)'
.Ed
.Pp
Return the number of characters in variable
.Va a :
.Bd -literal -offset indent
$ expr $a \&: '.*'
.Ed
.Sh SEE ALSO .Sh SEE ALSO
.Xr test 1 , .Xr test 1
.Xr re_format 7
.Sh STANDARDS .Sh STANDARDS
The The
.Nm .Nm
utility is compliant with the utility is compliant with the
.St -p1003.1-2008 .St -p1003.1-2008
specification. specification.
.Sh HISTORY
The
.Nm
utility first appeared in the Programmer's Workbench (PWB/UNIX)
and has supported regular expressions since
.At v7 .
It was rewritten from scratch for
.Bx 386 0.1
and again for
.Nx 1.1 .
.Sh AUTHORS
.An -nosplit
The first free version was written by
.An Pace Willisson
in 1992.
This version was written by
.An John T. Conklin
in 1994.

4
expr.c
View File

@ -182,11 +182,11 @@ lex(char *p)
} }
/* one-char operand */ /* one-char operand */
if (*p && !*(p+1) && strchr(ops, *p)) if (*p && !*(p + 1) && strchr(ops, *p))
return *p; return *p;
/* two-char operand */ /* two-char operand */
if (*p && *(p+1) == '=' && !*(p+2)) { if (*p && *(p + 1) == '=' && !*(p + 2)) {
switch (*p) { switch (*p) {
case '>': case '>':
return GE; return GE;