expr - evaluate arguments as an expression


     /usr/bin/expr argument...

     /usr/xpg4/bin/expr argument...


     The expr utility evaluates the  expression  and  writes  the
     result  to  standard  output.  The character 0 is written to
     indicate a zero value and nothing is written to  indicate  a
     null string.


     The argument operand is evaluated as an expression. Terms of
     the  expression must be separated by blanks. Characters spe-
     cial to the shell must be escaped (see sh(1)). Strings  con-
     taining blanks or other special characters should be quoted.
     The length of the expression is limited  to  LINE_MAX  (2048

     The operators and keywords are listed below. The list is  in
     order of increasing precedence, with equal precedence opera-
     tors grouped within {} symbols. All  of  the  operators  are

     expr \| expr
           Returns the evaluation of the first expr if it is nei-
           ther  NULL nor 0; otherwise, returns the evaluation of
           the second expr if it is not NULL; otherwise, 0.

     expr \& expr
           Returns the first expr if neither expr is NULL  or  0,
           otherwise returns 0.

     expr{ =, \>, \>=, \<, \<=, !=} expr
           Returns the result of an integer  comparison  if  both
           arguments  are  integers, otherwise returns the result
           of a string comparison using the locale-specific coal-
           ition  sequence. The result of each comparison will be
           1 if the specified relationship  is  TRUE,  0  if  the
           relationship is FALSE.

     expr { +, - } expr
           Addition or subtraction of integer-valued arguments.

     expr { \*, /, %} expr
           Multiplication,  division,   or   remainder   of   the
           integer-valued arguments.

     expr : expr
           The matching operator :  (colon)  compares  the  first
           argument  with  the  second argument, which must be an
           internationalized basic regular expression (BRE).  See
           regex(5) and NOTES. Normally, the /usr/bin/expr match-
           ing operator returns the number of bytes  matched  and
           the  /usr/xpg4/bin/expr  matching operator returns the
           number of characters matched (0 on  failure).  If  the
           second   argument  contains  at  least  one  BRE  sub-
           expression [\(...\)], the  matching  operator  returns
           the string corresponding to \1.

           An argument consisting only  of  an  (optional)  unary
           minus followed by digits.

           A string argument that  cannot  be  identified  as  an
           integer  argument or as one of the expression operator

  Compatibility Operators (x86 only)
     The following operators are included for compatibility  with
     INTERACTIVE UNIX System only and are not intended to be used
     by non- INTERACTIVE UNIX System scripts:

     index string character-list
           Report the first position in  which  any  one  of  the
           bytes in character-list matches a byte in string.

     length string
           Return the length (that is, the number  of  bytes)  of

     substr string integer-1 integer-2
           Extract the substring of string starting  at  position
           integer-1 and of length integer-2 bytes.  If integer-1
           has a value  greater  than  the  number  of  bytes  in
           string,  expr  returns  a  null string.  If you try to
           extract more bytes than  there  are  in  string,  expr
           returns  all  the remaining bytes from string. Results
           are unspecified if either integer-1 or integer-2 is  a
           negative value.


     Example 1: Adding an integer to a shell variable

     Add 1 to the shell variable a:

     example$ a=`expr $a + 1`

     Example 2: Returning a path name segment

     The following example emulates  basename(1),  returning  the
     last  segment  of  the  path name $a. For $a equal to either
     /usr/abc/file or just file, the example returns file. (Watch
     out  for  / alone as an argument: expr takes it as the divi-
     sion operator.  See NOTES below.)

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

     Example 3: Using // characters to simplify the expression

     Here is a better version of the previous example. The  addi-
     tion of the // characters eliminates any ambiguity about the
     division operator and simplifies the whole expression.

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

     Example 4: Returning the number of bytes in a variable

     example$ expr "$VAR" : '.*'

     Example 5: Returning the number of characters in a variable

     example$ expr "$VAR" : '.*'


     See environ(5) for descriptions of the following environment
     variables  that  affect the execution of expr: LANG, LC_ALL,


     As a side effect of expression evaluation, expr returns  the
     following exit values:

     0     If the expression is neither NULL nor 0.

     1     If the expression is either NULL or 0.

     2     For invalid expressions.

     >2    An error occurred.


     See attributes(5) for descriptions of the  following  attri-

    |       ATTRIBUTE TYPE        |       ATTRIBUTE VALUE       |
    | Availability                | SUNWcsu                     |
    | CSI                         | enabled                     |
    | Interface Stability         | Standard                    |


     basename(1),   ed(1),   sh(1),   Intro(3),    attributes(5),
     environ(5), regex(5), standards(5)


     syntax error
           Operator and operand errors.

     non-numeric argument
           Arithmetic is attempted on such a string.


     After argument processing by the shell, expr cannot tell the
     difference  between an operator and an operand except by the
     value. If $a is an =, the command:

     example$ expr $a = '='

     looks like:

     example$ expr = = =

     as the arguments are passed to expr (and they are all  taken
     as the = operator). The following works:

     example$ expr X$a = X=

  Regular Expressions
     Unlike some previous versions, expr  uses  Internationalized
     Basic  Regular  Expressions for all system-provided locales.
     Internationalized Regular Expressions are explained  on  the
     regex(5) manual page.

Man(1) output converted with man2html