Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (OSF1-V5.1-alpha)
Apropos / Subsearch:
optional field

expr(1)								      expr(1)


  expr - Evaluates arguments as	expressions


  expr expression


  Interfaces documented	on this	reference page conform to industry standards
  as follows:

  expr:	 XCU5.0

  Refer	to the standards(5) reference page for more information	about indus-
  try standards	and associated tags.




  The single expression	evaluated by expr will be formed from the operands,
  as described in the DESCRIPTION section.  Each of the	expression operator
  symbols: (   )   |   &&amp;   = >&gt; >&gt;=   <&lt;	<&lt;=   !=	  +   -	  *   /	  %   :	and
  the symbols integer and string in the	DESCRIPTION section must be provided
  as separate arguments	to expr.

      Expression to be evaluated, formed as explained in the DESCRIPTION sec-


  The expr command reads an expression,	evaluates it, and writes the result
  to standard output.  Within the expression argument, you must	separate each
  term with spaces, precede characters special to the shell with a \
  (backslash), and quote strings containing spaces or other special charac-
  ters.	 Note that expr	returns	0 to indicate a	zero value, rather than	the
  null string.	Integers can be	preceded by a unary minus sign.	 Internally,
  integers are treated as 64-bit or 32-bit two's complement numbers, depend-
  ing on the word size of the hardware platform.

  The operators	and keywords are described in the following listing.  Charac-
  ters that need to be escaped are preceded by a \ (backslash).	 The list is
  in order of increasing precedence with equal precedence operators grouped
  within {} (braces).

  expression1 \| expression2
      Returns expression1 if it	is neither null	nor 0 (zero); otherwise,
      returns expression2.

  expression1 \&&amp; expression2
      Returns expression1 if neither expression1 nor expression2 is null nor
      0; otherwise, returns 0.

  expression1 {	 =,  \>&gt;,  \>&gt;=,	\<&lt;, \<&lt;=,  !=  }	expression2
      Returns the result of an integer comparison if both expressions are
      integers;	otherwise, returns the result of a string comparison.

  expression1 {+,  - } expression2
      Adds or subtracts	integer-valued arguments.

  expression1 {	 \*,  /,  %  } expression2
      Multiplies, divides, or provides the remainder from the division of
      integer-valued arguments.

  expression1 :	expression2 or match expression1 expression2
      Compares expression1 with	expression2, which must	be a basic regular
      expression, with syntax as described for grep, except that all patterns
      are anchored, so ^ (circumflex) (which anchors a pattern to the begin-
      ning of a	line) is not a special character in this context.

      Normally,	the matching operator returns the number of characters
      matched.	Alternatively, you can use the \(...\) symbols in expression2
      to return	a portion of expression1.

      Provides expression grouping.

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

      A	string argument.  Refer	to the STRING OPERAND section.

  To avoid unpredictable results when using a range expression to match	a
  class	of characters, use a character class expression	rather than a stan-
  dard range expression.  For information about	character class	expressions,
  see the discussion of	this topic included in the description of the grep


  [Tru64 UNIX]	The expr command provides the following	string-expression
  functions.  Strings containing white space must be quoted.  A	string argu-
  ment should not be one of the	expression operator symbols shown in the
  OPERANDS section or one of the string	function names below. You cannot use,
  for example, match "$subject"	"$pattern" unless it is	confirmed that sub-
  ject and pattern do not match	this violation.	The first character of a
  string is position 1.	 The information returned by all these functions is
  in the form of a string:

  index	string1	string2
      [Tru64 UNIX]  Compares each character in the second string against each
      character	in the first string and	returns	the position in	the first
      string of	the first match	found, where the first match is	the match
      closest to the beginning of string1.

  length string
      [Tru64 UNIX]  Returns the	length of the string argument.

  match	string1	string2
      [Tru64 UNIX]  See	the description	of the : (colon) match operator,

  substr string	start length
      [Tru64 UNIX]  Returns the	substring of string that begins	at character
      position start and is length characters long.


  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

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


  The expr command returns the following exit values:

  0   The expression is	neither	null nor 0.

  1   The expression is	null or	0.

  2   The expression is	invalid.

  >&gt;2  An error occurred.


   1.  To increment a shell variable, enter:
	    COUNT=`expr	$COUNT + 1`

       This adds 1 to the COUNT	shell variable (see sh for details).

   2.  To find the length of a shell variable, enter:
	    RES=`expr "$VAR" : ".*"`

       Note that VAR is	in double quotes to avoid problems where VAR is	NULL
       or contains embedded spaces.  The regular expression is also quoted to
       avoid expansion by the shell. This operation can	also be	performed as:
	    RES=`expr length "$VAR"`

   3.  To use part of a	shell variable,	enter:
	    RES=`expr "$VAR" : "-*\(.*\)"`

       This removes leading - (dashes),	if any,	from VAR. If the \( \) char-
       acters were omitted, RES	would contain the length of VAR.

   4.  To find a character from	one string in another string, enter:
	    INDEX=`expr	index "Hello World!" "Wo"`

       Note that the returned value is 5, not 7.  The first match is the
       fifth character in string1, matching the	o in string2 rather than the
       W, which	is the seventh character in string1.

   5.  Special considerations:
	    RES=`expr "x$VAR" :	"x-*\(.*\)"`

       This succeeds even if VAR has the value - (dash).
	    RES=`expr "x$VAR" =	"x="

       This succeeds even if VAR has the value = (equal	sign).

   6.  When CMD_ENV variable is	set to bsd:
	    RES=`expr 0001'

       This results in 0001. Otherwise the value is 1.
	    RES=`expr substr 012345 1 3'

       This results in 012. Otherwise the value	is 12.


  The following	environment variables affect the execution of expr:

      [Tru64 UNIX]  This variable, if set to bsd, prevents stripping of	lead-
      ing zeroes from expressions.

      Provides a default value for the internationalization variables that
      are unset	or null. If LANG is unset or null, the corresponding value
      from the default locale is used. If any of the internationalization
      variables	contain	an invalid setting, the	utility	behaves	as if none of
      the variables had	been defined.

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

      Determines 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 in
      regular expressions..

      Determines the locale for	the format and contents	of diagnostic mes-
      sages written to standard	error.

      Determines the location of message catalogues for	the processing of


  Commands:  grep(1), Bourne shell sh(1b), POSIX shell sh(1p), test(1)

  Functions:  string(3), wcscat(3)

  Standards:  standards(5)