Home Man
Today's Posts

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

Linux 2.6 - man page for expr (linux section 1posix)

EXPR(P) 			    POSIX Programmer's Manual				  EXPR(P)

       expr - evaluate arguments as an expression

       expr operand

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


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

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

       and  the  symbols  integer  and	string in the table are provided as separate arguments to

       Not used.


       The following environment variables shall affect the execution of expr:

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

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


	      Determine the locale for the behavior of ranges, equivalence  classes,  and  multi-
	      character  collating elements within regular expressions and by the string compari-
	      son operators.

	      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 argu-
	      ments) and the behavior of character classes within regular expressions.

	      Determine the locale that should be used to affect the format and contents of diag-
	      nostic messages written to standard error.

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


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

       The standard error shall be used only for diagnostic messages.


       The formation of the expression to be evaluated is shown in the following table. The  sym-
       bols  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  constructs	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 nei-
					ther expression evaluates to null or
					zero; otherwise, returns zero.
					Returns the result of a decimal integer
					comparison if both arguments are inte-
					gers; otherwise, returns the result of a
					string comparison using the locale-spe-
					cific collation sequence. The result of
					each comparison is 1 if the specified
					relationship is true, or 0 if the rela-
					tionship 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 argu-
		       expr1 - expr2	Subtraction of decimal integer-valued
		       expr1 * expr2	Multiplication of decimal integer-valued
		       expr1 / expr2	Integer division of decimal integer-val-
					ued arguments, producing an integer
		       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
		       integer		An argument consisting only of an
					(optional) unary minus followed by dig-
		       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 unspec-
       ified whether '^' is a special character in that context. Usually, the  matching  operator
       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 identified 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.

       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.


       The following sections are informative.

       After argument processing by the shell, expr is not required to be able to tell	the  dif-
       ference	between an operator and an operand except by the value. If "$a" is '=' , the com-

	      expr $a = '='

       looks like:

	      expr = = =

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

	      expr X$a = X=

       Also note that this volume of IEEE Std 1003.1-2001 permits implementations to extend util-
       ities. The expr utility 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
       application 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).

       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 separate  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 provided 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 characters 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.

       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 unspecified because many historical imple-
       mentations have treated it as a special character, despite their system documentation. For

	      expr foo : ^foo	  expr ^foo : ^foo

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


       Parameters and Variables , Arithmetic Expansion

       Portions  of  this  text  are  reprinted  and  reproduced in electronic form from IEEE Std
       1003.1, 2003 Edition, Standard for Information Technology  --  Portable	Operating  System
       Interface  (POSIX), The Open Group Base Specifications Issue 6, Copyright (C) 2001-2003 by
       the Institute 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 orig-
       inal Standard can be obtained online at http://www.opengroup.org/unix/online.html .

IEEE/The Open Group			       2003					  EXPR(P)

All times are GMT -4. The time now is 08:50 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
Show Password