module Netstring_str:sig
..end
Str
syntax
This module was written at a time when we had only the Str
module
for regular expressions. However, Str
has an interface that does
not work for multi-threaded programs, because the state of the module
is visible to the outside. The module Netstring_str
is similar to Str
,
but has a thread-compatible interface.
Now we have the much better PCRE library for regular expressions.
This implementation of Netstring_str
bases on the PCRE engine but retains
the old interface as much as possible. This includes that the regexp
function parses old-style regular expressions and internally translates
them to PCRE-style expressions.
See also Netstring_pcre
. The difference is that Netstring_pcre
expects
already PCRE-style regular expressions and does not translate them.
. matches every character but newline
e* matches e several times
e+ matches e several times but at least once
e? matches e optionally
e{m,n} matches e at least m times and at most n times
e1\|e2 matches e1 or e2
[set] matches the characters from set
[^set] matches the characters except from set
\(...\) group paranthesis
\n back reference (n is digit)
^ matches at beginning of line
$ matches at end of line
This is exactly what Str
supports. Character classes
are not implemented.
type
regexp
typesplit_result =
Str.split_result
=
| |
Text of |
|||
| |
Delim of |
(* | Here we keep compatibility with Str | *) |
type
result
val regexp : string -> regexp
val regexp_case_fold : string -> regexp
val quote : string -> string
val regexp_string : string -> regexp
val regexp_string_case_fold : string -> regexp
val quote_set : string -> string
val string_match : regexp -> string -> int -> result option
None
if no match is found. Returns Some r
on success,
and r
describes the match.val search_forward : regexp -> string -> int -> int * result
Not_found
if no match could be found.
Returns (p,r)
when a match at position p
is found,
described by r
.val search_backward : regexp -> string -> int -> int * result
Not_found
if no match could be found.
Returns (p,r)
when a match at position p
is found,
described by r
.val matched_string : result -> string -> string
string_match
or the search
functions, and the result argument must be the corresponding
result.val match_beginning : result -> int
val match_end : result -> int
val matched_group : result -> int -> string -> string
string_match
or the search
functions, and the result argument must be the corresponding
result.val group_beginning : result -> int -> int
val group_end : result -> int -> int
val global_replace : regexp -> string -> string -> string
global_replace re templ s
: Replaces all matchings of re
in
s
by templ
.
In templ
one can refer to matched groups by the backslash notation:
\1
refers to the first group, \2
to the second etc.
\0
is the whole match. \\
is the backslash character.
val replace_first : regexp -> string -> string -> string
replace_first re templ s
: Replaces the first match of re
in
s
by templ
.
In templ
one can refer to matched groups by the backslash notation:
\1
refers to the first group, \2
to the second etc.
\0
is the whole match. \\
is the backslash character.
val global_substitute : regexp ->
(result -> string -> string) -> string -> string
global_substitute re subst s
: Applies the substitution function
subst
to all matchings of re
in s
, and returns the
transformed string. subst
is called with the current result
of the match and the whole string s
.val substitute_first : regexp ->
(result -> string -> string) -> string -> string
substitute_first re subst s
: Applies the substitution function
subst
to the first matching of re
in s
, and returns the
transformed string. subst
is called with the current result
of the match and the whole string s
.val split : regexp -> string -> string list
val bounded_split : regexp -> string -> int -> string list
n
substrings, based on split
val split_delim : regexp -> string -> string list
split
, but occurrences of the delimiter at the beginning
and the end are returned as empty stringsval bounded_split_delim : regexp -> string -> int -> string list
n
substrings, based on split_delim
val full_split : regexp -> string -> split_result list
split_delim
, but returns the delimiters in the resultval bounded_full_split : regexp -> string -> int -> split_result list
n
substrings, based on full_split
val string_before : string -> int -> string
n
characters of a stringval string_after : string -> int -> string
n
characters of a stringval first_chars : string -> int -> string
string_before
val last_chars : string -> int -> string
string_after
module Debug:sig
..end