expr(P)                                                 expr(P)





NAME
       expr - evaluate arguments as an expression

SYNOPSIS
       expr operand

DESCRIPTION
       The  expr utility shall evaluate an expression and write
       the result to standard output.

OPTIONS
       None.

OPERANDS
       The single expression evaluated by expr shall be  formed
       from the operands, as described in the EXTENDED DESCRIP-
       TION section. The application shall ensure that each  of
       the expression operator symbols:


              (  )  |  &  =  >  >=  <  <=  !=  +  -  *  /  %  :

       and the symbols integer and string in the table are pro-
       vided as separate arguments to expr.

STDIN
       Not used.

INPUT FILES
       None.

ENVIRONMENT VARIABLES
       The following environment  variables  shall  affect  the
       execution of expr:

       LANG   Provide a default value for the internationaliza-
              tion variables that are unset or null.  (See  the
              Base  Definitions volume of IEEE Std 1003.1-2001,
              Section 8.2, Internationalization  Variables  for
              the  precedence of internationalization variables
              used to determine  the  values  of  locale  cate-
              gories.)

       LC_ALL If  set to a non-empty string value, override the
              values  of  all  the  other  internationalization
              variables.

       LC_COLLATE

              Determine  the locale for the behavior of ranges,
              equivalence classes, and multi-character  collat-
              ing  elements  within  regular expressions and by
              the string comparison operators.

       LC_CTYPE
              Determine the locale for  the  interpretation  of
              sequences  of  bytes  of  text data as characters
              (for example, single-byte as  opposed  to  multi-
              byte characters in arguments) and the behavior of
              character classes within regular expressions.

       LC_MESSAGES
              Determine the  locale  that  should  be  used  to
              affect  the  format  and  contents  of diagnostic
              messages written to standard error.

       NLSPATH
              Determine the location of  message  catalogs  for
              the processing of LC_MESSAGES .


ASYNCHRONOUS EVENTS
       Default.

STDOUT
       The expr utility shall evaluate the expression and write
       the result, followed by a <newline>, to standard output.

STDERR
       The  standard  error  shall  be used only for diagnostic
       messages.

OUTPUT FILES
       None.

EXTENDED DESCRIPTION
       The formation of the expression to be evaluated is shown
       in  the  following  table.  The symbols expr, expr1, and
       expr2 represent  expressions  formed  from  integer  and
       string  symbols and the expression operator symbols (all
       separate arguments) by recursive application of the con-
       structs  described  in  the  table.  The expressions are
       listed in order of increasing  precedence,  with  equal-
       precedence  operators  grouped between horizontal lines.
       All of the operators shall be left-associative.
Expression         Description
expr1 | expr2      Returns the evaluation of expr1 if it is neither null nor zero; otherwise, returns the evaluation of expr2 if it is not null; otherwise, zero.
expr1 & expr2      Returns the evaluation of expr1 if neither expression evaluates to null or zero; otherwise, returns zero.
                   Returns the result of a decimal integer comparison if both arguments are integers; otherwise, returns the result of a string comparison using the locale-specific collation sequence. The result of each comparison is 1 if the specified relationship is true, or 0 if the relationship is false.
expr1 = expr2      Equal.
expr1 > expr2      Greater than.
expr1 >= expr2     Greater than or equal.
expr1 < expr2      Less than.
expr1 <= expr2     Less than or equal.
expr1 != expr2     Not equal.
expr1 + expr2      Addition of decimal integer-valued arguments.
expr1 - expr2      Subtraction of decimal integer-valued arguments.
expr1 * expr2      Multiplication of decimal integer-valued arguments.
expr1 / expr2      Integer division of decimal integer-valued arguments, producing an integer result.
expr1 % expr2      Remainder of integer division of decimal integer-valued arguments.
expr1 : expr2      Matching expression; see below.
( expr )           Grouping symbols. Any expression can be placed within parentheses. Parentheses can be nested to a depth of {EXPR_NEST_MAX}.
integer            An argument consisting only of an (optional) unary minus followed by digits.
string             A string argument; see below.

   Matching Expression
       The ':'  matching  operator  shall  compare  the  string
       resulting  from the evaluation of expr1 with the regular
       expression pattern  resulting  from  the  evaluation  of
       expr2.  Regular  expression syntax shall be that defined
       in the Base Definitions volume of  IEEE Std 1003.1-2001,
       Section  9.3, Basic Regular Expressions, except that all
       patterns are anchored to the  beginning  of  the  string
       (that is, only sequences starting at the first character
       of a string are matched by the regular expression)  and,
       therefore,  it  is  unspecified whether '^' is a special
       character in that context. Usually, the matching  opera-
       tor  shall  return  a  string representing the number of
       characters matched ( '0' on failure). Alternatively,  if
       the  pattern  contains  at  least one regular expression
       subexpression "[\(...\)]" , the string corresponding  to
       "\1" shall be returned.

   String Operand
       A  string argument is an argument that cannot be identi-
       fied as an integer argument or as one of the  expression
       operator symbols shown in the OPERANDS section.

       The  use  of  string arguments length, substr, index, or
       match produces unspecified results.

