expr(1)                        DG/UX R4.11MU05                       expr(1)


NAME
       expr - evaluate arguments as an expression

SYNOPSIS
       expr arguments

DESCRIPTION
       The arguments are taken as an expression.  After evaluation, the
       result is written on the standard output.  Terms of the expression
       must be separated by blanks.  Characters special to the shell must be
       escaped.  Note that 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, 2s complement numbers.  The length of the expression is
       limited to 512 characters.  Expressions may be grouped using
       (escaped) parentheses.

       The operators and keywords are listed below.  Characters that need to
       be escaped in the shell [see sh(1)] are preceded by \.  The list is
       in order of increasing precedence, with equal precedence operators
       grouped within {} symbols.

       expr \| expr
            Return the first expr if it is neither null nor 0, otherwise
            return the second expr.

       expr \& expr
            Return the first expr if neither expr is null or 0, otherwise
            return 0.

       expr { =, \>, \>=, \<, \<=, != } expr
            Return the result of an integer comparison if both arguments are
            integers, otherwise return the result of a lexical comparison.

       expr { +, - } expr
            Add or subtract integer-valued arguments.

       expr { \*, /, % } expr
            Multiply, divide, or compute remainder of integer-valued
            arguments.

       expr : expr
       match expr expr
            Compare the first argument with the second argument, which must
            be a regular expression.  Regular expression syntax is the same
            as that of ed(1), except that all patterns are ``anchored''
            (that is, 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).
            Alternatively, the \( . . . \) pattern symbols can be used to
            return a portion of the first argument.

       length string
            Return the length of string.

       substr string index count
            Return the portion of string composed of at most count
            characters starting at the character position of string as
            expressed by index (where the first character of string is index
            1, not 0).

       index string charactersequence
            Return the index of the first character in string that is also
            in charactersequence or 0 to indicate no match.

   International Features
       expr processes supplementary code set characters according to the
       locale specified in the LCCTYPE environment variable [see LANG on
       environ(5)].  In regular expressions, pattern searches are performed
       on characters, not bytes, as described on ed(1).  String comparisons
       are affected by the LCCOLLATE and LCCTYPE environment variables
       [see LANG on environ(5)].

EXAMPLES
       Add 1 to the shell variable a (assuming a is set to an integer
       value):

              a=`expr $a + 1`

       The following example emulates basename(1); it returns the last
       segment of the path name $a.  For $a equal to either /usr/abc/file or
       just file, the example returns file.  The // characters eliminate any
       ambiguity about the division operator.

              expr //$a : '.*/\(.*\)'
       Here is a better version of the previous example.  The addition of
       the // characters eliminates any ambiguity about the division
       operator and simplifies the whole expression.

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

       Return the number of characters in $VAR:

              expr $VAR : '.*'

       or

              expr length $VAR

DIAGNOSTICS
       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 null or 0
            2    for invalid expressions.

        syntax error     for operator/operand errors
        non-numeric argument
                         if arithmetic is attempted on such a string

SEE ALSO
       regexp(5).

NOTES
       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 are all taken as the =
       operator).  The following works:

              expr X$a = X=


Licensed material--property of copyright holder(s)