— Scheme Procedure: string-match pattern str [start]

Compile the string pattern into a regular expression and compare it with str. The optional numeric argument start specifies the position of str at which to begin matching.

string-match returns a match structure which describes what, if anything, was matched by the regular expression. See Match Structures. If str does not match pattern at all, string-match returns #f.

— Scheme Procedure: make-regexp pat [flags ...]
— C Function: scm_make_regexp (pat, flags) |1 |0 |1

Compile the regular expression described by pat, and return the compiled regexp structure. If pat does not describe a legal regular expression, throw a regular-expression-syntax error.

The flags change the behavior of the compiled regexp. The following flags may be supplied:

regexp/icase

Consider uppercase and lowercase letters to be the same when matching.

regexp/newline

If a newline appears in the target string, then permit the ‘^’ and ‘$’ operators to match immediately after or immediately before the newline, respectively. Also, the ‘.’ and ‘[^...]’ operators will never match a newline character. The intent of this flag is to treat the target string as a buffer containing many lines of text, and the regular expression as a pattern that may match a single one of those lines.

regexp/basic

Compile a basic (“obsolete”) regexp instead of the extended (“modern”) regexps that are the default. Basic regexps do not consider ‘|’, ‘+’ or ‘?’ to be special characters, and require the ‘{...}’ and ‘(...)’ metacharacters to be backslash-escaped (see Backslash Escapes). There are several other differences between basic and extended regular expressions, but these are the most significant.

regexp/extended

Compile an extended regular expression rather than a basic regexp. This is the default behavior; this flag will not usually be needed. If a call to make-regexp includes both regexp/basic and regexp/extended flags, the one which comes last will override the earlier one.

— Scheme Procedure: regexp-exec rx str [start [flags]]
— C Function: scm_regexp_exec (rx, str, start, flags) |2 |2 |0

Match the compiled regular expression rx against str. If the optional integer argument start is provided, begin matching from that position in the string. Return a match structure describing the results of the match, or #f if no match could be found. Optional integer argument flags changes the behavior of the matching, similar to make-regexp.

— Scheme Procedure: regexp? x
— C Function: scm_regexp_p (x)

Return #t if obj is a compiled regular expression, or #f otherwise.

— Scheme Procedure: regexp-substitute port match [items...]

Write to the output port port selected contents of the match structure match. Each item specifies what should be written, and may be one of the following arguments:

• A string. String arguments are written out verbatim.
• An integer. The submatch with that number is written.
• The symbol ‘pre’. The portion of the matched string preceding the regexp match is written.
• The symbol ‘post’. The portion of the matched string following the regexp match is written.

port may be #f, in which case nothing is written; instead, regexp-substitute constructs a string from the specified items and returns that.

     (define date-regex "([0-9][0-9][0-9][0-9])([0-9][0-9])([0-9][0-9])")
     (define s "Date 20020429 12am.")
     (define sm (string-match date-regex s))
     
     (regexp-substitute #f sm 'pre 2 "-" 3 "-" 1 'post " (" 0 ")")
     ⇒ "Date 04-29-2002 12am. (20020429)"

— Scheme Procedure: regexp-substitute/global port regexp string [items...]

Similar to regexp-substitute, but can be used to perform global substitutions on str. Instead of taking a match structure as an argument, regexp-substitute/global takes two string arguments: a regexp string describing a regular expression, and a target string which should be matched against this regular expression.

Each item behaves as in regexp-substitute, with the following exceptions:

• A function may be supplied. When this function is called, it will be passed one argument: a match structure for a given regular expression match. It should return a string to be written out to port.
• The ‘post’ symbol causes regexp-substitute/global to recurse on the unmatched portion of str. This must be supplied in order to perform global search-and-replace on str; if it is not present among the items, then regexp-substitute/global will return after processing a single match.