EXIT STATUS
       The following exit values shall be returned:

        0     The expression  evaluates  to  neither  null  nor
              zero.

        1     The expression evaluates to null or zero.

        2     Invalid expression.

       >2     An error occurred.


CONSEQUENCES OF ERRORS
       Default.

       The following sections are informative.

APPLICATION USAGE
       After  argument  processing  by  the  shell, expr is not
       required to be able to tell the  difference  between  an
       operator  and an operand except by the value. If "$a" is
       '=' , the command:


              expr $a = '='

       looks like:


              expr = = =

       as the arguments are passed to expr (and they all may be
       taken  as  the  '=' operator). The following works reli-
       ably:


              expr X$a = X=

       Also note that this volume of IEEE Std 1003.1-2001  per-
       mits implementations to extend utilities. The expr util-
       ity permits the integer arguments to be preceded with  a
       unary  minus.  This means that an integer argument could
       look like an option. Therefore, the conforming  applica-
       tion  must  employ the "--" construct of Guideline 10 of
       the Base  Definitions  volume  of  IEEE Std 1003.1-2001,
       Section  12.2,  Utility Syntax Guidelines to protect its
       operands if there is any chance the first operand  might
       be  a  negative  integer  (or  any string with a leading
       minus).

EXAMPLES
       The expr utility has a rather difficult syntax:

              Many of the  operators  are  also  shell  control
              operators  or  reserved words, so they have to be
              escaped on the command line.

              Each part of the expression is composed of  sepa-
              rate  arguments,  so liberal usage of <blank>s is
              required. For example:
     Invalid              Valid

     expr 1+2             expr 1 + 2
     expr "1 + 2"         expr 1 + 2
     expr 1 + (2 * 3)     expr 1 + \( 2 \* 3 \)

       In many cases, the arithmetic and string  features  pro-
       vided  as  part of the shell command language are easier
       to use than their equivalents  in  expr.  Newly  written
       scripts  should  avoid expr in favor of the new features
       within the  shell;  see  Parameters  and  Variables  and
       Arithmetic Expansion .

       The following command:


              a=$(expr $a + 1)

       adds 1 to the variable a.

       The   following   command,  for  "$a"  equal  to  either
       /usr/abc/file or just file:


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

       returns the last segment of a pathname (that is,  file).
       Applications  should  avoid the character '/' used alone
       as an argument; expr may interpret it  as  the  division
       operator.

       The following command:


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

       is  a better representation of the previous example. The
       addition of the "//" characters eliminates any ambiguity
       about  the  division  operator  and simplifies the whole
       expression. Also note that pathnames may contain charac-
       ters  contained in the IFS variable and should be quoted
       to avoid having "$a" expand into multiple arguments.

       The following command:


              expr "$VAR" : '.*'

       returns the number of characters in VAR.

RATIONALE
       In an early proposal, EREs were  used  in  the  matching
       expression  syntax.   This  was changed to BREs to avoid
       breaking historical applications.

       The use of a leading circumflex in the BRE  is  unspeci-
       fied   because   many  historical  implementations  have
       treated it as a special character, despite their  system
       documentation. For example:


              expr foo : ^foo     expr ^foo : ^foo

       return  3  and  0, respectively, on those systems; their
       documentation would imply the reverse. Thus, the anchor-
       ing condition is left unspecified to avoid breaking his-
       torical scripts relying on this undocumented feature.

FUTURE DIRECTIONS
       None.

SEE ALSO
       Parameters and Variables , Arithmetic Expansion

COPYRIGHT
       Portions of this text are reprinted  and  reproduced  in
       electronic  form  from  IEEE  Std  1003.1, 2003 Edition,
       Standard for Information Technology -- Portable  Operat-
       ing System Interface (POSIX), The Open Group Base Speci-
       fications Issue 6, Copyright (C) 2001-2003 by the Insti-
       tute  of  Electrical  and Electronics Engineers, Inc and
       The Open Group. In the event of any discrepancy  between
       this  version  and  the original IEEE and The Open Group
       Standard, the original IEEE and The Open Group  Standard
       is  the  referee  document. The original Standard can be
       obtained        online        at        http://www.open-
       group.org/unix/online.html .



POSIX                         2003                      expr(P)