Module Re

module Re: sig .. end
Module Re: regular expressions commons

type t 
Regular expression
type re 
Compiled regular expression
type substrings 
Match informations

Compilation and execution of a regular expression


val compile : t -> re
Compile a regular expression into an executable version that can be used to match strings, e.g. with Re.exec.
val exec : ?pos:int -> ?len:int -> re -> string -> substrings
exec re str matches str against the compiled expression re, and returns the matched groups if any.
Raises Not_found if the regular expression can't be found in str
pos : optional beginning of the string (default 0)
len : length of the substring of str that can be matched (default -1, meaning to the end of the string
val execp : ?pos:int -> ?len:int -> re -> string -> bool
Similar to Re.exec, but returns true if the expression matches, and false if it doesn't
val exec_partial : ?pos:int -> ?len:int -> re -> string -> [ `Full | `Mismatch | `Partial ]

Substring extraction


val get : substrings -> int -> string
Raise Not_found if the group did not match
val get_ofs : substrings -> int -> int * int
Raise Not_found if the group did not match
val get_all : substrings -> string array
Return the empty string for each group which did not match
val get_all_ofs : substrings -> (int * int) array
Return (-1,-1) for each group which did not match
val test : substrings -> int -> bool
Test whether a group matched

Marks


type markid 
Mark id
module MarkSet: Set.S  with type elt = markid
val marked : substrings -> markid -> bool
Tell if a mark was matched.
val mark_set : substrings -> MarkSet.t

High Level Operations


type 'a gen = unit -> 'a option 
val all : ?pos:int -> ?len:int -> re -> string -> substrings list
Repeatedly calls Re.exec on the given string, starting at given position and length.
val all_gen : ?pos:int -> ?len:int -> re -> string -> substrings gen
Same as Re.all but returns a generator
val matches : ?pos:int -> ?len:int -> re -> string -> string list
Same as Re.all, but extracts the matched substring rather than returning the whole group. This basically iterates over matched strings
val matches_gen : ?pos:int -> ?len:int -> re -> string -> string gen
Same as Re.matches, but returns a generator.
val split : ?pos:int -> ?len:int -> re -> string -> string list
split re s splits s into chunks separated by re. It yields the chunks themselves, not the separator. For instance this can be used with a whitespace-matching re such as "[\t ]+".
val split_gen : ?pos:int -> ?len:int -> re -> string -> string gen
type split_token = [ `Delim of substrings | `Text of string ] 
val split_full : ?pos:int -> ?len:int -> re -> string -> split_token list
val split_full_gen : ?pos:int -> ?len:int -> re -> string -> split_token gen
val replace : ?pos:int ->
?len:int ->
?all:bool -> re -> f:(substrings -> string) -> string -> string
replace ~all re ~f s iterates on s, and replaces every occurrence of re with f substring where substring is the current match. If all = false, then only the first occurrence of re is replaced.
val replace_string : ?pos:int -> ?len:int -> ?all:bool -> re -> by:string -> string -> string
replace_string ~all re ~by s iterates on s, and replaces every occurrence of re with by. If all = false, then only the first occurrence of re is replaced.

String expressions (literal match)


val str : string -> t
val char : char -> t

Basic operations on regular expressions


val alt : t list -> t
Alternative
val seq : t list -> t
Sequence
val empty : t
Match nothing
val epsilon : t
Empty word
val rep : t -> t
0 or more matches
val rep1 : t -> t
1 or more matches
val repn : t -> int -> int option -> t
Repeated matches
val opt : t -> t
0 or 1 matches

String, line, word


val bol : t
Beginning of line
val eol : t
End of line
val bow : t
Beginning of word
val eow : t
End of word
val bos : t
Beginning of string
val eos : t
End of string
val leol : t
Last end of line or end of string
val start : t
Initial position
val stop : t
Final position
val word : t -> t
Word
val not_boundary : t
Not at a word boundary
val whole_string : t -> t
Only matches the whole string

Match semantics


val longest : t -> t
Longest match
val shortest : t -> t
Shortest match
val first : t -> t
First match

Repeated match modifiers


val greedy : t -> t
Greedy
val non_greedy : t -> t
Non-greedy

Groups (or submatches)


val group : t -> t
Delimit a group
val no_group : t -> t
Remove all groups
val nest : t -> t
when matching against nest e, only the group matching in the last match of e will be considered as matching
val mark : t -> markid * t
Mark a regexp. the markid can then be used to know if this regexp was used.

Character sets


val set : string -> t
Any character of the string
val rg : char -> char -> t
Character ranges
val inter : t list -> t
Intersection of character sets
val diff : t -> t -> t
Difference of character sets
val compl : t list -> t
Complement of union

Predefined character sets


val any : t
Any character
val notnl : t
Any character but a newline
val alnum : t
val wordc : t
val alpha : t
val ascii : t
val blank : t
val cntrl : t
val digit : t
val graph : t
val lower : t
val print : t
val punct : t
val space : t
val upper : t
val xdigit : t

Case modifiers


val case : t -> t
Case sensitive matching
val no_case : t -> t
Case insensitive matching

Internal debugging


val print_re : Format.formatter -> re -> unit