expr(1) - NetBSD Manual Pages

Command:
Section:
Arch:
Collection:
>>>
EXPR(1)                 NetBSD General Commands Manual                 EXPR(1)


NAME

     expr -- evaluate expression


SYNOPSIS

     expr operand ...


DESCRIPTION

     The expr utility evaluates the expression consisting of the operand argu-
     ments and writes the result on standard output.

     Each operand is a separate argument to the expr utility.  Characters spe-
     cial to the command interpreter must be escaped.

     Operators are listed below in order of increasing precedence.  Operators
     with equal precedence are grouped within { } symbols.

     expr1 | expr2
             Returns the evaluation of expr1 if it is neither an empty string
             nor zero; otherwise, returns the evaluation of expr2 if it is not
             empty; otherwise, returns zero.

     expr1 & expr2
             Returns the evaluation of expr1 if neither expression evaluates
             to an empty string or zero; otherwise, returns zero.

     expr1 {=, >, >=, <, <=, !=} expr2
             Returns the result of the integer comparison if both arguments
             are integers; otherwise, returns the result of the string compar-
             ison using the locale-specific collation sequence.  The result of
             each comparison is 1 if the specified relation is true, or 0 if
             the relation is false.

     expr1 {+, -} expr2
             Returns the result of addition or subtraction of integer-valued
             arguments.

     expr1 {*, /, %} expr2
             Returns the result of multiplication, integer division, or
             remainder of integer-valued arguments.

     expr1 : expr2
             The ``:'' operator matches expr1 against expr2, the latter must
             be a regular expression.  The regular expression is anchored to
             the beginning of the string with an implicit ``^''.

             If the match succeeds and the pattern contains at least one regu-
             lar expression subexpression ``\(...\)'', the string correspond-
             ing to ``\1'' 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
             empty string is returned; otherwise 0.

     (  expr  )
             Parentheses are used for grouping in the usual manner.

     Additionally, the following keywords are recognized:

     length expr
             Returns the length of the specified string in bytes.

     Operator precedence (from highest to lowest):
           1.   parentheses
           2.   length
           3.   ``:''
           4.   ``*'', ``/'', and ``%''
           5.   ``+'' and ``-''
           6.   compare operators
           7.   ``&''
           8.   ``|''


EXIT STATUS

     The expr utility exits with one of the following values:
     0       the expression is neither an empty string nor 0.
     1       the expression is an empty string or 0.
     2       the expression is invalid.
     >2      an error occurred (such as memory allocation failure).


EXAMPLES

     1.   The following example adds one to variable ``a'':
                a=`expr $a + 1`

     2.   The following example returns zero, due to subtraction having higher
          precedence than the ``&'' operator:
                expr 1 '&' 1 - 1

     3.   The following example returns the filename portion of a pathname
          stored in variable ``a'':
                expr /$a : '.*/\(.*\)'

     4.   The following example returns the number of characters in variable
          ``a'':
                expr $a : '.*'


COMPATIBILITY

     This implementation of expr internally uses 64 bit representation of
     integers and checks for over- and underflows.  It also treats ``/'' (the
     division mark) and option ``--'' correctly depending upon context.

     expr on other systems (including NetBSD up to and including NetBSD 1.5)
     might not be so graceful.  Arithmetic results might be arbitrarily lim-
     ited on such systems, most commonly to 32 bit quantities.  This means
     such expr can only process values between -2147483648 and +2147483647.

     On other systems, expr might also not work correctly for regular expres-
     sions where either side contains ``/'' (a single forward slash), like
     this:

           expr / : '.*/\(.*\)'

     If this is the case, you might use ``//'' (a double forward slash) to
     avoid confusion with the division operator:

           expr "//$a" : '.*/\(.*\)'

     According to IEEE Std 1003.2 (``POSIX.2''), expr has to recognize the
     special option ``--'', treat it as a delimiter to mark the end of command
     line options, and ignore it.  Some expr implementations do not recognize
     it at all; others might ignore it even in cases where doing so results in
     syntax error.  There should be the same result for both following exam-
     ples, but it might not always be:
           1.   expr -- : .
           2.   expr -- -- : .
     Although NetBSD expr handles both cases correctly, you should not depend
     on this behavior for portability reasons and avoid passing a bare ``--''
     as the first argument.


STANDARDS

     The expr utility conforms to IEEE Std 1003.2 (``POSIX.2'').  The length
     keyword is an extension for compatibility with GNU expr.


HISTORY

     An expr utility first appeared in the Programmer's Workbench (PWB/UNIX).
     A public domain version of expr written by Pace Willisson
     <pace@blitz.com> appeared in 386BSD 0.1.


AUTHORS

     Initial implementation by Pace Willisson <pace@blitz.com> was largely
     rewritten by J.T. Conklin <jtc@NetBSD.org>.  It was rewritten again for
     NetBSD 1.6 by Jaromir Dolecek <jdolecek@NetBSD.org>.


NOTES

     The empty string ``'' cannot be matched with the intuitive:

           expr '' : '$'

     The reason is that the returned number of matched characters (zero) is
     indistinguishable from a failed match, so this returns failure.  To match
     the empty string, use something like:

           expr x'' : 'x$'

NetBSD 10.99                    March 15, 2025                    NetBSD 10.99