expr(1)

     NAME
          expr - evaluate expressions

     SYNOPSIS
          expr expression...
          expr {--help,--version}

     DESCRIPTION
          This documentation is no longer being maintained and may be
          inaccurate or incomplete.  The Texinfo documentation is now
          the authoritative source.

          This manual page documents the GNU version of expr.  expr
          evaluates an expression and writes the result on its
          standard output.  Each token of the expression must be a
          separate argument.  Operands are either numbers or strings.
          Strings are not quoted for expr, though you may need to
          quote them to protect them from the shell.  expr coerces
          anything appearing in an operand position to an integer or a
          string depending on the operation being applied to it.

          The operators (in order of increasing precedence) are:

          |    Yields its first argument if it is neither null nor 0,
               otherwise its second argument.  This is the usual `or'
               operation.

          &    Yields its first argument if neither argument is null
               or 0, otherwise 0.

          <  <=  =  ==  !=  >=  >
               Compare their arguments and return 1 if the relation is
               true, 0 otherwise.  (== is a synonym for =.)  expr
               tries to coerce both arguments to numbers and do a
               numeric comparison; if it fails when trying to coerce
               either argument it then does a lexicographic
               comparison.

          +  - Perform arithmetic operations.  Both arguments are
               coerced to numbers; an error occurs if this cannot be
               done.

          *  /  %
               Perform arithmetic operations (`%' is the remainder
               operation, as in C).  Both arguments are coerced to
               numbers; an error occurs if this cannot be done.

          :    Perform pattern matching.  Its arguments are coerced to
               strings and the second one is considered to be a
               regular expression, with a `^' implicitly added at the
               beginning.  The first argument is then matched against
               this regular expression.  If the match succeeds and
               part of the string is enclosed in `\(' and `\)', that
               part is the value of the : expression; otherwise an
               integer whose value is the number of characters matched
               is returned.  If the match fails, the :  operator
               returns the null string if `\(' and `\)' are used,
               otherwise 0.  Only one `\(' and `\)' pair can be used.

          In addition, the following keywords are recognized:

          match string regex
               An alternative way to do pattern matching.  This is the
               same as ``string : regex''.

          substr string position length
               Return the substring of string beginning at position
               with length at most length.  If either position or
               length is negative or non-numeric, return a null
               string.

          index string character-class
               Return the first position in string where the first
               character in character-class was found.  If no
               character in character-class is found in string, return
               0.

          length string
               Return the length of string.

          Parentheses are used for grouping in the usual manner.  The
          keywords cannot be used as strings.

        OPTIONS
          When GNU expr is invoked with exactly one argument, the
          following options are recognized:

          --help
               Print a usage message on standard output and exit
               successfully.

          --version
               Print version information on standard output then exit
               successfully.

     EXAMPLES
          To add 1 to the shell variable a:

               a=`expr $a + 1`

          The following may be used to print the non-directory part of
          the file name stored in variable a (the value in a need not
          contain `/'):

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

          Note the quoted shell metacharacters.

          expr returns the following exit status:

          0 if the expression is neither null nor 0,
          1 if the expression is null or 0,
          2 for invalid expressions.