expr - evaluate  arguments  as  a  logical,  arithmetic,  or
     string expression


     /usr/ucb/expr argument...


     The expr utility evaluates expressions as specified  by  its
     arguments.  After  evaluation,  the result is written on the
     standard output. Each token of the expression is a  separate
     argument,  so  terms  of the expression must be separated by
     blanks. Characters special to the  shell  must  be  escaped.
     Note:  0  is  returned to indicate a zero value, rather than
     the null string. Strings containing blanks or other  special
     characters should be quoted. Integer-valued arguments may be
     preceded by a unary minus  sign.  Internally,  integers  are
     treated as 32-bit, two's-complement numbers.

     The operators and keywords are listed below. Characters that
     need to be escaped are preceded by `\'. The list is in order
     of increasing precedence, with  equal  precedence  operators
     grouped within {} symbols.

     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 lexical comparison.

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

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

     string : regular-expression

     match string regular-expression
           The two forms  of  the  matching  operator  above  are
           synonymous. The matching operators : and match compare
           the first argument with the second argument which must
           be  a regular expression. Regular expression syntax is
           the same as that of regexp(5), except  that  all  pat-
           terns are "anchored" (treated as if they begin with ^)
           and therefore ^ is not a special  character,  in  that
           context.  Normally,  the matching operator returns the
           number of characters matched (0 on failure).  Alterna-
           tively,  the  \...\  pattern  symbols  can  be used to
           return a portion of the first argument.

     substr string integer-1 integer-2
           Extracts the substring of  string starting at position
           integer-1  and  of  length  integer-2  characters.  If
           integer-1 has a  value  greater  than  the  length  of
           string,  expr  returns  a  null  string. If you try to
           extract more characters than there are in string, expr
           returns  all  the  remaining  characters  from string.
           Beware of using negative values for  either  integer-1
           or  integer-2  as   expr tends to run forever in these

     index string character-list
           Reports the first position in string at which any  one
           of  the characters in character-list matches a charac-
           ter in  string.

     length string
           Returns the length (that is, the number of characters)
           of string.

     ( expr )
           Parentheses may be used for grouping.


     Example 1: Adding an integer to a shell variable

     Add 1 to the shell variable a.

     a='expr $a + 1'

     Example 2: Returning a path name segment

     Return the last  segment  of  a  path  name  (that  is,  the
     filename  part).  Watch out for / alone as an argument: expr
     will take it as the division operator (see BUGS below).

     # 'For $a equal to either "/usr/abc/file" or just "file"'
     expr  $a  :  '.*/\  \  $a

     Example 3: Using // characters to simplify the expression

     The addition of the // characters eliminates  any  ambiguity
     about the division operator and simplifies the whole expres-

     # A better representation of example 2.
     expr  //$a  :  '.*/\

     Example 4: Returning the value of a variable

     Returns the number of characters in $VAR.

     expr  $VAR  :  '.*'


     expr returns the following exit codes:

     0     If the expression is neither  NULL nor 0.

     1     If the expression is NULL or 0.

     2     For invalid expressions.


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

    |       ATTRIBUTE TYPE        |       ATTRIBUTE VALUE       |
    | Availability                | SUNWscpu                    |


     sh(1), test(1), attributes(5), regexp(5)


     syntax error
           for operator/operand errors

     non-numeric argument
           if arithmetic is attempted on such a string

     division by zero
           if an attempt to divide by zero is made


     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:

     expr  $a  =  '='

     looks like:

     expr  =  =  =

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

     expr  X$a  =  X=

     Note: the match, substr, length, and index operators  cannot
     themselves  be  used  as  ordinary  strings.   That  is, the

     example% expr index expurgatorious length
     syntax error

     generates the `syntax error' message as shown instead of the
     value 1 as you might expect.

Man(1) output converted with man2html