Unix/Linux Go Back    


Linux 2.6 - man page for regexp (linux section 3erl)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


regexp(3erl)			     Erlang Module Definition			     regexp(3erl)

NAME
       regexp - Regular Expression Functions for Strings

DESCRIPTION
   Note:
       This module has been obsoleted by the re module and will be removed in a future release.

       This module contains functions for regular expression matching and substitution.

EXPORTS
       match(String, RegExp) -> MatchRes

	      Types  String = RegExp = string()
		     MatchRes = {match,Start,Length} | nomatch | {error,errordesc()}
		     Start = Length = integer()

	      Finds  the  first,  longest match of the regular expression RegExp in String . This
	      function searches for the longest possible match and returns the first one found if
	      there are several expressions of the same length. It returns as follows:

		{match,Start,Length} :
		  if the match succeeded. Start is the starting position of the match, and Length
		  is the length of the matching string.

		nomatch :
		  if there were no matching characters.

		{error,Error} :
		  if there was an error in RegExp .

       first_match(String, RegExp) -> MatchRes

	      Types  String = RegExp = string()
		     MatchRes = {match,Start,Length} | nomatch | {error,errordesc()}
		     Start = Length = integer()

	      Finds the first match of the regular expression RegExp in String	.  This  call  is
	      usually  faster  than  match  and it is also a useful way to ascertain that a match
	      exists. It returns as follows:

		{match,Start,Length} :
		  if the match succeeded. Start is the starting position of the match and  Length
		  is the length of the matching string.

		nomatch :
		  if there were no matching characters.

		{error,Error} :
		  if there was an error in RegExp .

       matches(String, RegExp) -> MatchRes

	      Types  String = RegExp = string()
		     MatchRes = {match, Matches} | {error, errordesc()}
		     Matches = list()

	      Finds  all  non-overlapping matches of the expression RegExp in String . It returns
	      as follows:

		{match, Matches} :
		  if the regular expression was correct. The list will be empty if there  was  no
		  match. Each element in the list looks like {Start, Length} , where Start is the
		  starting position of the match, and  Length  is  the	length	of  the  matching
		  string.

		{error,Error} :
		  if there was an error in RegExp .

       sub(String, RegExp, New) -> SubRes

	      Types  String = RegExp = New = string()
		     SubRes = {ok,NewString,RepCount} | {error,errordesc()}
		     RepCount = integer()

	      Substitutes  the first occurrence of a substring matching RegExp in String with the
	      string New . A & in the string New is replaced by the matched substring of String .
	      \& puts a literal & into the replacement string. It returns as follows:

		{ok,NewString,RepCount} :
		  if  RegExp  is  correct. RepCount is the number of replacements which have been
		  made (this will be either 0 or 1).

		{error, Error} :
		  if there is an error in RegExp .

       gsub(String, RegExp, New) -> SubRes

	      Types  String = RegExp = New = string()
		     SubRes = {ok,NewString,RepCount} | {error,errordesc()}
		     RepCount = integer()

	      The same as sub , except that all non-overlapping occurrences of a substring match-
	      ing RegExp in String are replaced by the string New . It returns:

		{ok,NewString,RepCount} :
		  if  RegExp  is  correct. RepCount is the number of replacements which have been
		  made.

		{error, Error} :
		  if there is an error in RegExp .

       split(String, RegExp) -> SplitRes

	      Types  String = RegExp = string()
		     SubRes = {ok,FieldList} | {error,errordesc()}
		     Fieldlist = [string()]

	      String is split into fields (sub-strings) by the regular expression RegExp .

	      If the separator expression is " " (a single space), then the fields are	separated
	      by  blanks  and/or tabs and leading and trailing blanks and tabs are discarded. For
	      all other values of the separator, leading and trailing blanks  and  tabs  are  not
	      discarded. It returns:

		{ok, FieldList} :
		  to indicate that the string has been split up into the fields of FieldList .

		{error, Error} :
		  if there is an error in RegExp .

       sh_to_awk(ShRegExp) -> AwkRegExp

	      Types  ShRegExp AwkRegExp = string()
		     SubRes = {ok,NewString,RepCount} | {error,errordesc()}
		     RepCount = integer()

	      Converts	the  sh  type regular expression ShRegExp into a full AWK regular expres-
	      sion. Returns the converted regular expression string. sh expressions are  used  in
	      the shell for matching file names and have the following special characters:

		* :
		  matches any string including the null string.

		? :
		  matches any single character.

		[...] :
		  matches  any	of  the  enclosed characters. Character ranges are specified by a
		  pair of characters separated by a - . If the first character after [ is a  !	,
		  then any character not enclosed is matched.

	      It  may  sometimes  be more practical to use sh type expansions as they are simpler
	      and easier to use, even though they are not as powerful.

       parse(RegExp) -> ParseRes

	      Types  RegExp = string()
		     ParseRes = {ok,RE} | {error,errordesc()}

	      Parses the regular expression RegExp and builds the internal representation used in
	      the  other regular expression functions. Such representations can be used in all of
	      the other functions instead of a regular expression string. This is more	efficient
	      when the same regular expression is used in many strings. It returns:

		{ok, RE} if RegExp is correct and RE is the internal representation. :

		{error, Error} if there is an error in RegExpString . :

       format_error(ErrorDescriptor) -> Chars

	      Types  ErrorDescriptor = errordesc()
		     Chars = [char() | Chars]

	      Returns  a  string which describes the error ErrorDescriptor returned when there is
	      an error in a regular expression.

REGULAR EXPRESSIONS
       The regular expressions allowed here is a subset of the set found in egrep and in the  AWK
       programming  language, as defined in the book, The AWK Programming Language, by A. V. Aho,
       B. W. Kernighan, P. J. Weinberger . They are composed of the following characters:

	 c :
	   matches the non-metacharacter c .

	 \c :
	   matches the escape sequence or literal character c .

	 . :
	   matches any character.

	 ^ :
	   matches the beginning of a string.

	 $ :
	   matches the end of a string.

	 [abc...] :
	   character class, which matches any of the characters abc... Character ranges are spec-
	   ified by a pair of characters separated by a - .

	 [^abc...] :
	   negated character class, which matches any character except abc... .

	 r1 | r2 :
	   alternation. It matches either r1 or r2 .

	 r1r2 :
	   concatenation. It matches r1 and then r2 .

	 r+ :
	   matches one or more r s.

	 r* :
	   matches zero or more r s.

	 r? :
	   matches zero or one r s.

	 (r) :
	   grouping. It matches r .

       The escape sequences allowed are the same as for Erlang strings:

	 \b :
	   backspace

	 \f :
	   form feed

	 \n :
	   newline (line feed)

	 \r :
	   carriage return

	 \t :
	   tab

	 \e :
	   escape

	 \v :
	   vertical tab

	 \s :
	   space

	 \d :
	   delete

	 \ddd :
	   the octal value ddd

	 \xhh :
	   The hexadecimal value hh .

	 \x{h...} :
	   The hexadecimal value h... .

	 \c :
	   any other character literally, for example \\ for backslash, \" for ")

       To  make these functions easier to use, in combination with the function io:get_line which
       terminates the input line with a new line, the $ characters also matches a  string  ending
       with "...\n" . The following examples define Erlang data types:

       Atoms	 [a-z][0-9a-zA-Z_]*

       Variables [A-Z_][0-9a-zA-Z_]*

       Floats	 (\+|-)?[0-9]+\.[0-9]+((E|e)(\+|-)?[0-9]+)?

       Regular	expressions  are  written  as Erlang strings when used with the functions in this
       module. This means that any \ or " characters in a regular expression string must be writ-
       ten  with  \  as  they are also escape characters for the string. For example, the regular
       expression string for Erlang floats is: "(\\+|-)?[0-9]+\\.[0-9]+((E|e)(\\+|-)?[0-9]+)?" .

       It is not really necessary to have the escape sequences as part of the regular  expression
       syntax  as they can always be generated directly in the string. They are included for com-
       pleteness and can they can also be useful when generating  regular  expressions,  or  when
       they are entered other than with Erlang strings.

Ericsson AB				  stdlib 1.17.3 			     regexp(3erl)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 01:32 PM.