The cl-ppcre Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The cl-ppcre Reference Manual

This is the cl-ppcre Reference Manual, version 2.1.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 04:04:35 2022 GMT+0.

Table of Contents


1 Introduction

CL-PPCRE - Portable Perl-compatible regular expressions for Common Lisp

Abstract

CL-PPCRE is a portable regular expression library for Common Lisp which has the following features:

CL-PPCRE has been used successfully in various applications like BioBike, clutu, LoGS, CafeSpot, Eboy, or The Regex Coach.

Further documentation can be found in docs/index.html, or on the cl-ppcre homepage.


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 cl-ppcre

Perl-compatible regular expression library

Author

Dr. Edi Weitz

License

BSD

Version

2.1.1

Source

cl-ppcre.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.1 cl-ppcre/cl-ppcre.asd

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

ASDF Systems

cl-ppcre.


3.1.2 cl-ppcre/packages.lisp

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Packages

cl-ppcre.


3.1.3 cl-ppcre/specials.lisp

Dependency

packages.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Public Interface
Internals

3.1.4 cl-ppcre/util.lisp

Dependency

specials.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Internals

3.1.5 cl-ppcre/errors.lisp

Dependency

util.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Public Interface
Internals

3.1.6 cl-ppcre/charset.lisp

Dependency

errors.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Public Interface

make-load-form (method).

Internals

3.1.7 cl-ppcre/charmap.lisp

Dependency

charset.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Public Interface

make-load-form (method).

Internals

3.1.8 cl-ppcre/chartest.lisp

Dependency

charmap.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Public Interface

create-optimized-test-function (function).

Internals

create-hash-table-from-test-function (function).


3.1.9 cl-ppcre/lexer.lisp

Dependency

chartest.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Internals

3.1.10 cl-ppcre/parser.lisp

Dependency

lexer.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Public Interface

parse-string (function).

Internals

3.1.11 cl-ppcre/regex-class.lisp

Dependency

parser.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Public Interface
Internals

3.1.12 cl-ppcre/regex-class-util.lisp

Dependency

regex-class.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Internals

3.1.13 cl-ppcre/convert.lisp

Dependency

regex-class-util.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Internals

3.1.14 cl-ppcre/optimize.lisp

Dependency

convert.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Internals

3.1.15 cl-ppcre/closures.lisp

Dependency

optimize.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Internals

3.1.16 cl-ppcre/repetition-closures.lisp

Dependency

closures.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Internals

3.1.17 cl-ppcre/scanner.lisp

Dependency

repetition-closures.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Internals

Previous: , Up: Lisp   [Contents][Index]

3.1.18 cl-ppcre/api.lisp

Dependency

scanner.lisp (file).

Source

cl-ppcre.asd.

Parent Component

cl-ppcre (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 cl-ppcre

Source

packages.lisp.

Nickname

ppcre

Use List

common-lisp.

Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.1 Special variables

Special Variable: *allow-named-registers*

Whether the parser should support AllegroCL’s named registers (?<name>"<regex>") and back-reference \k<name> syntax.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *allow-quoting*

Whether the parser should support Perl’s \Q and \E.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *look-ahead-for-suffix*

Controls whether scanners will optimistically look ahead for a constant suffix of a regular expression, if there is one.

Package

cl-ppcre.

Source

api.lisp.

Special Variable: *optimize-char-classes*

Whether character classes should be compiled into look-ups into O(1) data structures. This is usually fast but will be costly in terms of scanner creation time and might be costly in terms of size if *REGEX-CHAR-CODE-LIMIT* is high. This value will be used as the :KIND keyword argument to CREATE-OPTIMIZED-TEST-FUNCTION - see there for the possible non-NIL values.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *property-resolver*

Should be NIL or a designator for a function which accepts strings and returns unary character test functions or NIL. This ’resolver’ is intended to handle ‘character properties’ like \p{IsAlpha}. If *PROPERTY-RESOLVER* is NIL, then the parser will simply treat \p and \P as #\p and #\P as in older versions of CL-PPCRE.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *regex-char-code-limit*

The upper exclusive bound on the char-codes of characters which can occur in character classes. Change this value BEFORE creating scanners if you don’t need the (full) Unicode support of implementations like AllegroCL, CLISP, LispWorks, or SBCL.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *use-bmh-matchers*

Whether the scanners created by CREATE-SCANNER should use the (fast but large) Boyer-Moore-Horspool matchers.

Package

cl-ppcre.

Source

specials.lisp.


5.1.2 Macros

Macro: define-parse-tree-synonym (name parse-tree)

Defines the symbol NAME to be a synonym for the parse tree PARSE-TREE. Both arguments are quoted.

Package

cl-ppcre.

Source

api.lisp.

Macro: do-matches ((match-start match-end regex target-string &optional result-form &key start end) &body body)

Iterates over TARGET-STRING and tries to match REGEX as often as possible evaluating BODY with MATCH-START and MATCH-END bound to the start/end positions of each match in turn. After the last match, returns RESULT-FORM if provided or NIL otherwise. An implicit block named NIL surrounds DO-MATCHES; RETURN may be used to terminate the loop immediately. If REGEX matches an empty string the scan is continued one position behind this match. BODY may start with declarations.

Package

cl-ppcre.

Source

api.lisp.

Macro: do-matches-as-strings ((match-var regex target-string &optional result-form &key start end sharedp) &body body)

Iterates over TARGET-STRING and tries to match REGEX as often as possible evaluating BODY with MATCH-VAR bound to the substring of TARGET-STRING corresponding to each match in turn. After the last match, returns RESULT-FORM if provided or NIL otherwise. An implicit block named NIL surrounds DO-MATCHES-AS-STRINGS; RETURN may be used to terminate the loop immediately. If REGEX matches an empty string the scan is continued one position behind this match. If SHAREDP is true, the substrings may share structure with TARGET-STRING. BODY may start with declarations.

Package

cl-ppcre.

Source

api.lisp.

Macro: do-register-groups (var-list (regex target-string &optional result-form &key start end sharedp) &body body)

Iterates over TARGET-STRING and tries to match REGEX as often as possible evaluating BODY with the variables in VAR-LIST bound to the corresponding register groups for each match in turn, i.e. each variable is either bound to a string or to NIL. For each element of VAR-LIST which is NIL there’s no binding to the corresponding register group. The number of variables in VAR-LIST must not be greater than the number of register groups. After the last match, returns RESULT-FORM if provided or NIL otherwise. An implicit block named NIL surrounds DO-REGISTER-GROUPS; RETURN may be used to terminate the loop immediately. If REGEX matches an empty string the scan is continued one position behind this match. If SHAREDP is true, the substrings may share structure with TARGET-STRING. BODY may start with declarations.

Package

cl-ppcre.

Source

api.lisp.

Macro: do-scans ((match-start match-end reg-starts reg-ends regex target-string &optional result-form &key start end) &body body)

Iterates over TARGET-STRING and tries to match REGEX as often as possible evaluating BODY with MATCH-START, MATCH-END, REG-STARTS, and REG-ENDS bound to the four return values of each match in turn. After the last match, returns RESULT-FORM if provided or NIL otherwise. An implicit block named NIL surrounds DO-SCANS; RETURN may be used to terminate the loop immediately. If REGEX matches an empty string the scan is continued one position behind this match. BODY may start with declarations.

Package

cl-ppcre.

Source

api.lisp.

Macro: register-groups-bind (var-list (regex target-string &key start end sharedp) &body body)

Executes BODY with the variables in VAR-LIST bound to the corresponding register groups after TARGET-STRING has been matched against REGEX, i.e. each variable is either bound to a string or to NIL. If there is no match, BODY is _not_ executed. For each element of VAR-LIST which is NIL there’s no binding to the corresponding register group. The number of variables in VAR-LIST must not be greater than the number of register groups. If SHAREDP is true, the substrings may share structure with TARGET-STRING.

Package

cl-ppcre.

Source

api.lisp.


5.1.3 Compiler macros

Compiler Macro: all-matches (regex &rest rest)

Make sure that constant forms are compiled into scanners at compile time.

Package

cl-ppcre.

Source

api.lisp.

Compiler Macro: all-matches-as-strings (regex &rest rest)

Make sure that constant forms are compiled into scanners at compile time.

Package

cl-ppcre.

Source

api.lisp.

Compiler Macro: count-matches (regex &rest rest)

Make sure that constant forms are compiled into scanners at compile time.

Package

cl-ppcre.

Source

api.lisp.

Compiler Macro: regex-replace (regex target-string replacement &rest rest)

Make sure that constant forms are compiled into scanners at compile time.

Package

cl-ppcre.

Source

api.lisp.

Compiler Macro: regex-replace-all (regex target-string replacement &rest rest)

Make sure that constant forms are compiled into scanners at compile time.

Package

cl-ppcre.

Source

api.lisp.

Compiler Macro: scan (regex target-string &rest rest)

Make sure that constant forms are compiled into scanners at compile time.

Package

cl-ppcre.

Source

api.lisp.

Compiler Macro: scan-to-strings (regex target-string &rest rest)

Make sure that constant forms are compiled into scanners at compile time.

Package

cl-ppcre.

Source

api.lisp.

Compiler Macro: split (regex target-string &rest rest)

Make sure that constant forms are compiled into scanners at compile time.

Package

cl-ppcre.

Source

api.lisp.


5.1.4 Ordinary functions

Function: all-matches (regex target-string &key start end)

Returns a list containing the start and end positions of all matches of REGEX against TARGET-STRING, i.e. if there are N matches the list contains (* 2 N) elements. If REGEX matches an empty string the scan is continued one position behind this match.

Package

cl-ppcre.

Source

api.lisp.

Function: all-matches-as-strings (regex target-string &key start end sharedp)

Returns a list containing all substrings of TARGET-STRING which match REGEX. If REGEX matches an empty string the scan is continued one position behind this match. If SHAREDP is true, the substrings may share structure with TARGET-STRING.

Package

cl-ppcre.

Source

api.lisp.

Function: count-matches (regex target-string &key start end)

Returns a count of all substrings of TARGET-STRING which match REGEX.

Package

cl-ppcre.

Source

api.lisp.

Function: create-optimized-test-function (test-function &key start end kind)

Given a unary test function which is applicable to characters returns a function which yields the same boolean results for all characters with character codes from START to (excluding) END. If KIND is NIL, TEST-FUNCTION will simply be returned. Otherwise, KIND should be one of:

* :HASH-TABLE - builds a hash table representing all characters which satisfy the test and returns a closure which checks if a character is in that hash table

* :CHARSET - instead of a hash table uses a "charset" which is a data structure using non-linear hashing and optimized to represent (sparse) sets of characters in a fast and space-efficient way (contributed by Nikodemus Siivola)

* :CHARMAP - instead of a hash table uses a bit vector to represent the set of characters

You can also use :HASH-TABLE* or :CHARSET* which are like :HASH-TABLE and :CHARSET but use the complement of the set if the set contains more than half of all characters between START and END. This saves space but needs an additional pass across all characters to create the data structure. There is no corresponding :CHARMAP* kind as the bit vectors are already created to cover the smallest possible interval which contains either the set or its complement.

Package

cl-ppcre.

Source

chartest.lisp.

Function: parse-string (string)

Translate the regex string STRING into a parse tree.

Package

cl-ppcre.

Source

parser.lisp.

Function: parse-tree-synonym (symbol)

Returns the parse tree the SYMBOL symbol is a synonym for. Returns NIL is SYMBOL wasn’t yet defined to be a synonym.

Package

cl-ppcre.

Source

api.lisp.

Function: (setf parse-tree-synonym) (symbol)

Defines SYMBOL to be a synonm for the parse tree NEW-PARSE-TREE.

Package

cl-ppcre.

Source

api.lisp.

Function: quote-meta-chars (string &key start end)

Quote, i.e. prefix with #\\, all non-word characters in STRING.

Package

cl-ppcre.

Source

api.lisp.

Function: regex-apropos (regex &optional packages &key case-insensitive)

Similar to the standard function APROPOS but returns a list of all symbols which match the regular expression REGEX. If CASE-INSENSITIVE is true and REGEX isn’t already a scanner, a case-insensitive scanner is used.

Package

cl-ppcre.

Source

api.lisp.

Function: regex-apropos-list (regex &optional packages &key case-insensitive)

Similar to the standard function APROPOS-LIST but returns a list of all symbols which match the regular expression REGEX. If CASE-INSENSITIVE is true and REGEX isn’t already a scanner, a case-insensitive scanner is used.

Package

cl-ppcre.

Source

api.lisp.

Function: regex-replace (regex target-string replacement &key start end preserve-case simple-calls element-type)

Try to match TARGET-STRING between START and END against REGEX and replace the first match with REPLACEMENT. Two values are returned; the modified string, and T if REGEX matched or NIL otherwise.

REPLACEMENT can be a string which may contain the special substrings "\&" for the whole match, "\‘" for the part of TARGET-STRING before the match, "\’" for the part of TARGET-STRING after the match, "\N" or "\{N}" for the Nth register where N is a positive integer.

REPLACEMENT can also be a function designator in which case the match will be replaced with the result of calling the function designated by REPLACEMENT with the arguments TARGET-STRING, START, END, MATCH-START, MATCH-END, REG-STARTS, and REG-ENDS. (REG-STARTS and REG-ENDS are arrays holding the start and end positions of matched registers or NIL - the meaning of the other arguments should be obvious.)

Finally, REPLACEMENT can be a list where each element is a string, one of the symbols :MATCH, :BEFORE-MATCH, or :AFTER-MATCH - corresponding to "\&", "\‘", and "\’" above -, an integer N - representing register (1+ N) -, or a function designator.

If PRESERVE-CASE is true, the replacement will try to preserve the case (all upper case, all lower case, or capitalized) of the match. The result will always be a fresh string, even if REGEX doesn’t match.

ELEMENT-TYPE is the element type of the resulting string.

Package

cl-ppcre.

Source

api.lisp.

Function: regex-replace-all (regex target-string replacement &key start end preserve-case simple-calls element-type)

Try to match TARGET-STRING between START and END against REGEX and replace all matches with REPLACEMENT. Two values are returned; the modified string, and T if REGEX matched or NIL otherwise.

REPLACEMENT can be a string which may contain the special substrings "\&" for the whole match, "\‘" for the part of TARGET-STRING before the match, "\’" for the part of TARGET-STRING after the match, "\N" or "\{N}" for the Nth register where N is a positive integer.

REPLACEMENT can also be a function designator in which case the match will be replaced with the result of calling the function designated by REPLACEMENT with the arguments TARGET-STRING, START, END, MATCH-START, MATCH-END, REG-STARTS, and REG-ENDS. (REG-STARTS and REG-ENDS are arrays holding the start and end positions of matched registers or NIL - the meaning of the other arguments should be obvious.)

Finally, REPLACEMENT can be a list where each element is a string, one of the symbols :MATCH, :BEFORE-MATCH, or :AFTER-MATCH - corresponding to "\&", "\‘", and "\’" above -, an integer N - representing register (1+ N) -, or a function designator.

If PRESERVE-CASE is true, the replacement will try to preserve the case (all upper case, all lower case, or capitalized) of the match. The result will always be a fresh string, even if REGEX doesn’t match.

ELEMENT-TYPE is the element type of the resulting string.

Package

cl-ppcre.

Source

api.lisp.

Function: scan-to-strings (regex target-string &key start end sharedp)

Like SCAN but returns substrings of TARGET-STRING instead of positions, i.e. this function returns two values on success: the whole match as a string plus an array of substrings (or NILs) corresponding to the matched registers. If SHAREDP is true, the substrings may share structure with TARGET-STRING.

Package

cl-ppcre.

Source

api.lisp.

Function: split (regex target-string &key start end limit with-registers-p omit-unmatched-p sharedp)

Matches REGEX against TARGET-STRING as often as possible and returns a list of the substrings between the matches. If WITH-REGISTERS-P is true, substrings corresponding to matched registers are inserted into the list as well. If OMIT-UNMATCHED-P is true, unmatched registers will simply be left out, otherwise they will show up as NIL. LIMIT limits the number of elements returned - registers aren’t counted. If LIMIT is NIL (or 0 which is equivalent), trailing empty strings are removed from the result list. If REGEX matches an empty string the scan is continued one position behind this match. If SHAREDP is true, the substrings may share structure with TARGET-STRING.

Package

cl-ppcre.

Source

api.lisp.


5.1.5 Generic functions

Generic Function: create-scanner (regex &key case-insensitive-mode multi-line-mode single-line-mode extended-mode destructive)

Accepts a regular expression - either as a
parse-tree or as a string - and returns a scan closure which will scan strings for this regular expression and a list mapping registers to their names (NIL stands for unnamed ones). The "mode" keyword arguments are equivalent to the imsx modifiers in Perl. If DESTRUCTIVE is not NIL, the function is allowed to destructively modify its first argument (but only if it’s a parse tree).

Package

cl-ppcre.

Source

api.lisp.

Methods
Method: create-scanner (parse-tree &key case-insensitive-mode multi-line-mode single-line-mode extended-mode destructive)
Method: create-scanner ((scanner function) &key case-insensitive-mode multi-line-mode single-line-mode extended-mode destructive)
Method: create-scanner ((regex-string string) &key case-insensitive-mode multi-line-mode single-line-mode extended-mode destructive)
Generic Reader: ppcre-syntax-error-pos (condition)

Returns the position within the string where the error occurred (or NIL if the error happened while trying to convert a parse tree

Package

cl-ppcre.

Methods
Reader Method: ppcre-syntax-error-pos ((condition ppcre-syntax-error))
Source

errors.lisp.

Target Slot

pos.

Generic Reader: ppcre-syntax-error-string (condition)

Returns the string the parser was parsing when the error was encountered (or NIL if the error happened while trying to convert a parse tree).

Package

cl-ppcre.

Methods
Reader Method: ppcre-syntax-error-string ((condition ppcre-syntax-error))
Source

errors.lisp.

Target Slot

string.

Generic Function: scan (regex target-string &key start end real-start-pos)

Searches TARGET-STRING from START to END and tries
to match REGEX. On success returns four values - the start of the match, the end of the match, and two arrays denoting the beginnings and ends of register matches. On failure returns NIL. REGEX can be a string which will be parsed according to Perl syntax, a parse tree, or a pre-compiled scanner created by CREATE-SCANNER. TARGET-STRING will be coerced to a simple string if it isn’t one already. The REAL-START-POS parameter should be ignored - it exists only for internal purposes.

Package

cl-ppcre.

Source

api.lisp.

Methods
Method: scan (parse-tree target-string &key start end real-start-pos)
Method: scan ((scanner function) target-string &key start end real-start-pos)
Method: scan ((regex-string string) target-string &key start end real-start-pos)

5.1.6 Standalone methods

Method: initialize-instance :after ((str str) &rest init-args)

Automatically computes the length of a STR after initialization.

Source

regex-class.lisp.

Method: make-load-form ((set charset) &optional environment)
Source

charset.lisp.

Method: make-load-form ((map charmap) &optional environment)
Source

charmap.lisp.

Method: print-object ((register register) stream)
Source

regex-class.lisp.

Method: print-object ((str str) stream)
Source

regex-class.lisp.

Method: print-object ((repetition repetition) stream)
Source

regex-class.lisp.


5.1.7 Conditions

Condition: ppcre-error

All errors signaled by CL-PPCRE are of this type.

Package

cl-ppcre.

Source

errors.lisp.

Direct superclasses

simple-error.

Direct subclasses
Condition: ppcre-invocation-error

Signaled when CL-PPCRE functions are invoked with wrong arguments.

Package

cl-ppcre.

Source

errors.lisp.

Direct superclasses

ppcre-error.

Condition: ppcre-syntax-error

Signaled if CL-PPCRE’s parser encounters an error
when trying to parse a regex string or to convert a parse tree into its internal representation.

Package

cl-ppcre.

Source

errors.lisp.

Direct superclasses

ppcre-error.

Direct methods
Direct Default Initargs
InitargValue
:string*syntax-error-string*
:posnil
Direct slots
Slot: string
Package

common-lisp.

Initargs

:string

Readers

ppcre-syntax-error-string.

Writers

This slot is read-only.

Slot: pos
Initargs

:pos

Readers

ppcre-syntax-error-pos.

Writers

This slot is read-only.


5.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.1 Constants

Constant: +probe-depth+

Maximum number of collisions (for any element) we accept before we allocate more storage. This is now fixed, but could be made to vary depending on the size of the storage vector (e.g. in the range of 1-4). Larger probe-depths mean more collisions are tolerated before the table grows, but increase the constant factor.

Package

cl-ppcre.

Source

charset.lisp.

Constant: +whitespace-char-string+

A string of all characters which are considered to be whitespace. Same as Perl’s [\s].

Package

cl-ppcre.

Source

util.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.2 Special variables

Special Variable: *end-pos*

Where to stop scanning within *STRING*.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *end-string-pos*

Start of the next possible end-string candidate.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *extended-mode-p*

Whether the parser will start in extended mode.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *hyperdoc-base-uri*
Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *last-pos-stores*

An array to keep track of the last positions where we saw repetitive patterns.
Only used for patterns which might have zero length.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *real-start-pos*

The real start of *STRING*. This is for repeated scans and is only used internally.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *reg-ends*

An array which holds the end positions of the current register candidates.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *reg-starts*

An array which holds the start positions of the current register candidates.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *regs-maybe-start*

An array which holds the next start positions of the current register candidates.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *rep-num*

Counts the number of "complicated" repetitions while the matchers are built.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *repeat-counters*

An array to keep track of how often repetitive patterns have been tested already.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *special-optimize-settings*

Special optimize settings used only by a few declaration expressions.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *standard-optimize-settings*

The standard optimize settings used by most declaration expressions.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *start-pos*

Where to start scanning within *STRING*.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *string*

The string which is currently scanned by SCAN. Will always be coerced to a SIMPLE-STRING.

Package

cl-ppcre.

Source

specials.lisp.

Special Variable: *syntax-error-string*

The string which caused the syntax error.

Package

cl-ppcre.

Source

errors.lisp.

Special Variable: *zero-length-num*

Counts the number of repetitions the inner regexes of which may have zero-length while the matchers are built.

Package

cl-ppcre.

Source

specials.lisp.


5.2.3 Macros

Macro: bmh-matcher-aux (&key case-insensitive-p)

Auxiliary macro used by CREATE-BMH-MATCHER.

Package

cl-ppcre.

Source

scanner.lisp.

Macro: case-insensitive-mode-p (flags)

Accessor macro to extract the first flag out of a three-element flag list.

Package

cl-ppcre.

Source

convert.lisp.

Macro: char-searcher-aux (&key case-insensitive-p)

Auxiliary macro used by CREATE-CHAR-SEARCHER.

Package

cl-ppcre.

Source

scanner.lisp.

Macro: constant-repetition-constant-length-closure (check-curr-pos)

This is the template for simple constant repetitions (where simple means that the inner regex to be checked is of fixed length LEN, and that it doesn’t contain registers, i.e. there’s no need for backtracking) and where constant means that MINIMUM is equal to MAXIMUM. CHECK-CURR-POS is a form which checks whether the inner regex of the repetition matches at CURR-POS.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Macro: defconstant (name value &optional doc)

Make sure VALUE is evaluated only once (to appease SBCL).

Package

cl-ppcre.

Source

util.lisp.

Macro: greedy-constant-length-closure (check-curr-pos)

This is the template for simple greedy repetitions (where simple means that the minimum number of repetitions is zero, that the inner regex to be checked is of fixed length LEN, and that it doesn’t contain registers, i.e. there’s no need for backtracking). CHECK-CURR-POS is a form which checks whether the inner regex of the repetition matches at CURR-POS.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Macro: incf-after (place &optional delta)

Utility macro inspired by C’s "place++", i.e. first return the value of PLACE and afterwards increment it by DELTA.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Macro: insert-advance-fn (advance-fn)

Creates the actual closure returned by CREATE-SCANNER-AUX by replacing ’(ADVANCE-FN-DEFINITION) with a suitable definition for ADVANCE-FN. This is a utility macro used by CREATE-SCANNER-AUX.

Package

cl-ppcre.

Source

scanner.lisp.

Macro: insert-char-class-tester ((char-class chr-expr) &body body)

Utility macro to replace each occurence of ’(CHAR-CLASS-TEST) within BODY with the correct test (corresponding to CHAR-CLASS) against CHR-EXPR.

Package

cl-ppcre.

Source

closures.lisp.

Macro: maybe-coerce-to-simple-string (string)

Coerces STRING to a simple STRING unless it already is one.

Package

cl-ppcre.

Source

util.lisp.

Macro: multi-line-mode-p (flags)

Accessor macro to extract the second flag out of a three-element flag list.

Package

cl-ppcre.

Source

convert.lisp.

Macro: non-greedy-constant-length-closure (check-curr-pos)

This is the template for simple non-greedy repetitions (where simple means that the minimum number of repetitions is zero, that the inner regex to be checked is of fixed length LEN, and that it doesn’t contain registers, i.e. there’s no need for backtracking). CHECK-CURR-POS is a form which checks whether the inner regex of the repetition matches at CURR-POS.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Macro: regex-apropos-aux ((regex packages case-insensitive &optional return-form) &body body)

Auxiliary macro used by REGEX-APROPOS and REGEX-APROPOS-LIST. Loops through PACKAGES and executes BODY with SYMBOL bound to each symbol which matches REGEX. Optionally evaluates and returns RETURN-FORM at the end. If CASE-INSENSITIVE is true and REGEX isn’t already a scanner, a case-insensitive scanner is used.

Package

cl-ppcre.

Source

api.lisp.

Macro: signal-invocation-error (format-control &rest format-arguments)
Package

cl-ppcre.

Source

errors.lisp.

Macro: signal-syntax-error (format-control &rest format-arguments)
Package

cl-ppcre.

Source

errors.lisp.

Macro: signal-syntax-error* (pos format-control &rest format-arguments)
Package

cl-ppcre.

Source

errors.lisp.

Macro: single-line-mode-p (flags)

Accessor macro to extract the third flag out of a three-element flag list.

Package

cl-ppcre.

Source

convert.lisp.

Macro: with-rebinding (bindings &body body)

WITH-REBINDING ( { var | (var prefix) }* ) form*

Evaluates a series of forms in the lexical environment that is formed by adding the binding of each VAR to a fresh, uninterned symbol, and the binding of that fresh, uninterned symbol to VAR’s original value, i.e., its value in the current lexical environment.

The uninterned symbol is created as if by a call to GENSYM with the string denoted by PREFIX - or, if PREFIX is not supplied, the string denoted by VAR - as argument.

The forms are evaluated in order, and the values of all but the last are discarded (that is, the body is an implicit PROGN).

Package

cl-ppcre.

Source

util.lisp.

Macro: with-unique-names ((&rest bindings) &body body)

Syntax: WITH-UNIQUE-NAMES ( { var | (var x) }* ) declaration* form*

Executes a series of forms with each VAR bound to a fresh, uninterned symbol. The uninterned symbol is as if returned by a call to GENSYM with the string denoted by X - or, if X is not supplied, the string denoted by VAR - as argument.

The variable bindings created are lexical unless special declarations are specified. The scopes of the name bindings and declarations do not include the Xs.

The forms are evaluated in order, and the values of all but the last are discarded (that is, the body is an implicit PROGN).

Package

cl-ppcre.

Source

util.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.4 Ordinary functions

Function: %add-to-charset (char set count)

Tries to add the character CHAR to the charset SET without extending it. Returns NIL if this fails. Counts CHAR as new if COUNT is true and it is added to SET.

Package

cl-ppcre.

Source

charset.lisp.

Function: %add-to-charset/expand (char set)

Extends the charset SET and then adds the character CHAR to it.

Package

cl-ppcre.

Source

charset.lisp.

Function: *string*-equal (string2 start1 end1 start2 end2)

Like STRING-EQUAL, i.e. compares the special string *STRING* from START1 to END1 with STRING2 from START2 to END2. Note that there’s no boundary check - this has to be implemented by the caller.

Package

cl-ppcre.

Source

closures.lisp.

Function: *string*= (string2 start1 end1 start2 end2)

Like STRING=, i.e. compares the special string *STRING* from START1 to END1 with STRING2 from START2 to END2. Note that there’s no boundary check - this has to be implemented by the caller.

Package

cl-ppcre.

Source

closures.lisp.

Function: add-to-charset (char set)

Adds the character CHAR to the charset SET, extending SET if necessary. Returns CHAR.

Package

cl-ppcre.

Source

charset.lisp.

Function: build-replacement (replacement-template target-string start end match-start match-end reg-starts reg-ends simple-calls element-type)

Accepts a replacement template and the current values from the matching process in REGEX-REPLACE or REGEX-REPLACE-ALL and returns the corresponding string.

Package

cl-ppcre.

Source

api.lisp.

Reader: charmap-complementp (instance)
Writer: (setf charmap-complementp) (instance)
Package

cl-ppcre.

Source

charmap.lisp.

Target Slot

complementp.

Function: charmap-contents (charmap)

Returns a list of all characters belonging to a character map. Only works for non-complement charmaps.

Package

cl-ppcre.

Source

charmap.lisp.

Reader: charmap-count (instance)
Writer: (setf charmap-count) (instance)
Package

cl-ppcre.

Source

charmap.lisp.

Target Slot

count.

Reader: charmap-end (instance)
Writer: (setf charmap-end) (instance)
Package

cl-ppcre.

Source

charmap.lisp.

Target Slot

end.

Function: charmap-p (object)
Package

cl-ppcre.

Source

charmap.lisp.

Reader: charmap-start (instance)
Writer: (setf charmap-start) (instance)
Package

cl-ppcre.

Source

charmap.lisp.

Target Slot

start.

Reader: charmap-vector (instance)
Writer: (setf charmap-vector) (instance)
Package

cl-ppcre.

Source

charmap.lisp.

Target Slot

vector.

Reader: charset-count (instance)
Writer: (setf charset-count) (instance)
Package

cl-ppcre.

Source

charset.lisp.

Target Slot

count.

Reader: charset-depth (instance)
Writer: (setf charset-depth) (instance)
Package

cl-ppcre.

Source

charset.lisp.

Target Slot

depth.

Function: charset-p (object)
Package

cl-ppcre.

Source

charset.lisp.

Reader: charset-vector (instance)
Writer: (setf charset-vector) (instance)
Package

cl-ppcre.

Source

charset.lisp.

Target Slot

vector.

Function: clean-comments (string &optional extended-mode)

Clean (?#...) comments within STRING for quoting, i.e. convert \Q to Q and \E to E. If EXTENDED-MODE is true, also clean end-of-line comments, i.e. those starting with #\# and ending with #\Newline.

Package

cl-ppcre.

Source

api.lisp.

Function: collect-char-class (lexer)

Reads and consumes characters from regex string until a right bracket is seen. Assembles them into a list (which is returned) of characters, character ranges, like (:RANGE #\A #\E) for a-e, and tokens representing special character classes.

Package

cl-ppcre.

Source

lexer.lisp.

Function: complement* (test-function)

Like COMPLEMENT but optimized for unary functions.

Package

cl-ppcre.

Source

util.lisp.

Function: compute-index (hash vector)

Computes and returns the index into the vector VECTOR corresponding to the hash code HASH.

Package

cl-ppcre.

Source

charset.lisp.

Function: convert (parse-tree)

Converts the parse tree PARSE-TREE into an equivalent REGEX object and returns three values: the REGEX object, the number of registers seen and an object the regex starts with which is either a STR object or an EVERYTHING object (if the regex starts with something like ".*") or NIL.

Package

cl-ppcre.

Source

convert.lisp.

Function: convert-aux (parse-tree)

Converts the parse tree PARSE-TREE into a REGEX object and returns
it. Will also

- split and optimize repetitions,
- accumulate strings or EVERYTHING objects into the special variable STARTS-WITH,
- keep track of all registers seen in the special variable REG-NUM,
- keep track of all named registers seen in the special variable REG-NAMES - keep track of the highest backreference seen in the special
variable MAX-BACK-REF,
- maintain and adher to the currently applicable modifiers in the special variable FLAGS, and
- maybe even wash your car...

Package

cl-ppcre.

Source

convert.lisp.

Function: convert-char-class-to-test-function (list invertedp case-insensitive-p)

Combines all items in LIST into test function and returns a logical-OR combination of these functions. Items can be single characters, character ranges like (:RANGE #\A #\E), or special character classes like :DIGIT-CLASS. Does the right thing with respect to case-(in)sensitivity as specified by the special variable FLAGS.

Package

cl-ppcre.

Source

convert.lisp.

Function: copy-charmap (instance)
Package

cl-ppcre.

Source

charmap.lisp.

Function: copy-charset (instance)
Package

cl-ppcre.

Source

charset.lisp.

Function: copy-lexer (instance)
Package

cl-ppcre.

Source

lexer.lisp.

Function: create-bmh-matcher (pattern case-insensitive-p)

Returns a Boyer-Moore-Horspool matcher which searches the (special) simple-string *STRING* for the first occurence of the substring PATTERN. The search starts at the position START-POS within *STRING* and stops before *END-POS* is reached. Depending on the second argument the search is case-insensitive or not. If the special variable *USE-BMH-MATCHERS* is NIL, use the standard SEARCH function instead. (BMH matchers are faster but need much more space.)

Package

cl-ppcre.

Source

scanner.lisp.

Function: create-char-searcher (chr case-insensitive-p)

Returns a function which searches the (special) simple-string *STRING* for the first occurence of the character CHR. The search starts at the position START-POS within *STRING* and stops before *END-POS* is reached. Depending on the second argument the search is case-insensitive or not.

Package

cl-ppcre.

Source

scanner.lisp.

Function: create-charmap-from-test-function (test-function start end)

Creates and returns a charmap representing all characters with character codes between START and END which satisfy TEST-FUNCTION. Tries to find the smallest interval which is necessary to represent the character set and uses the complement representation if that helps.

Package

cl-ppcre.

Source

charmap.lisp.

Function: create-charset-from-test-function (test-function start end)

Creates and returns a charset representing all characters with character codes between START and END which satisfy TEST-FUNCTION.

Package

cl-ppcre.

Source

charset.lisp.

Function: create-greedy-everything-matcher (maximum min-rest next-fn)

Creates a closure which just matches as far ahead as possible, i.e. a closure for a dot in single-line mode.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Function: create-hash-table-from-test-function (test-function start end)

Creates and returns a hash table representing all characters with character codes between START and END which satisfy TEST-FUNCTION.

Package

cl-ppcre.

Source

chartest.lisp.

Function: create-scanner-aux (match-fn min-len start-anchored-p starts-with start-string-test end-anchored-p end-string-test end-string-len end-string-offset rep-num zero-length-num reg-num)

Auxiliary function to create and return a scanner (which is actually a closure). Used by CREATE-SCANNER.

Package

cl-ppcre.

Source

scanner.lisp.

Function: digit-char-p (chr)

Tests whether a character is a decimal digit, i.e. the same as Perl’s [\d]. Note that this function shadows the standard Common Lisp function CL:DIGIT-CHAR-P.

Package

cl-ppcre.

Source

util.lisp.

Function: end-of-string-p (lexer)

Tests whether we’re at the end of the regex string.

Package

cl-ppcre.

Source

lexer.lisp.

Function: end-string (regex)

Returns the constant string (if it exists) REGEX ends with wrapped into a STR object, otherwise NIL.

Package

cl-ppcre.

Source

optimize.lisp.

Function: fail (lexer)

Moves (LEXER-POS LEXER) back to the last position stored in (LEXER-LAST-POS LEXER) and pops the LAST-POS stack.

Package

cl-ppcre.

Source

lexer.lisp.

Function: get-number (lexer &key radix max-length no-whitespace-p)

Read and consume the number the lexer is currently looking at and return it. Returns NIL if no number could be identified.
RADIX is used as in PARSE-INTEGER. If MAX-LENGTH is not NIL we’ll read at most the next MAX-LENGTH characters. If NO-WHITESPACE-P is not NIL we don’t tolerate whitespace in front of the number.

Package

cl-ppcre.

Source

lexer.lisp.

Function: get-quantifier (lexer)

Returns a list of two values (min max) if what the lexer is looking at can be interpreted as a quantifier. Otherwise returns NIL and resets the lexer to its old position.

Package

cl-ppcre.

Source

lexer.lisp.

Function: get-token (lexer)

Returns and consumes the next token from the regex string (or NIL).

Package

cl-ppcre.

Source

lexer.lisp.

Function: greedy-quant (lexer)

Parses and consumes a <greedy-quant>.
The productions are: <greedy-quant> -> <group> | <group><quantifier> where <quantifier> is parsed by the lexer function GET-QUANTIFIER. Will return <parse-tree> or (:GREEDY-REPETITION <min> <max> <parse-tree>).

Package

cl-ppcre.

Source

parser.lisp.

Function: group (lexer)

Parses and consumes a <group>.
The productions are: <group> -> "("<regex>")" "(?:"<regex>")" "(?>"<regex>")" "(?<flags>:"<regex>")" "(?="<regex>")" "(?!"<regex>")" "(?<="<regex>")" "(?<!"<regex>")" "(?("<num>")"<regex>")" "(?("<regex>")"<regex>")"
"(?<name>"<regex>")" (when *ALLOW-NAMED-REGISTERS* is T) <legal-token>
where <flags> is parsed by the lexer function MAYBE-PARSE-FLAGS.
Will return <parse-tree> or (<grouping-type> <parse-tree>) where
<grouping-type> is one of six keywords - see source for details.

Package

cl-ppcre.

Source

parser.lisp.

Function: hyperdoc-lookup (symbol type)
Package

cl-ppcre.

Source

specials.lisp.

Function: in-charmap-p (char charmap)

Tests whether the character CHAR belongs to the set represented by CHARMAP.

Package

cl-ppcre.

Source

charmap.lisp.

Function: in-charset-p (char set)

Checks whether the character CHAR is in the charset SET.

Package

cl-ppcre.

Source

charset.lisp.

Reader: lexer-last-pos (instance)
Writer: (setf lexer-last-pos) (instance)
Package

cl-ppcre.

Source

lexer.lisp.

Target Slot

last-pos.

Reader: lexer-len (instance)
Package

cl-ppcre.

Source

lexer.lisp.

Target Slot

len.

Function: lexer-p (object)
Package

cl-ppcre.

Source

lexer.lisp.

Reader: lexer-pos (instance)
Writer: (setf lexer-pos) (instance)
Package

cl-ppcre.

Source

lexer.lisp.

Target Slot

pos.

Reader: lexer-reg (instance)
Writer: (setf lexer-reg) (instance)
Package

cl-ppcre.

Source

lexer.lisp.

Target Slot

reg.

Reader: lexer-str (instance)
Package

cl-ppcre.

Source

lexer.lisp.

Target Slot

str.

Function: looking-at-p (lexer chr)

Tests whether the next character the lexer would see is CHR. Does not respect extended mode.

Package

cl-ppcre.

Source

lexer.lisp.

Function: make-char-from-code (number error-pos)

Create character from char-code NUMBER. NUMBER can be NIL which is interpreted as 0. ERROR-POS is the position where the corresponding number started within the regex string.

Package

cl-ppcre.

Source

lexer.lisp.

Function: make-char-vector (size)

Returns a vector of size SIZE to hold characters. All elements are initialized to #Null except for the first one which is initialized to #?.

Package

cl-ppcre.

Source

charset.lisp.

Function: make-charmap (start end test-function &optional complementp)

Creates and returns a charmap representing all characters with character codes in the interval [start end) that satisfy TEST-FUNCTION. The COMPLEMENTP slot of the charmap is set to the value of the optional argument, but this argument doesn’t have an effect on how TEST-FUNCTION is used.

Package

cl-ppcre.

Source

charmap.lisp.

Function: make-charmap% (&key vector start end count complementp)
Package

cl-ppcre.

Source

charmap.lisp.

Function: make-charset ()
Package

cl-ppcre.

Source

charset.lisp.

Function: make-lexer (string)
Package

cl-ppcre.

Source

lexer.lisp.

Function: make-lexer-internal (&key str len reg pos last-pos)
Package

cl-ppcre.

Source

lexer.lisp.

Function: map-char-to-special-char-class (chr)

Maps escaped characters like "\d" to the tokens which represent their associated character classes.

Package

cl-ppcre.

Source

lexer.lisp.

Function: map-charset (function charset)

Calls FUNCTION with all characters in SET. Returns NIL.

Package

cl-ppcre.

Source

charset.lisp.

Function: maybe-accumulate (str)

Accumulate STR into the special variable STARTS-WITH if ACCUMULATE-START-P (also special) is true and STARTS-WITH is either NIL or a STR object of the same case mode. Always returns NIL.

Package

cl-ppcre.

Source

convert.lisp.

Function: maybe-parse-flags (lexer)

Reads a sequence of modifiers (including #\- to reverse their meaning) and returns a corresponding list of "flag" tokens. The "x" modifier is treated specially in that it dynamically modifies the behaviour of the lexer itself via the special variable *EXTENDED-MODE-P*.

Package

cl-ppcre.

Source

lexer.lisp.

Function: maybe-split-repetition (regex greedyp minimum maximum min-len length reg-seen)

Splits a REPETITION object into a constant and a varying part if applicable, i.e. something like
a{3,} -> a{3}a*
The arguments to this function correspond to the REPETITION slots of the same name.

Package

cl-ppcre.

Source

convert.lisp.

Function: mix (code hash)

Given a character code CODE and a hash code HASH, computes and returns the "next" hash code. See comments below.

Package

cl-ppcre.

Source

charset.lisp.

Function: newline-skipper (start-pos)

Finds the next occurence of a character in *STRING* which is behind a #Newline.

Package

cl-ppcre.

Source

scanner.lisp.

Function: next-char (lexer)

Returns the next character which is to be examined and updates the POS slot. Respects extended mode, i.e. whitespace, comments, and also nested comments are skipped if applicable.

Package

cl-ppcre.

Source

lexer.lisp.

Function: next-char-non-extended (lexer)

Returns the next character which is to be examined and updates the POS slot. Does not respect extended mode.

Package

cl-ppcre.

Source

lexer.lisp.

Function: normalize-var-list (var-list)

Utility function for REGISTER-GROUPS-BIND and DO-REGISTER-GROUPS. Creates the long form (a list of (FUNCTION VAR) entries) out of the short form of VAR-LIST.

Package

cl-ppcre.

Source

util.lisp.

Function: nsubseq (sequence start &optional end)

Returns a subsequence by pointing to location in original sequence.

Package

cl-ppcre.

Source

util.lisp.

Function: parse-register-name-aux (lexer)

Reads and returns the name in a named register group. It is assumed that the starting #< character has already been read. The closing #> will also be consumed.

Package

cl-ppcre.

Source

lexer.lisp.

Function: print-symbol-info (symbol)

Auxiliary function used by REGEX-APROPOS. Tries to print some meaningful information about a symbol.

Package

cl-ppcre.

Source

api.lisp.

Function: quant (lexer)

Parses and consumes a <quant>.
The productions are: <quant> -> <greedy-quant> | <greedy-quant>"?". Will return the <parse-tree> returned by GREEDY-QUANT and optionally change :GREEDY-REPETITION to :NON-GREEDY-REPETITION.

Package

cl-ppcre.

Source

parser.lisp.

Function: quote-sections (string)

Replace sections inside of STRING which are enclosed by \Q and \E with the quoted equivalent of these sections (see QUOTE-META-CHARS). Repeat this as long as there are such sections. These sections may nest.

Package

cl-ppcre.

Source

api.lisp.

Function: read-char-property (lexer first-char)
Package

cl-ppcre.

Source

lexer.lisp.

Function: reg-expr (lexer)

Parses and consumes a <regex>, a complete regular expression.
The productions are: <regex> -> <seq> | <seq>"|"<regex>.
Will return <parse-tree> or (:ALTERNATION <parse-tree> <parse-tree>).

Package

cl-ppcre.

Source

parser.lisp.

Function: replace-aux (target-string replacement pos-list reg-list start end preserve-case simple-calls element-type)

Auxiliary function used by REGEX-REPLACE and REGEX-REPLACE-ALL. POS-LIST contains a list with the start and end positions of all matches while REG-LIST contains a list of arrays representing the corresponding register start and end positions.

Package

cl-ppcre.

Source

api.lisp.

Function: seq (lexer)

Parses and consumes a <seq>.
The productions are: <seq> -> <quant> | <quant><seq>.
Will return <parse-tree> or (:SEQUENCE <parse-tree> <parse-tree>).

Package

cl-ppcre.

Source

parser.lisp.

Function: set-flag (token)

Reads a flag token and sets or unsets the corresponding entry in the special FLAGS list.

Package

cl-ppcre.

Source

convert.lisp.

Function: start-of-subexpr-p (lexer)

Tests whether the next token can start a valid sub-expression, i.e. a stand-alone regex.

Package

cl-ppcre.

Source

lexer.lisp.

Function: string-case-modifier (str from to start end)

Checks whether all words in STR between FROM and TO are upcased, downcased or capitalized and returns a function which applies a corresponding case modification to strings. Returns #’IDENTITY otherwise, especially if words in the target area extend beyond FROM or TO. STR is supposed to be bounded by START and END. It is assumed that (<= START FROM TO END).

Package

cl-ppcre.

Source

api.lisp.

Function: string-list-to-simple-string (string-list)

Concatenates a list of strings to one simple-string.

Package

cl-ppcre.

Source

util.lisp.

Function: try-number (lexer &key radix max-length no-whitespace-p)

Like GET-NUMBER but won’t consume anything if no number is seen.

Package

cl-ppcre.

Source

lexer.lisp.

Function: unescape-char (lexer)

Convert the characters(s) following a backslash into a token which is returned. This function is to be called when the backslash has already been consumed. Special character classes like \W are handled elsewhere.

Package

cl-ppcre.

Source

lexer.lisp.

Function: unget-token (lexer)

Moves the lexer back to the last position stored in the LAST-POS stack.

Package

cl-ppcre.

Source

lexer.lisp.

Function: whitespacep (chr)

Tests whether a character is whitespace, i.e. whether it would match [\s] in Perl.

Package

cl-ppcre.

Source

util.lisp.

Function: word-boundary-p (start-pos)

Check whether START-POS is a word-boundary within *STRING*.

Package

cl-ppcre.

Source

closures.lisp.

Function: word-char-p (chr)

Tests whether a character is a "word" character. In the ASCII charset this is equivalent to a-z, A-Z, 0-9, or _, i.e. the same as Perl’s [\w].

Package

cl-ppcre.

Source

util.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.5 Generic functions

Generic Function: build-replacement-template (replacement-string)

Converts a replacement string for REGEX-REPLACE or REGEX-REPLACE-ALL into a replacement template which is an S-expression.

Package

cl-ppcre.

Source

api.lisp.

Methods
Method: build-replacement-template ((replacement-list list))
Method: build-replacement-template ((replacement-function-symbol symbol))
Method: build-replacement-template ((replacement-function function))
Method: build-replacement-template ((replacement-string string))
Generic Reader: case-insensitive-p (object)
Package

cl-ppcre.

Methods
Reader Method: case-insensitive-p ((str str))

If we match case-insensitively.

Source

regex-class.lisp.

Target Slot

case-insensitive-p.

Reader Method: case-insensitive-p ((back-reference back-reference))

Whether we check case-insensitively.

Source

regex-class.lisp.

Target Slot

case-insensitive-p.

Generic Function: case-mode (regex old-case-mode)

Utility function used by the optimizer (see GATHER-STRINGS). Returns a keyword denoting the case-(in)sensitivity of a STR or its second argument if the STR has length 0. Returns NIL for REGEX objects which are not of type STR.

Package

cl-ppcre.

Source

regex-class-util.lisp.

Methods
Method: case-mode ((regex regex) old-case-mode)
Method: case-mode ((str str) old-case-mode)
Generic Reader: choices (object)
Generic Writer: (setf choices) (object)
Package

cl-ppcre.

Methods
Reader Method: choices ((alternation alternation))
Writer Method: (setf choices) ((alternation alternation))

A list of REGEX objects

Source

regex-class.lisp.

Target Slot

choices.

Generic Function: compute-min-rest (regex current-min-rest)

Returns the minimal length of REGEX plus
CURRENT-MIN-REST. This is similar to REGEX-MIN-LENGTH except that it recurses down into REGEX and sets the MIN-REST slots of REPETITION objects.

Package

cl-ppcre.

Source

optimize.lisp.

Methods
Method: compute-min-rest ((regex regex) current-min-rest)
Method: compute-min-rest ((lookbehind lookbehind) current-min-rest)
Method: compute-min-rest ((lookahead lookahead) current-min-rest)
Method: compute-min-rest ((standalone standalone) current-min-rest)
Method: compute-min-rest ((register register) current-min-rest)
Method: compute-min-rest ((repetition repetition) current-min-rest)
Method: compute-min-rest ((filter filter) current-min-rest)
Method: compute-min-rest ((str str) current-min-rest)
Method: compute-min-rest ((branch branch) current-min-rest)
Method: compute-min-rest ((alternation alternation) current-min-rest)
Method: compute-min-rest ((seq seq) current-min-rest)
Generic Function: compute-offsets (regex start-pos)

Returns the offset the following regex would have
relative to START-POS or NIL if we can’t compute it. Sets the OFFSET slot of REGEX to START-POS if REGEX is a STR. May also affect OFFSET slots of STR objects further down the tree.

Package

cl-ppcre.

Source

regex-class-util.lisp.

Methods
Method: compute-offsets ((regex regex) start-pos)
Method: compute-offsets ((filter filter) start-pos)
Method: compute-offsets ((back-reference back-reference) start-pos)
Method: compute-offsets ((str str) start-pos)
Method: compute-offsets ((everything everything) start-pos)
Method: compute-offsets ((char-class char-class) start-pos)
Method: compute-offsets ((standalone standalone) start-pos)
Method: compute-offsets ((register register) start-pos)
Method: compute-offsets ((repetition repetition) start-pos)
Method: compute-offsets ((branch branch) start-pos)
Method: compute-offsets ((alternation alternation) start-pos)
Method: compute-offsets ((seq seq) start-pos)
Generic Reader: contains-register-p (object)
Package

cl-ppcre.

Methods
Reader Method: contains-register-p ((repetition repetition))

Whether the regex contains a register.

Source

regex-class.lisp.

Target Slot

contains-register-p.

Generic Function: convert-compound-parse-tree (token parse-tree &key invertedp name greedyp)

Helper function for CONVERT-AUX which converts
parse trees which are conses and dispatches on TOKEN which is the first element of the parse tree.

Package

cl-ppcre.

Source

convert.lisp.

Methods
Method: convert-compound-parse-tree ((token (eql :flags)) parse-tree &key)

The case for (:FLAGS {<flag>}*) where flag is a modifier symbol like :CASE-INSENSITIVE-P.

Method: convert-compound-parse-tree ((token (eql :inverted-property)) parse-tree &key)

The case for (:INVERTED-PROPERTY <name>) where <name> is a string.

Method: convert-compound-parse-tree ((token (eql :property)) parse-tree &key)

The case for (:PROPERTY <name>) where <name> is a string.

Method: convert-compound-parse-tree ((token (eql :inverted-char-class)) parse-tree &key)

The case for (:INVERTED-CHAR-CLASS {<item>}*).

Method: convert-compound-parse-tree ((token (eql :char-class)) parse-tree &key invertedp)

The case for (:CHAR-CLASS {<item>}*) where item is one of

- a character,
- a character range: (:RANGE <char1> <char2>), or
- a special char class symbol like :DIGIT-CHAR-CLASS.

Also used for inverted char classes when INVERTEDP is true.

Method: convert-compound-parse-tree ((token (eql :regex)) parse-tree &key)

The case for (:REGEX <string>).

Method: convert-compound-parse-tree ((token (eql :back-reference)) parse-tree &key)

The case for (:BACK-REFERENCE <number>|<name>).

Method: convert-compound-parse-tree ((token (eql :standalone)) parse-tree &key)

The case for (:STANDALONE <regex>).

Method: convert-compound-parse-tree ((token (eql :filter)) parse-tree &key)

The case for (:FILTER <function> &optional <length>).

Method: convert-compound-parse-tree ((token (eql :named-register)) parse-tree &key)

The case for (:NAMED-REGISTER <regex>).

Method: convert-compound-parse-tree ((token (eql :register)) parse-tree &key name)

The case for (:REGISTER <regex>). Also used for named registers when NAME is not NIL.

Method: convert-compound-parse-tree ((token (eql :non-greedy-repetition)) parse-tree &key)

The case for (:NON-GREEDY-REPETITION <min> <max> <regex>).

Method: convert-compound-parse-tree ((token (eql :greedy-repetition)) parse-tree &key greedyp)

The case for (:GREEDY-REPETITION|:NON-GREEDY-REPETITION <min> <max> <regex>).

This function is also used for the non-greedy case in which case it is called with GREEDYP set to NIL as you would expect.

Method: convert-compound-parse-tree ((token (eql :negative-lookbehind)) parse-tree &key)

The case for (:NEGATIVE-LOOKBEHIND <regex>).

Method: convert-compound-parse-tree ((token (eql :positive-lookbehind)) parse-tree &key)

The case for (:POSITIVE-LOOKBEHIND <regex>).

Method: convert-compound-parse-tree ((token (eql :negative-lookahead)) parse-tree &key)

The case for (:NEGATIVE-LOOKAHEAD <regex>).

Method: convert-compound-parse-tree ((token (eql :positive-lookahead)) parse-tree &key)

The case for (:POSITIVE-LOOKAHEAD <regex>).

Method: convert-compound-parse-tree ((token (eql :branch)) parse-tree &key)

The case for (:BRANCH <test> <regex>).

Here, <test> must be look-ahead, look-behind or number; if <regex> is an alternation it must have one or two choices.

Method: convert-compound-parse-tree ((token (eql :alternation)) parse-tree &key)

The case for (:ALTERNATION {<regex>}*).

Method: convert-compound-parse-tree ((token (eql :group)) parse-tree &key)

The case for parse trees like (:GROUP {<regex>}*).

This is a syntactical construct equivalent to :SEQUENCE intended to keep the effect of modifiers local.

Method: convert-compound-parse-tree ((token (eql :sequence)) parse-tree &key)

The case for parse trees like (:SEQUENCE {<regex>}*).

Method: convert-compound-parse-tree (token parse-tree &key)
Generic Function: convert-simple-parse-tree (parse-tree)

Helper function for CONVERT-AUX which converts parse trees which are atoms.

Package

cl-ppcre.

Source

convert.lisp.

Methods
Method: convert-simple-parse-tree (parse-tree)

The default method - check if there’s a translation.

Method: convert-simple-parse-tree ((parse-tree character))
Method: convert-simple-parse-tree ((parse-tree string))
Method: convert-simple-parse-tree ((parse-tree (eql :void)))
Method: convert-simple-parse-tree ((parse-tree (eql :word-boundary)))
Method: convert-simple-parse-tree ((parse-tree (eql :non-word-boundary)))
Method: convert-simple-parse-tree ((parse-tree (eql :everything)))
Method: convert-simple-parse-tree ((parse-tree (eql :digit-class)))
Method: convert-simple-parse-tree ((parse-tree (eql :word-char-class)))
Method: convert-simple-parse-tree ((parse-tree (eql :whitespace-char-class)))
Method: convert-simple-parse-tree ((parse-tree (eql :non-digit-class)))
Method: convert-simple-parse-tree ((parse-tree (eql :non-word-char-class)))
Method: convert-simple-parse-tree ((parse-tree (eql :non-whitespace-char-class)))
Method: convert-simple-parse-tree ((parse-tree (eql :start-anchor)))
Method: convert-simple-parse-tree ((parse-tree (eql :end-anchor)))
Method: convert-simple-parse-tree ((parse-tree (eql :modeless-start-anchor)))
Method: convert-simple-parse-tree ((parse-tree (eql :modeless-end-anchor)))
Method: convert-simple-parse-tree ((parse-tree (eql :modeless-end-anchor-no-newline)))
Method: convert-simple-parse-tree ((parse-tree (eql :case-insensitive-p)))
Method: convert-simple-parse-tree ((parse-tree (eql :case-sensitive-p)))
Method: convert-simple-parse-tree ((parse-tree (eql :multi-line-mode-p)))
Method: convert-simple-parse-tree ((parse-tree (eql :not-multi-line-mode-p)))
Method: convert-simple-parse-tree ((parse-tree (eql :single-line-mode-p)))
Method: convert-simple-parse-tree ((parse-tree (eql :not-single-line-mode-p)))
Generic Function: copy-regex (regex)

Implements a deep copy of a REGEX object.

Package

cl-ppcre.

Source

regex-class-util.lisp.

Methods
Method: copy-regex ((filter filter))
Method: copy-regex ((str str))
Method: copy-regex ((char-class char-class))
Method: copy-regex ((back-reference back-reference))
Method: copy-regex ((standalone standalone))
Method: copy-regex ((register register))
Method: copy-regex ((repetition repetition))
Method: copy-regex ((lookbehind lookbehind))
Method: copy-regex ((branch branch))
Method: copy-regex ((alternation alternation))
Method: copy-regex ((seq seq))
Method: copy-regex ((lookahead lookahead))
Method: copy-regex ((void void))
Method: copy-regex ((word-boundary word-boundary))
Method: copy-regex ((everything everything))
Method: copy-regex ((anchor anchor))
Generic Function: create-constant-repetition-constant-length-matcher (repetition next-fn)

Creates a closure which tries to match REPETITION.
It is assumed that REPETITION has a constant number of repetitions. It is furthermore assumed that the inner regex of REPETITION is of fixed length and doesn’t contain registers.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Methods
Method: create-constant-repetition-constant-length-matcher ((repetition repetition) next-fn)
Generic Function: create-constant-repetition-matcher (repetition next-fn)

Creates a closure which tries to match REPETITION.
It is assumed that REPETITION has a constant number of repetitions.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Methods
Method: create-constant-repetition-matcher ((repetition repetition) next-fn)
Generic Function: create-greedy-constant-length-matcher (repetition next-fn)

Creates a closure which tries to match REPETITION.
It is assumed that REPETITION is greedy and the minimal number of repetitions is zero. It is furthermore assumed that the inner regex of REPETITION is of fixed length and doesn’t contain registers.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Methods
Method: create-greedy-constant-length-matcher ((repetition repetition) next-fn)
Generic Function: create-greedy-matcher (repetition next-fn)

Creates a closure which tries to match REPETITION.
It is assumed that REPETITION is greedy and the minimal number of repetitions is zero.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Methods
Method: create-greedy-matcher ((repetition repetition) next-fn)
Generic Function: create-greedy-no-zero-matcher (repetition next-fn)

Creates a closure which tries to match REPETITION.
It is assumed that REPETITION is greedy and the minimal number of repetitions is zero. It is furthermore assumed that the inner regex of REPETITION can never match a zero-length string (or instead the maximal number of repetitions is 1).

Package

cl-ppcre.

Source

repetition-closures.lisp.

Methods
Method: create-greedy-no-zero-matcher ((repetition repetition) next-fn)
Generic Function: create-matcher-aux (regex next-fn)

Creates a closure which takes one parameter,
START-POS, and tests whether REGEX can match *STRING* at START-POS such that the call to NEXT-FN after the match would succeed.

Package

cl-ppcre.

Source

closures.lisp.

Methods
Method: create-matcher-aux ((repetition repetition) next-fn)
Source

repetition-closures.lisp.

Method: create-matcher-aux ((void void) next-fn)
Method: create-matcher-aux ((filter filter) next-fn)
Method: create-matcher-aux ((standalone standalone) next-fn)
Method: create-matcher-aux ((branch branch) next-fn)
Method: create-matcher-aux ((back-reference back-reference) next-fn)
Method: create-matcher-aux ((anchor anchor) next-fn)
Method: create-matcher-aux ((everything everything) next-fn)
Method: create-matcher-aux ((word-boundary word-boundary) next-fn)
Method: create-matcher-aux ((str str) next-fn)
Method: create-matcher-aux ((char-class char-class) next-fn)
Method: create-matcher-aux ((lookbehind lookbehind) next-fn)
Method: create-matcher-aux ((lookahead lookahead) next-fn)
Method: create-matcher-aux ((register register) next-fn)
Method: create-matcher-aux ((alternation alternation) next-fn)
Method: create-matcher-aux ((seq seq) next-fn)
Generic Function: create-non-greedy-constant-length-matcher (repetition next-fn)

Creates a closure which tries to match REPETITION.
It is assumed that REPETITION is non-greedy and the minimal number of repetitions is zero. It is furthermore assumed that the inner regex of REPETITION is of fixed length and doesn’t contain registers.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Methods
Method: create-non-greedy-constant-length-matcher ((repetition repetition) next-fn)
Generic Function: create-non-greedy-matcher (repetition next-fn)

Creates a closure which tries to match REPETITION.
It is assumed that REPETITION is non-greedy and the minimal number of repetitions is zero.

Package

cl-ppcre.

Source

repetition-closures.lisp.

Methods
Method: create-non-greedy-matcher ((repetition repetition) next-fn)
Generic Function: create-non-greedy-no-zero-matcher (repetition next-fn)

Creates a closure which tries to match REPETITION.
It is assumed that REPETITION is non-greedy and the minimal number of repetitions is zero. It is furthermore assumed that the inner regex of REPETITION can never match a zero-length string (or instead the maximal number of repetitions is 1).

Package

cl-ppcre.

Source

repetition-closures.lisp.

Methods
Method: create-non-greedy-no-zero-matcher ((repetition repetition) next-fn)
Generic Reader: elements (object)
Generic Writer: (setf elements) (object)
Package

cl-ppcre.

Methods
Reader Method: elements ((seq seq))
Writer Method: (setf elements) ((seq seq))

A list of REGEX objects.

Source

regex-class.lisp.

Target Slot

elements.

Generic Reader: else-regex (object)
Generic Writer: (setf else-regex) (object)
Package

cl-ppcre.

Methods
Reader Method: else-regex ((branch branch))
Writer Method: (setf else-regex) ((branch branch))

The regex that’s to be matched if the test fails.

Source

regex-class.lisp.

Target Slot

else-regex.

Generic Function: end-string-aux (regex &optional old-case-insensitive-p)

Returns the constant string (if it exists) REGEX
ends with wrapped into a STR object, otherwise NIL. OLD-CASE-INSENSITIVE-P is the CASE-INSENSITIVE-P slot of the last STR collected or :VOID if no STR has been collected yet. (This is a helper function called by END-STRING.)

Package

cl-ppcre.

Source

optimize.lisp.

Methods
Method: end-string-aux ((regex regex) &optional old-case-insensitive-p)
Method: end-string-aux ((standalone standalone) &optional old-case-insensitive-p)
Method: end-string-aux ((register register) &optional old-case-insensitive-p)
Method: end-string-aux ((seq seq) &optional old-case-insensitive-p)
Method: end-string-aux ((str str) &optional old-case-insensitive-p)
Generic Function: everythingp (regex)

Returns an EVERYTHING object if REGEX is equivalent
to this object, otherwise NIL. So, "(.){1}" would return true (i.e. the object corresponding to ".", for example.

Package

cl-ppcre.

Source

regex-class-util.lisp.

Methods
Method: everythingp ((regex regex))
Method: everythingp ((everything everything))
Method: everythingp ((standalone standalone))
Method: everythingp ((register register))
Method: everythingp ((repetition repetition))
Method: everythingp ((alternation alternation))
Method: everythingp ((seq seq))
Generic Function: flatten (regex)

Merges adjacent sequences and alternations, i.e. it transforms #<SEQ #<STR "a"> #<SEQ #<STR "b"> #<STR "c">>> to #<SEQ #<STR "a"> #<STR "b"> #<STR "c">>. This is a destructive operation on REGEX.

Package

cl-ppcre.

Source

optimize.lisp.

Methods
Method: flatten ((regex regex))
Method: flatten ((branch branch))
Method: flatten ((alternation alternation))
Method: flatten ((seq seq))
Generic Reader: fn (object)
Generic Writer: (setf fn) (object)
Package

cl-ppcre.

Methods
Reader Method: fn ((filter filter))
Writer Method: (setf fn) ((filter filter))

The user-defined function.

Source

regex-class.lisp.

Target Slot

fn.

Generic Function: gather-strings (regex)

Collects adjacent strings or characters into one
string provided they have the same case mode. This is a destructive operation on REGEX.

Package

cl-ppcre.

Source

optimize.lisp.

Methods
Method: gather-strings ((regex regex))
Method: gather-strings ((branch branch))
Method: gather-strings ((alternation alternation))
Method: gather-strings ((seq seq))
Generic Reader: greedyp (object)
Package

cl-ppcre.

Methods
Reader Method: greedyp ((repetition repetition))

Whether the repetition is greedy.

Source

regex-class.lisp.

Target Slot

greedyp.

Generic Function: len (object)
Package

cl-ppcre.

Methods
Method: len ((void void))
Source

regex-class-util.lisp.

Reader Method: len ((filter filter))

The fixed length of this filter or NIL.

Source

regex-class.lisp.

Target Slot

len.

Reader Method: len ((str str))

The length of the string.

Source

regex-class.lisp.

Target Slot

len.

Reader Method: len ((repetition repetition))

The length of the enclosed regex. NIL if unknown.

Source

regex-class.lisp.

Target Slot

len.

Reader Method: len ((lookbehind lookbehind))

The (fixed) length of the enclosed regex.

Source

regex-class.lisp.

Target Slot

len.

Generic Writer: (setf len) (object)
Package

cl-ppcre.

Methods
Writer Method: (setf len) ((str str))

The length of the string.

Source

regex-class.lisp.

Target Slot

len.

Writer Method: (setf len) ((lookbehind lookbehind))

The (fixed) length of the enclosed regex.

Source

regex-class.lisp.

Target Slot

len.

Generic Reader: maximum (object)
Generic Writer: (setf maximum) (object)
Package

cl-ppcre.

Methods
Reader Method: maximum ((repetition repetition))
Writer Method: (setf maximum) ((repetition repetition))

The maximal number of repetitions. Can be NIL for unbounded.

Source

regex-class.lisp.

Target Slot

maximum.

Generic Reader: min-len (object)
Package

cl-ppcre.

Methods
Reader Method: min-len ((repetition repetition))

The minimal length of the enclosed regex.

Source

regex-class.lisp.

Target Slot

min-len.

Generic Reader: min-rest (object)
Generic Writer: (setf min-rest) (object)
Package

cl-ppcre.

Methods
Reader Method: min-rest ((repetition repetition))
Writer Method: (setf min-rest) ((repetition repetition))

The minimal number of characters which must appear after this repetition.

Source

regex-class.lisp.

Target Slot

min-rest.

Generic Reader: minimum (object)
Generic Writer: (setf minimum) (object)
Package

cl-ppcre.

Methods
Reader Method: minimum ((repetition repetition))
Writer Method: (setf minimum) ((repetition repetition))

The minimal number of repetitions.

Source

regex-class.lisp.

Target Slot

minimum.

Generic Reader: multi-line-p (object)
Package

cl-ppcre.

Methods
Reader Method: multi-line-p ((anchor anchor))

Whether we’re in multi-line mode,
i.e. whether each #\Newline is surrounded by anchors.

Source

regex-class.lisp.

Target Slot

multi-line-p.

Generic Reader: name (object)
Generic Writer: (setf name) (object)
Package

cl-ppcre.

Methods
Reader Method: name ((back-reference back-reference))
Writer Method: (setf name) ((back-reference back-reference))

The name of the register this reference refers to or NIL.

Source

regex-class.lisp.

Target Slot

name.

Reader Method: name ((register register))

Name of this register or NIL.

Source

regex-class.lisp.

Target Slot

name.

Generic Reader: negatedp (object)
Package

cl-ppcre.

Methods
Reader Method: negatedp ((word-boundary word-boundary))

Whether we mean the opposite, i.e. no word-boundary.

Source

regex-class.lisp.

Target Slot

negatedp.

Generic Reader: no-newline-p (object)
Package

cl-ppcre.

Methods
Reader Method: no-newline-p ((anchor anchor))

Whether we ignore #\Newline at the end.

Source

regex-class.lisp.

Target Slot

no-newline-p.

Generic Reader: num (object)
Generic Writer: (setf num) (object)
Package

cl-ppcre.

Methods
Reader Method: num ((back-reference back-reference))
Writer Method: (setf num) ((back-reference back-reference))

The number of the register this reference refers to.

Source

regex-class.lisp.

Target Slot

num.

Reader Method: num ((register register))

The number of this register, starting from 0. This is the index into *REGS-START* and *REGS-END*.

Source

regex-class.lisp.

Target Slot

num.

Generic Reader: offset (object)
Generic Writer: (setf offset) (object)
Package

cl-ppcre.

Methods
Reader Method: offset ((str str))
Writer Method: (setf offset) ((str str))

Offset from the left of the whole
parse tree. The first regex has offset 0. NIL if unknown, i.e. behind a variable-length regex.

Source

regex-class.lisp.

Target Slot

offset.

Generic Reader: positivep (object)
Package

cl-ppcre.

Methods
Reader Method: positivep ((lookbehind lookbehind))

Whether this assertion is positive.

Source

regex-class.lisp.

Target Slot

positivep.

Reader Method: positivep ((lookahead lookahead))

Whether this assertion is positive.

Source

regex-class.lisp.

Target Slot

positivep.

Generic Reader: regex (object)
Generic Writer: (setf regex) (object)
Package

cl-ppcre.

Methods
Reader Method: regex ((standalone standalone))
Writer Method: (setf regex) ((standalone standalone))

The inner regex.

Source

regex-class.lisp.

Target Slot

regex.

Reader Method: regex ((register register))
Writer Method: (setf regex) ((register register))

The inner regex.

Source

regex-class.lisp.

Target Slot

regex.

Reader Method: regex ((repetition repetition))
Writer Method: (setf regex) ((repetition repetition))

The REGEX that’s repeated.

Source

regex-class.lisp.

Target Slot

regex.

Reader Method: regex ((lookbehind lookbehind))
Writer Method: (setf regex) ((lookbehind lookbehind))

The REGEX object we’re checking.

Source

regex-class.lisp.

Target Slot

regex.

Reader Method: regex ((lookahead lookahead))
Writer Method: (setf regex) ((lookahead lookahead))

The REGEX object we’re checking.

Source

regex-class.lisp.

Target Slot

regex.

Generic Function: regex-length (regex)

Return the length of REGEX if it is fixed, NIL otherwise.

Package

cl-ppcre.

Source

regex-class-util.lisp.

Methods
Method: regex-length ((regex regex))
Method: regex-length ((filter filter))
Method: regex-length ((str str))
Method: regex-length ((everything everything))
Method: regex-length ((char-class char-class))
Method: regex-length ((back-reference back-reference))
Method: regex-length ((standalone standalone))
Method: regex-length ((register register))
Method: regex-length ((repetition repetition))
Method: regex-length ((branch branch))
Method: regex-length ((alternation alternation))
Method: regex-length ((seq seq))
Generic Function: regex-min-length (regex)

Returns the minimal length of REGEX.

Package

cl-ppcre.

Source

regex-class-util.lisp.

Methods
Method: regex-min-length ((regex regex))
Method: regex-min-length ((filter filter))
Method: regex-min-length ((str str))
Method: regex-min-length ((everything everything))
Method: regex-min-length ((char-class char-class))
Method: regex-min-length ((standalone standalone))
Method: regex-min-length ((register register))
Method: regex-min-length ((repetition repetition))
Method: regex-min-length ((branch branch))
Method: regex-min-length ((alternation alternation))
Method: regex-min-length ((seq seq))
Generic Function: remove-registers (regex)

Returns a deep copy of a REGEX (see COPY-REGEX) and
optionally removes embedded REGISTER objects if possible and if the special variable REMOVE-REGISTERS-P is true.

Package

cl-ppcre.

Source

regex-class-util.lisp.

Methods
Method: remove-registers ((seq seq))
Method: remove-registers ((regex regex))
Method: remove-registers ((alternation alternation))
Method: remove-registers ((branch branch))
Method: remove-registers ((lookbehind lookbehind))
Method: remove-registers ((lookahead lookahead))
Method: remove-registers ((standalone standalone))
Method: remove-registers ((repetition repetition))
Method: remove-registers ((register register))
Generic Function: resolve-property (property)

Resolves PROPERTY to a unary character test
function. PROPERTY can either be a function designator or it can be a string which is resolved using *PROPERTY-RESOLVER*.

Package

cl-ppcre.

Source

convert.lisp.

Methods
Method: resolve-property ((property-name string))
Method: resolve-property ((function-name symbol))
Method: resolve-property ((test-function function))
Generic Reader: single-line-p (object)
Package

cl-ppcre.

Methods
Reader Method: single-line-p ((everything everything))

Whether we’re in single-line mode, i.e. whether we also match #\Newline.

Source

regex-class.lisp.

Target Slot

single-line-p.

Generic Function: skip (object)
Package

cl-ppcre.

Methods
Method: skip ((void void))
Source

regex-class-util.lisp.

Reader Method: skip ((str str))

If we can avoid testing for this
string because the SCAN function has done this already.

Source

regex-class.lisp.

Target Slot

skip.

Generic Writer: (setf skip) (object)
Package

cl-ppcre.

Methods
Writer Method: (setf skip) ((str str))

If we can avoid testing for this
string because the SCAN function has done this already.

Source

regex-class.lisp.

Target Slot

skip.

Generic Function: start-anchored-p (regex &optional in-seq-p)

Returns T if REGEX starts with a "real" start
anchor, i.e. one that’s not in multi-line mode, NIL otherwise. If IN-SEQ-P is true the function will return :ZERO-LENGTH if REGEX is a zero-length assertion.

Package

cl-ppcre.

Source

optimize.lisp.

Methods
Method: start-anchored-p ((regex regex) &optional in-seq-p)
Method: start-anchored-p ((anchor anchor) &optional in-seq-p)
Method: start-anchored-p ((standalone standalone) &optional in-seq-p)
Method: start-anchored-p ((register register) &optional in-seq-p)
Method: start-anchored-p ((repetition repetition) &optional in-seq-p)
Method: start-anchored-p ((branch branch) &optional in-seq-p)
Method: start-anchored-p ((alternation alternation) &optional in-seq-p)
Method: start-anchored-p ((seq seq) &optional in-seq-p)
Generic Function: start-of-end-string-p (object)
Package

cl-ppcre.

Methods
Method: start-of-end-string-p ((void void))
Source

regex-class-util.lisp.

Reader Method: start-of-end-string-p ((str str))

If this is the unique
STR which starts END-STRING (a slot of MATCHER).

Source

regex-class.lisp.

Target Slot

start-of-end-string-p.

Generic Writer: (setf start-of-end-string-p) (object)
Package

cl-ppcre.

Methods
Writer Method: (setf start-of-end-string-p) ((str str))

If this is the unique
STR which starts END-STRING (a slot of MATCHER).

Source

regex-class.lisp.

Target Slot

start-of-end-string-p.

Generic Reader: startp (object)
Package

cl-ppcre.

Methods
Reader Method: startp ((anchor anchor))

Whether this is a "start anchor".

Source

regex-class.lisp.

Target Slot

startp.

Generic Function: str (object)
Package

cl-ppcre.

Methods
Method: str ((void void))
Source

regex-class-util.lisp.

Reader Method: str ((str str))

The actual string.

Source

regex-class.lisp.

Target Slot

str.

Generic Writer: (setf str) (object)
Package

cl-ppcre.

Methods
Writer Method: (setf str) ((str str))

The actual string.

Source

regex-class.lisp.

Target Slot

str.

Generic Reader: test (object)
Generic Writer: (setf test) (object)
Package

cl-ppcre.

Methods
Reader Method: test ((branch branch))
Writer Method: (setf test) ((branch branch))

The test of this branch, one of LOOKAHEAD, LOOKBEHIND, or a number.

Source

regex-class.lisp.

Target Slot

test.

Generic Reader: test-function (object)
Package

cl-ppcre.

Methods
Reader Method: test-function ((char-class char-class))

A unary function (accepting a
character) which stands in for the character class and does the work of checking whether a character belongs to the class.

Source

regex-class.lisp.

Target Slot

test-function.

Generic Reader: then-regex (object)
Generic Writer: (setf then-regex) (object)
Package

cl-ppcre.

Methods
Reader Method: then-regex ((branch branch))
Writer Method: (setf then-regex) ((branch branch))

The regex that’s to be matched if the test succeeds.

Source

regex-class.lisp.

Target Slot

then-regex.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.6 Structures

Structure: charmap
Package

cl-ppcre.

Source

charmap.lisp.

Direct superclasses

structure-object.

Direct methods

make-load-form.

Direct slots
Slot: vector
Package

common-lisp.

Type

simple-bit-vector

Initform

#*0

Readers

charmap-vector.

Writers

(setf charmap-vector).

Slot: start
Type

fixnum

Initform

0

Readers

charmap-start.

Writers

(setf charmap-start).

Slot: end
Type

fixnum

Initform

0

Readers

charmap-end.

Writers

(setf charmap-end).

Slot: count
Package

common-lisp.

Type

(or fixnum null)

Readers

charmap-count.

Writers

(setf charmap-count).

Slot: complementp
Type

boolean

Readers

charmap-complementp.

Writers

(setf charmap-complementp).

Structure: charset
Package

cl-ppcre.

Source

charset.lisp.

Direct superclasses

structure-object.

Direct methods

make-load-form.

Direct slots
Slot: depth
Type

fixnum

Initform

cl-ppcre::+probe-depth+

Readers

charset-depth.

Writers

(setf charset-depth).

Slot: count
Package

common-lisp.

Type

fixnum

Initform

0

Readers

charset-count.

Writers

(setf charset-count).

Slot: vector
Package

common-lisp.

Type

(simple-array character (*))

Initform

(cl-ppcre::make-char-vector 12)

Readers

charset-vector.

Writers

(setf charset-vector).

Structure: lexer

LEXER structures are used to hold the regex string which is currently lexed and to keep track of the lexer’s state.

Package

cl-ppcre.

Source

lexer.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: str
Type

string

Initform

""

Readers

lexer-str.

Writers

This slot is read-only.

Slot: len
Type

fixnum

Initform

0

Readers

lexer-len.

Writers

This slot is read-only.

Slot: reg
Type

fixnum

Initform

0

Readers

lexer-reg.

Writers

(setf lexer-reg).

Slot: pos
Type

fixnum

Initform

0

Readers

lexer-pos.

Writers

(setf lexer-pos).

Slot: last-pos
Type

list

Readers

lexer-last-pos.

Writers

(setf lexer-last-pos).


Previous: , Up: Internals   [Contents][Index]

5.2.7 Classes

Class: alternation

ALTERNATION objects represent alternations of regexes. (Like "a|b" ist the alternation of "a" or "b".)

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: choices

A list of REGEX objects

Type

cons

Initargs

:choices

Readers

choices.

Writers

(setf choices).

Class: anchor

ANCHOR objects represent anchors like "^" or "$".

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: startp

Whether this is a "start anchor".

Initargs

:startp

Readers

startp.

Writers

This slot is read-only.

Slot: multi-line-p

Whether we’re in multi-line mode,
i.e. whether each #\Newline is surrounded by anchors.

Initargs

:multi-line-p

Readers

multi-line-p.

Writers

This slot is read-only.

Slot: no-newline-p

Whether we ignore #\Newline at the end.

Initargs

:no-newline-p

Readers

no-newline-p.

Writers

This slot is read-only.

Class: back-reference

BACK-REFERENCE objects represent backreferences.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: num

The number of the register this reference refers to.

Type

fixnum

Initargs

:num

Readers

num.

Writers

(setf num).

Slot: name

The name of the register this reference refers to or NIL.

Initargs

:name

Readers

name.

Writers

(setf name).

Slot: case-insensitive-p

Whether we check case-insensitively.

Initargs

:case-insensitive-p

Readers

case-insensitive-p.

Writers

This slot is read-only.

Class: branch

BRANCH objects represent Perl’s conditional regular expressions.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: test

The test of this branch, one of LOOKAHEAD, LOOKBEHIND, or a number.

Initargs

:test

Readers

test.

Writers

(setf test).

Slot: then-regex

The regex that’s to be matched if the test succeeds.

Initargs

:then-regex

Readers

then-regex.

Writers

(setf then-regex).

Slot: else-regex

The regex that’s to be matched if the test fails.

Initform

(make-instance (quote cl-ppcre::void))

Initargs

:else-regex

Readers

else-regex.

Writers

(setf else-regex).

Class: char-class

CHAR-CLASS objects represent character classes.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: test-function

A unary function (accepting a
character) which stands in for the character class and does the work of checking whether a character belongs to the class.

Type

(or function symbol nil)

Initargs

:test-function

Readers

test-function.

Writers

This slot is read-only.

Class: everything

EVERYTHING objects represent regexes matching "everything", i.e. dots.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: single-line-p

Whether we’re in single-line mode, i.e. whether we also match #\Newline.

Initargs

:single-line-p

Readers

single-line-p.

Writers

This slot is read-only.

Class: filter

FILTER objects represent arbitrary functions defined by the user.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: fn

The user-defined function.

Type

(or function symbol)

Initargs

:fn

Readers

fn.

Writers

(setf fn).

Slot: len

The fixed length of this filter or NIL.

Initargs

:len

Readers

len.

Writers

This slot is read-only.

Class: lookahead

LOOKAHEAD objects represent look-ahead assertions.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: regex

The REGEX object we’re checking.

Initargs

:regex

Readers

regex.

Writers

(setf regex).

Slot: positivep

Whether this assertion is positive.

Initargs

:positivep

Readers

positivep.

Writers

This slot is read-only.

Class: lookbehind

LOOKBEHIND objects represent look-behind assertions.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: regex

The REGEX object we’re checking.

Initargs

:regex

Readers

regex.

Writers

(setf regex).

Slot: positivep

Whether this assertion is positive.

Initargs

:positivep

Readers

positivep.

Writers

This slot is read-only.

Slot: len

The (fixed) length of the enclosed regex.

Type

fixnum

Initargs

:len

Readers

len.

Writers

(setf len).

Class: regex

The REGEX base class. All other classes inherit from this one.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct subclasses
Direct methods
Class: register

REGISTER objects represent register groups.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: regex

The inner regex.

Initargs

:regex

Readers

regex.

Writers

(setf regex).

Slot: num

The number of this register, starting from 0. This is the index into *REGS-START* and *REGS-END*.

Type

fixnum

Initargs

:num

Readers

num.

Writers

This slot is read-only.

Slot: name

Name of this register or NIL.

Initargs

:name

Readers

name.

Writers

This slot is read-only.

Class: repetition

REPETITION objects represent repetitions of regexes.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: regex

The REGEX that’s repeated.

Initargs

:regex

Readers

regex.

Writers

(setf regex).

Slot: greedyp

Whether the repetition is greedy.

Initargs

:greedyp

Readers

greedyp.

Writers

This slot is read-only.

Slot: minimum

The minimal number of repetitions.

Type

fixnum

Initargs

:minimum

Readers

minimum.

Writers

(setf minimum).

Slot: maximum

The maximal number of repetitions. Can be NIL for unbounded.

Initargs

:maximum

Readers

maximum.

Writers

(setf maximum).

Slot: min-len

The minimal length of the enclosed regex.

Initargs

:min-len

Readers

min-len.

Writers

This slot is read-only.

Slot: len

The length of the enclosed regex. NIL if unknown.

Initargs

:len

Readers

len.

Writers

This slot is read-only.

Slot: min-rest

The minimal number of characters which must appear after this repetition.

Type

fixnum

Initform

0

Readers

min-rest.

Writers

(setf min-rest).

Slot: contains-register-p

Whether the regex contains a register.

Initargs

:contains-register-p

Readers

contains-register-p.

Writers

This slot is read-only.

Class: seq

SEQ objects represents sequences of regexes. (Like "ab" is the sequence of "a" and "b".)

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: elements

A list of REGEX objects.

Type

cons

Initargs

:elements

Readers

elements.

Writers

(setf elements).

Class: standalone

A standalone regular expression.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: regex

The inner regex.

Initargs

:regex

Readers

regex.

Writers

(setf regex).

Class: str

STR objects represent string.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: str

The actual string.

Type

string

Initargs

:str

Readers

str.

Writers

(setf str).

Slot: len

The length of the string.

Type

fixnum

Initform

0

Readers

len.

Writers

(setf len).

Slot: case-insensitive-p

If we match case-insensitively.

Initargs

:case-insensitive-p

Readers

case-insensitive-p.

Writers

This slot is read-only.

Slot: offset

Offset from the left of the whole
parse tree. The first regex has offset 0. NIL if unknown, i.e. behind a variable-length regex.

Readers

offset.

Writers

(setf offset).

Slot: skip

If we can avoid testing for this
string because the SCAN function has done this already.

Initargs

:skip

Readers

skip.

Writers

(setf skip).

Slot: start-of-end-string-p

If this is the unique
STR which starts END-STRING (a slot of MATCHER).

Readers

start-of-end-string-p.

Writers

(setf start-of-end-string-p).

Class: void

VOID objects represent empty regular expressions.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Class: word-boundary

WORD-BOUNDARY objects represent word-boundary assertions.

Package

cl-ppcre.

Source

regex-class.lisp.

Direct superclasses

regex.

Direct methods
Direct slots
Slot: negatedp

Whether we mean the opposite, i.e. no word-boundary.

Initargs

:negatedp

Readers

negatedp.

Writers

This slot is read-only.


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (   *  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   Q   R   S   T   U   W  
Index Entry  Section

%
%add-to-charset: Private ordinary functions
%add-to-charset/expand: Private ordinary functions

(
(setf charmap-complementp): Private ordinary functions
(setf charmap-count): Private ordinary functions
(setf charmap-end): Private ordinary functions
(setf charmap-start): Private ordinary functions
(setf charmap-vector): Private ordinary functions
(setf charset-count): Private ordinary functions
(setf charset-depth): Private ordinary functions
(setf charset-vector): Private ordinary functions
(setf choices): Private generic functions
(setf choices): Private generic functions
(setf elements): Private generic functions
(setf elements): Private generic functions
(setf else-regex): Private generic functions
(setf else-regex): Private generic functions
(setf fn): Private generic functions
(setf fn): Private generic functions
(setf len): Private generic functions
(setf len): Private generic functions
(setf len): Private generic functions
(setf lexer-last-pos): Private ordinary functions
(setf lexer-pos): Private ordinary functions
(setf lexer-reg): Private ordinary functions
(setf maximum): Private generic functions
(setf maximum): Private generic functions
(setf min-rest): Private generic functions
(setf min-rest): Private generic functions
(setf minimum): Private generic functions
(setf minimum): Private generic functions
(setf name): Private generic functions
(setf name): Private generic functions
(setf num): Private generic functions
(setf num): Private generic functions
(setf offset): Private generic functions
(setf offset): Private generic functions
(setf parse-tree-synonym): Public ordinary functions
(setf regex): Private generic functions
(setf regex): Private generic functions
(setf regex): Private generic functions
(setf regex): Private generic functions
(setf regex): Private generic functions
(setf regex): Private generic functions
(setf skip): Private generic functions
(setf skip): Private generic functions
(setf start-of-end-string-p): Private generic functions
(setf start-of-end-string-p): Private generic functions
(setf str): Private generic functions
(setf str): Private generic functions
(setf test): Private generic functions
(setf test): Private generic functions
(setf then-regex): Private generic functions
(setf then-regex): Private generic functions

*
*string*-equal: Private ordinary functions
*string*=: Private ordinary functions

A
add-to-charset: Private ordinary functions
all-matches: Public compiler macros
all-matches: Public ordinary functions
all-matches-as-strings: Public compiler macros
all-matches-as-strings: Public ordinary functions

B
bmh-matcher-aux: Private macros
build-replacement: Private ordinary functions
build-replacement-template: Private generic functions
build-replacement-template: Private generic functions
build-replacement-template: Private generic functions
build-replacement-template: Private generic functions
build-replacement-template: Private generic functions

C
case-insensitive-mode-p: Private macros
case-insensitive-p: Private generic functions
case-insensitive-p: Private generic functions
case-insensitive-p: Private generic functions
case-mode: Private generic functions
case-mode: Private generic functions
case-mode: Private generic functions
char-searcher-aux: Private macros
charmap-complementp: Private ordinary functions
charmap-contents: Private ordinary functions
charmap-count: Private ordinary functions
charmap-end: Private ordinary functions
charmap-p: Private ordinary functions
charmap-start: Private ordinary functions
charmap-vector: Private ordinary functions
charset-count: Private ordinary functions
charset-depth: Private ordinary functions
charset-p: Private ordinary functions
charset-vector: Private ordinary functions
choices: Private generic functions
choices: Private generic functions
clean-comments: Private ordinary functions
collect-char-class: Private ordinary functions
Compiler Macro, all-matches: Public compiler macros
Compiler Macro, all-matches-as-strings: Public compiler macros
Compiler Macro, count-matches: Public compiler macros
Compiler Macro, regex-replace: Public compiler macros
Compiler Macro, regex-replace-all: Public compiler macros
Compiler Macro, scan: Public compiler macros
Compiler Macro, scan-to-strings: Public compiler macros
Compiler Macro, split: Public compiler macros
complement*: Private ordinary functions
compute-index: Private ordinary functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-min-rest: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
compute-offsets: Private generic functions
constant-repetition-constant-length-closure: Private macros
contains-register-p: Private generic functions
contains-register-p: Private generic functions
convert: Private ordinary functions
convert-aux: Private ordinary functions
convert-char-class-to-test-function: Private ordinary functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-compound-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
convert-simple-parse-tree: Private generic functions
copy-charmap: Private ordinary functions
copy-charset: Private ordinary functions
copy-lexer: Private ordinary functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
copy-regex: Private generic functions
count-matches: Public compiler macros
count-matches: Public ordinary functions
create-bmh-matcher: Private ordinary functions
create-char-searcher: Private ordinary functions
create-charmap-from-test-function: Private ordinary functions
create-charset-from-test-function: Private ordinary functions
create-constant-repetition-constant-length-matcher: Private generic functions
create-constant-repetition-constant-length-matcher: Private generic functions
create-constant-repetition-matcher: Private generic functions
create-constant-repetition-matcher: Private generic functions
create-greedy-constant-length-matcher: Private generic functions
create-greedy-constant-length-matcher: Private generic functions
create-greedy-everything-matcher: Private ordinary functions
create-greedy-matcher: Private generic functions
create-greedy-matcher: Private generic functions
create-greedy-no-zero-matcher: Private generic functions
create-greedy-no-zero-matcher: Private generic functions
create-hash-table-from-test-function: Private ordinary functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-matcher-aux: Private generic functions
create-non-greedy-constant-length-matcher: Private generic functions
create-non-greedy-constant-length-matcher: Private generic functions
create-non-greedy-matcher: Private generic functions
create-non-greedy-matcher: Private generic functions
create-non-greedy-no-zero-matcher: Private generic functions
create-non-greedy-no-zero-matcher: Private generic functions
create-optimized-test-function: Public ordinary functions
create-scanner: Public generic functions
create-scanner: Public generic functions
create-scanner: Public generic functions
create-scanner: Public generic functions
create-scanner-aux: Private ordinary functions

D
defconstant: Private macros
define-parse-tree-synonym: Public macros
digit-char-p: Private ordinary functions
do-matches: Public macros
do-matches-as-strings: Public macros
do-register-groups: Public macros
do-scans: Public macros

E
elements: Private generic functions
elements: Private generic functions
else-regex: Private generic functions
else-regex: Private generic functions
end-of-string-p: Private ordinary functions
end-string: Private ordinary functions
end-string-aux: Private generic functions
end-string-aux: Private generic functions
end-string-aux: Private generic functions
end-string-aux: Private generic functions
end-string-aux: Private generic functions
end-string-aux: Private generic functions
everythingp: Private generic functions
everythingp: Private generic functions
everythingp: Private generic functions
everythingp: Private generic functions
everythingp: Private generic functions
everythingp: Private generic functions
everythingp: Private generic functions
everythingp: Private generic functions

F
fail: Private ordinary functions
flatten: Private generic functions
flatten: Private generic functions
flatten: Private generic functions
flatten: Private generic functions
flatten: Private generic functions
fn: Private generic functions
fn: Private generic functions
Function, %add-to-charset: Private ordinary functions
Function, %add-to-charset/expand: Private ordinary functions
Function, (setf charmap-complementp): Private ordinary functions
Function, (setf charmap-count): Private ordinary functions
Function, (setf charmap-end): Private ordinary functions
Function, (setf charmap-start): Private ordinary functions
Function, (setf charmap-vector): Private ordinary functions
Function, (setf charset-count): Private ordinary functions
Function, (setf charset-depth): Private ordinary functions
Function, (setf charset-vector): Private ordinary functions
Function, (setf lexer-last-pos): Private ordinary functions
Function, (setf lexer-pos): Private ordinary functions
Function, (setf lexer-reg): Private ordinary functions
Function, (setf parse-tree-synonym): Public ordinary functions
Function, *string*-equal: Private ordinary functions
Function, *string*=: Private ordinary functions
Function, add-to-charset: Private ordinary functions
Function, all-matches: Public ordinary functions
Function, all-matches-as-strings: Public ordinary functions
Function, build-replacement: Private ordinary functions
Function, charmap-complementp: Private ordinary functions
Function, charmap-contents: Private ordinary functions
Function, charmap-count: Private ordinary functions
Function, charmap-end: Private ordinary functions
Function, charmap-p: Private ordinary functions
Function, charmap-start: Private ordinary functions
Function, charmap-vector: Private ordinary functions
Function, charset-count: Private ordinary functions
Function, charset-depth: Private ordinary functions
Function, charset-p: Private ordinary functions
Function, charset-vector: Private ordinary functions
Function, clean-comments: Private ordinary functions
Function, collect-char-class: Private ordinary functions
Function, complement*: Private ordinary functions
Function, compute-index: Private ordinary functions
Function, convert: Private ordinary functions
Function, convert-aux: Private ordinary functions
Function, convert-char-class-to-test-function: Private ordinary functions
Function, copy-charmap: Private ordinary functions
Function, copy-charset: Private ordinary functions
Function, copy-lexer: Private ordinary functions
Function, count-matches: Public ordinary functions
Function, create-bmh-matcher: Private ordinary functions
Function, create-char-searcher: Private ordinary functions
Function, create-charmap-from-test-function: Private ordinary functions
Function, create-charset-from-test-function: Private ordinary functions
Function, create-greedy-everything-matcher: Private ordinary functions
Function, create-hash-table-from-test-function: Private ordinary functions
Function, create-optimized-test-function: Public ordinary functions
Function, create-scanner-aux: Private ordinary functions
Function, digit-char-p: Private ordinary functions
Function, end-of-string-p: Private ordinary functions
Function, end-string: Private ordinary functions
Function, fail: Private ordinary functions
Function, get-number: Private ordinary functions
Function, get-quantifier: Private ordinary functions
Function, get-token: Private ordinary functions
Function, greedy-quant: Private ordinary functions
Function, group: Private ordinary functions
Function, hyperdoc-lookup: Private ordinary functions
Function, in-charmap-p: Private ordinary functions
Function, in-charset-p: Private ordinary functions
Function, lexer-last-pos: Private ordinary functions
Function, lexer-len: Private ordinary functions
Function, lexer-p: Private ordinary functions
Function, lexer-pos: Private ordinary functions
Function, lexer-reg: Private ordinary functions
Function, lexer-str: Private ordinary functions
Function, looking-at-p: Private ordinary functions
Function, make-char-from-code: Private ordinary functions
Function, make-char-vector: Private ordinary functions
Function, make-charmap: Private ordinary functions
Function, make-charmap%: Private ordinary functions
Function, make-charset: Private ordinary functions
Function, make-lexer: Private ordinary functions
Function, make-lexer-internal: Private ordinary functions
Function, map-char-to-special-char-class: Private ordinary functions
Function, map-charset: Private ordinary functions
Function, maybe-accumulate: Private ordinary functions
Function, maybe-parse-flags: Private ordinary functions
Function, maybe-split-repetition: Private ordinary functions
Function, mix: Private ordinary functions
Function, newline-skipper: Private ordinary functions
Function, next-char: Private ordinary functions
Function, next-char-non-extended: Private ordinary functions
Function, normalize-var-list: Private ordinary functions
Function, nsubseq: Private ordinary functions
Function, parse-register-name-aux: Private ordinary functions
Function, parse-string: Public ordinary functions
Function, parse-tree-synonym: Public ordinary functions
Function, print-symbol-info: Private ordinary functions
Function, quant: Private ordinary functions
Function, quote-meta-chars: Public ordinary functions
Function, quote-sections: Private ordinary functions
Function, read-char-property: Private ordinary functions
Function, reg-expr: Private ordinary functions
Function, regex-apropos: Public ordinary functions
Function, regex-apropos-list: Public ordinary functions
Function, regex-replace: Public ordinary functions
Function, regex-replace-all: Public ordinary functions
Function, replace-aux: Private ordinary functions
Function, scan-to-strings: Public ordinary functions
Function, seq: Private ordinary functions
Function, set-flag: Private ordinary functions
Function, split: Public ordinary functions
Function, start-of-subexpr-p: Private ordinary functions
Function, string-case-modifier: Private ordinary functions
Function, string-list-to-simple-string: Private ordinary functions
Function, try-number: Private ordinary functions
Function, unescape-char: Private ordinary functions
Function, unget-token: Private ordinary functions
Function, whitespacep: Private ordinary functions
Function, word-boundary-p: Private ordinary functions
Function, word-char-p: Private ordinary functions

G
gather-strings: Private generic functions
gather-strings: Private generic functions
gather-strings: Private generic functions
gather-strings: Private generic functions
gather-strings: Private generic functions
Generic Function, (setf choices): Private generic functions
Generic Function, (setf elements): Private generic functions
Generic Function, (setf else-regex): Private generic functions
Generic Function, (setf fn): Private generic functions
Generic Function, (setf len): Private generic functions
Generic Function, (setf maximum): Private generic functions
Generic Function, (setf min-rest): Private generic functions
Generic Function, (setf minimum): Private generic functions
Generic Function, (setf name): Private generic functions
Generic Function, (setf num): Private generic functions
Generic Function, (setf offset): Private generic functions
Generic Function, (setf regex): Private generic functions
Generic Function, (setf skip): Private generic functions
Generic Function, (setf start-of-end-string-p): Private generic functions
Generic Function, (setf str): Private generic functions
Generic Function, (setf test): Private generic functions
Generic Function, (setf then-regex): Private generic functions
Generic Function, build-replacement-template: Private generic functions
Generic Function, case-insensitive-p: Private generic functions
Generic Function, case-mode: Private generic functions
Generic Function, choices: Private generic functions
Generic Function, compute-min-rest: Private generic functions
Generic Function, compute-offsets: Private generic functions
Generic Function, contains-register-p: Private generic functions
Generic Function, convert-compound-parse-tree: Private generic functions
Generic Function, convert-simple-parse-tree: Private generic functions
Generic Function, copy-regex: Private generic functions
Generic Function, create-constant-repetition-constant-length-matcher: Private generic functions
Generic Function, create-constant-repetition-matcher: Private generic functions
Generic Function, create-greedy-constant-length-matcher: Private generic functions
Generic Function, create-greedy-matcher: Private generic functions
Generic Function, create-greedy-no-zero-matcher: Private generic functions
Generic Function, create-matcher-aux: Private generic functions
Generic Function, create-non-greedy-constant-length-matcher: Private generic functions
Generic Function, create-non-greedy-matcher: Private generic functions
Generic Function, create-non-greedy-no-zero-matcher: Private generic functions
Generic Function, create-scanner: Public generic functions
Generic Function, elements: Private generic functions
Generic Function, else-regex: Private generic functions
Generic Function, end-string-aux: Private generic functions
Generic Function, everythingp: Private generic functions
Generic Function, flatten: Private generic functions
Generic Function, fn: Private generic functions
Generic Function, gather-strings: Private generic functions
Generic Function, greedyp: Private generic functions
Generic Function, len: Private generic functions
Generic Function, maximum: Private generic functions
Generic Function, min-len: Private generic functions
Generic Function, min-rest: Private generic functions
Generic Function, minimum: Private generic functions
Generic Function, multi-line-p: Private generic functions
Generic Function, name: Private generic functions
Generic Function, negatedp: Private generic functions
Generic Function, no-newline-p: Private generic functions
Generic Function, num: Private generic functions
Generic Function, offset: Private generic functions
Generic Function, positivep: Private generic functions
Generic Function, ppcre-syntax-error-pos: Public generic functions
Generic Function, ppcre-syntax-error-string: Public generic functions
Generic Function, regex: Private generic functions
Generic Function, regex-length: Private generic functions
Generic Function, regex-min-length: Private generic functions
Generic Function, remove-registers: Private generic functions
Generic Function, resolve-property: Private generic functions
Generic Function, scan: Public generic functions
Generic Function, single-line-p: Private generic functions
Generic Function, skip: Private generic functions
Generic Function, start-anchored-p: Private generic functions
Generic Function, start-of-end-string-p: Private generic functions
Generic Function, startp: Private generic functions
Generic Function, str: Private generic functions
Generic Function, test: Private generic functions
Generic Function, test-function: Private generic functions
Generic Function, then-regex: Private generic functions
get-number: Private ordinary functions
get-quantifier: Private ordinary functions
get-token: Private ordinary functions
greedy-constant-length-closure: Private macros
greedy-quant: Private ordinary functions
greedyp: Private generic functions
greedyp: Private generic functions
group: Private ordinary functions

H
hyperdoc-lookup: Private ordinary functions

I
in-charmap-p: Private ordinary functions
in-charset-p: Private ordinary functions
incf-after: Private macros
initialize-instance: Public standalone methods
insert-advance-fn: Private macros
insert-char-class-tester: Private macros

L
len: Private generic functions
len: Private generic functions
len: Private generic functions
len: Private generic functions
len: Private generic functions
len: Private generic functions
lexer-last-pos: Private ordinary functions
lexer-len: Private ordinary functions
lexer-p: Private ordinary functions
lexer-pos: Private ordinary functions
lexer-reg: Private ordinary functions
lexer-str: Private ordinary functions
looking-at-p: Private ordinary functions

M
Macro, bmh-matcher-aux: Private macros
Macro, case-insensitive-mode-p: Private macros
Macro, char-searcher-aux: Private macros
Macro, constant-repetition-constant-length-closure: Private macros
Macro, defconstant: Private macros
Macro, define-parse-tree-synonym: Public macros
Macro, do-matches: Public macros
Macro, do-matches-as-strings: Public macros
Macro, do-register-groups: Public macros
Macro, do-scans: Public macros
Macro, greedy-constant-length-closure: Private macros
Macro, incf-after: Private macros
Macro, insert-advance-fn: Private macros
Macro, insert-char-class-tester: Private macros
Macro, maybe-coerce-to-simple-string: Private macros
Macro, multi-line-mode-p: Private macros
Macro, non-greedy-constant-length-closure: Private macros
Macro, regex-apropos-aux: Private macros
Macro, register-groups-bind: Public macros
Macro, signal-invocation-error: Private macros
Macro, signal-syntax-error: Private macros
Macro, signal-syntax-error*: Private macros
Macro, single-line-mode-p: Private macros
Macro, with-rebinding: Private macros
Macro, with-unique-names: Private macros
make-char-from-code: Private ordinary functions
make-char-vector: Private ordinary functions
make-charmap: Private ordinary functions
make-charmap%: Private ordinary functions
make-charset: Private ordinary functions
make-lexer: Private ordinary functions
make-lexer-internal: Private ordinary functions
make-load-form: Public standalone methods
make-load-form: Public standalone methods
map-char-to-special-char-class: Private ordinary functions
map-charset: Private ordinary functions
maximum: Private generic functions
maximum: Private generic functions
maybe-accumulate: Private ordinary functions
maybe-coerce-to-simple-string: Private macros
maybe-parse-flags: Private ordinary functions
maybe-split-repetition: Private ordinary functions
Method, (setf choices): Private generic functions
Method, (setf elements): Private generic functions
Method, (setf else-regex): Private generic functions
Method, (setf fn): Private generic functions
Method, (setf len): Private generic functions
Method, (setf len): Private generic functions
Method, (setf maximum): Private generic functions
Method, (setf min-rest): Private generic functions
Method, (setf minimum): Private generic functions
Method, (setf name): Private generic functions
Method, (setf num): Private generic functions
Method, (setf offset): Private generic functions
Method, (setf regex): Private generic functions
Method, (setf regex): Private generic functions
Method, (setf regex): Private generic functions
Method, (setf regex): Private generic functions
Method, (setf regex): Private generic functions
Method, (setf skip): Private generic functions
Method, (setf start-of-end-string-p): Private generic functions
Method, (setf str): Private generic functions
Method, (setf test): Private generic functions
Method, (setf then-regex): Private generic functions
Method, build-replacement-template: Private generic functions
Method, build-replacement-template: Private generic functions
Method, build-replacement-template: Private generic functions
Method, build-replacement-template: Private generic functions
Method, case-insensitive-p: Private generic functions
Method, case-insensitive-p: Private generic functions
Method, case-mode: Private generic functions
Method, case-mode: Private generic functions
Method, choices: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-min-rest: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, compute-offsets: Private generic functions
Method, contains-register-p: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-compound-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, convert-simple-parse-tree: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, copy-regex: Private generic functions
Method, create-constant-repetition-constant-length-matcher: Private generic functions
Method, create-constant-repetition-matcher: Private generic functions
Method, create-greedy-constant-length-matcher: Private generic functions
Method, create-greedy-matcher: Private generic functions
Method, create-greedy-no-zero-matcher: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-matcher-aux: Private generic functions
Method, create-non-greedy-constant-length-matcher: Private generic functions
Method, create-non-greedy-matcher: Private generic functions
Method, create-non-greedy-no-zero-matcher: Private generic functions
Method, create-scanner: Public generic functions
Method, create-scanner: Public generic functions
Method, create-scanner: Public generic functions
Method, elements: Private generic functions
Method, else-regex: Private generic functions
Method, end-string-aux: Private generic functions
Method, end-string-aux: Private generic functions
Method, end-string-aux: Private generic functions
Method, end-string-aux: Private generic functions
Method, end-string-aux: Private generic functions
Method, everythingp: Private generic functions
Method, everythingp: Private generic functions
Method, everythingp: Private generic functions
Method, everythingp: Private generic functions
Method, everythingp: Private generic functions
Method, everythingp: Private generic functions
Method, everythingp: Private generic functions
Method, flatten: Private generic functions
Method, flatten: Private generic functions
Method, flatten: Private generic functions
Method, flatten: Private generic functions
Method, fn: Private generic functions
Method, gather-strings: Private generic functions
Method, gather-strings: Private generic functions
Method, gather-strings: Private generic functions
Method, gather-strings: Private generic functions
Method, greedyp: Private generic functions
Method, initialize-instance: Public standalone methods
Method, len: Private generic functions
Method, len: Private generic functions
Method, len: Private generic functions
Method, len: Private generic functions
Method, len: Private generic functions
Method, make-load-form: Public standalone methods
Method, make-load-form: Public standalone methods
Method, maximum: Private generic functions
Method, min-len: Private generic functions
Method, min-rest: Private generic functions
Method, minimum: Private generic functions
Method, multi-line-p: Private generic functions
Method, name: Private generic functions
Method, name: Private generic functions
Method, negatedp: Private generic functions
Method, no-newline-p: Private generic functions
Method, num: Private generic functions
Method, num: Private generic functions
Method, offset: Private generic functions
Method, positivep: Private generic functions
Method, positivep: Private generic functions
Method, ppcre-syntax-error-pos: Public generic functions
Method, ppcre-syntax-error-string: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, regex: Private generic functions
Method, regex: Private generic functions
Method, regex: Private generic functions
Method, regex: Private generic functions
Method, regex: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, regex-min-length: Private generic functions
Method, remove-registers: Private generic functions
Method, remove-registers: Private generic functions
Method, remove-registers: Private generic functions
Method, remove-registers: Private generic functions
Method, remove-registers: Private generic functions
Method, remove-registers: Private generic functions
Method, remove-registers: Private generic functions
Method, remove-registers: Private generic functions
Method, remove-registers: Private generic functions
Method, resolve-property: Private generic functions
Method, resolve-property: Private generic functions
Method, resolve-property: Private generic functions
Method, scan: Public generic functions
Method, scan: Public generic functions
Method, scan: Public generic functions
Method, single-line-p: Private generic functions
Method, skip: Private generic functions
Method, skip: Private generic functions
Method, start-anchored-p: Private generic functions
Method, start-anchored-p: Private generic functions
Method, start-anchored-p: Private generic functions
Method, start-anchored-p: Private generic functions
Method, start-anchored-p: Private generic functions
Method, start-anchored-p: Private generic functions
Method, start-anchored-p: Private generic functions
Method, start-anchored-p: Private generic functions
Method, start-of-end-string-p: Private generic functions
Method, start-of-end-string-p: Private generic functions
Method, startp: Private generic functions
Method, str: Private generic functions
Method, str: Private generic functions
Method, test: Private generic functions
Method, test-function: Private generic functions
Method, then-regex: Private generic functions
min-len: Private generic functions
min-len: Private generic functions
min-rest: Private generic functions
min-rest: Private generic functions
minimum: Private generic functions
minimum: Private generic functions
mix: Private ordinary functions
multi-line-mode-p: Private macros
multi-line-p: Private generic functions
multi-line-p: Private generic functions

N
name: Private generic functions
name: Private generic functions
name: Private generic functions
negatedp: Private generic functions
negatedp: Private generic functions
newline-skipper: Private ordinary functions
next-char: Private ordinary functions
next-char-non-extended: Private ordinary functions
no-newline-p: Private generic functions
no-newline-p: Private generic functions
non-greedy-constant-length-closure: Private macros
normalize-var-list: Private ordinary functions
nsubseq: Private ordinary functions
num: Private generic functions
num: Private generic functions
num: Private generic functions

O
offset: Private generic functions
offset: Private generic functions

P
parse-register-name-aux: Private ordinary functions
parse-string: Public ordinary functions
parse-tree-synonym: Public ordinary functions
positivep: Private generic functions
positivep: Private generic functions
positivep: Private generic functions
ppcre-syntax-error-pos: Public generic functions
ppcre-syntax-error-pos: Public generic functions
ppcre-syntax-error-string: Public generic functions
ppcre-syntax-error-string: Public generic functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-symbol-info: Private ordinary functions

Q
quant: Private ordinary functions
quote-meta-chars: Public ordinary functions
quote-sections: Private ordinary functions

R
read-char-property: Private ordinary functions
reg-expr: Private ordinary functions
regex: Private generic functions
regex: Private generic functions
regex: Private generic functions
regex: Private generic functions
regex: Private generic functions
regex: Private generic functions
regex-apropos: Public ordinary functions
regex-apropos-aux: Private macros
regex-apropos-list: Public ordinary functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-min-length: Private generic functions
regex-replace: Public compiler macros
regex-replace: Public ordinary functions
regex-replace-all: Public compiler macros
regex-replace-all: Public ordinary functions
register-groups-bind: Public macros
remove-registers: Private generic functions
remove-registers: Private generic functions
remove-registers: Private generic functions
remove-registers: Private generic functions
remove-registers: Private generic functions
remove-registers: Private generic functions
remove-registers: Private generic functions
remove-registers: Private generic functions
remove-registers: Private generic functions
remove-registers: Private generic functions
replace-aux: Private ordinary functions
resolve-property: Private generic functions
resolve-property: Private generic functions
resolve-property: Private generic functions
resolve-property: Private generic functions

S
scan: Public compiler macros
scan: Public generic functions
scan: Public generic functions
scan: Public generic functions
scan: Public generic functions
scan-to-strings: Public compiler macros
scan-to-strings: Public ordinary functions
seq: Private ordinary functions
set-flag: Private ordinary functions
signal-invocation-error: Private macros
signal-syntax-error: Private macros
signal-syntax-error*: Private macros
single-line-mode-p: Private macros
single-line-p: Private generic functions
single-line-p: Private generic functions
skip: Private generic functions
skip: Private generic functions
skip: Private generic functions
split: Public compiler macros
split: Public ordinary functions
start-anchored-p: Private generic functions
start-anchored-p: Private generic functions
start-anchored-p: Private generic functions
start-anchored-p: Private generic functions
start-anchored-p: Private generic functions
start-anchored-p: Private generic functions
start-anchored-p: Private generic functions
start-anchored-p: Private generic functions
start-anchored-p: Private generic functions
start-of-end-string-p: Private generic functions
start-of-end-string-p: Private generic functions
start-of-end-string-p: Private generic functions
start-of-subexpr-p: Private ordinary functions
startp: Private generic functions
startp: Private generic functions
str: Private generic functions
str: Private generic functions
str: Private generic functions
string-case-modifier: Private ordinary functions
string-list-to-simple-string: Private ordinary functions

T
test: Private generic functions
test: Private generic functions
test-function: Private generic functions
test-function: Private generic functions
then-regex: Private generic functions
then-regex: Private generic functions
try-number: Private ordinary functions

U
unescape-char: Private ordinary functions
unget-token: Private ordinary functions

W
whitespacep: Private ordinary functions
with-rebinding: Private macros
with-unique-names: Private macros
word-boundary-p: Private ordinary functions
word-char-p: Private ordinary functions

Jump to:   %   (   *  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   Q   R   S   T   U   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
C   D   E   F   G   L   M   N   O   P   R   S   T   V  
Index Entry  Section

*
*allow-named-registers*: Public special variables
*allow-quoting*: Public special variables
*end-pos*: Private special variables
*end-string-pos*: Private special variables
*extended-mode-p*: Private special variables
*hyperdoc-base-uri*: Private special variables
*last-pos-stores*: Private special variables
*look-ahead-for-suffix*: Public special variables
*optimize-char-classes*: Public special variables
*property-resolver*: Public special variables
*real-start-pos*: Private special variables
*reg-ends*: Private special variables
*reg-starts*: Private special variables
*regex-char-code-limit*: Public special variables
*regs-maybe-start*: Private special variables
*rep-num*: Private special variables
*repeat-counters*: Private special variables
*special-optimize-settings*: Private special variables
*standard-optimize-settings*: Private special variables
*start-pos*: Private special variables
*string*: Private special variables
*syntax-error-string*: Private special variables
*use-bmh-matchers*: Public special variables
*zero-length-num*: Private special variables

+
+probe-depth+: Private constants
+whitespace-char-string+: Private constants

C
case-insensitive-p: Private classes
case-insensitive-p: Private classes
choices: Private classes
complementp: Private structures
Constant, +probe-depth+: Private constants
Constant, +whitespace-char-string+: Private constants
contains-register-p: Private classes
count: Private structures
count: Private structures

D
depth: Private structures

E
elements: Private classes
else-regex: Private classes
end: Private structures

F
fn: Private classes

G
greedyp: Private classes

L
last-pos: Private structures
len: Private structures
len: Private classes
len: Private classes
len: Private classes
len: Private classes

M
maximum: Private classes
min-len: Private classes
min-rest: Private classes
minimum: Private classes
multi-line-p: Private classes

N
name: Private classes
name: Private classes
negatedp: Private classes
no-newline-p: Private classes
num: Private classes
num: Private classes

O
offset: Private classes

P
pos: Public conditions
pos: Private structures
positivep: Private classes
positivep: Private classes

R
reg: Private structures
regex: Private classes
regex: Private classes
regex: Private classes
regex: Private classes
regex: Private classes

S
single-line-p: Private classes
skip: Private classes
Slot, case-insensitive-p: Private classes
Slot, case-insensitive-p: Private classes
Slot, choices: Private classes
Slot, complementp: Private structures
Slot, contains-register-p: Private classes
Slot, count: Private structures
Slot, count: Private structures
Slot, depth: Private structures
Slot, elements: Private classes
Slot, else-regex: Private classes
Slot, end: Private structures
Slot, fn: Private classes
Slot, greedyp: Private classes
Slot, last-pos: Private structures
Slot, len: Private structures
Slot, len: Private classes
Slot, len: Private classes
Slot, len: Private classes
Slot, len: Private classes
Slot, maximum: Private classes
Slot, min-len: Private classes
Slot, min-rest: Private classes
Slot, minimum: Private classes
Slot, multi-line-p: Private classes
Slot, name: Private classes
Slot, name: Private classes
Slot, negatedp: Private classes
Slot, no-newline-p: Private classes
Slot, num: Private classes
Slot, num: Private classes
Slot, offset: Private classes
Slot, pos: Public conditions
Slot, pos: Private structures
Slot, positivep: Private classes
Slot, positivep: Private classes
Slot, reg: Private structures
Slot, regex: Private classes
Slot, regex: Private classes
Slot, regex: Private classes
Slot, regex: Private classes
Slot, regex: Private classes
Slot, single-line-p: Private classes
Slot, skip: Private classes
Slot, start: Private structures
Slot, start-of-end-string-p: Private classes
Slot, startp: Private classes
Slot, str: Private structures
Slot, str: Private classes
Slot, string: Public conditions
Slot, test: Private classes
Slot, test-function: Private classes
Slot, then-regex: Private classes
Slot, vector: Private structures
Slot, vector: Private structures
Special Variable, *allow-named-registers*: Public special variables
Special Variable, *allow-quoting*: Public special variables
Special Variable, *end-pos*: Private special variables
Special Variable, *end-string-pos*: Private special variables
Special Variable, *extended-mode-p*: Private special variables
Special Variable, *hyperdoc-base-uri*: Private special variables
Special Variable, *last-pos-stores*: Private special variables
Special Variable, *look-ahead-for-suffix*: Public special variables
Special Variable, *optimize-char-classes*: Public special variables
Special Variable, *property-resolver*: Public special variables
Special Variable, *real-start-pos*: Private special variables
Special Variable, *reg-ends*: Private special variables
Special Variable, *reg-starts*: Private special variables
Special Variable, *regex-char-code-limit*: Public special variables
Special Variable, *regs-maybe-start*: Private special variables
Special Variable, *rep-num*: Private special variables
Special Variable, *repeat-counters*: Private special variables
Special Variable, *special-optimize-settings*: Private special variables
Special Variable, *standard-optimize-settings*: Private special variables
Special Variable, *start-pos*: Private special variables
Special Variable, *string*: Private special variables
Special Variable, *syntax-error-string*: Private special variables
Special Variable, *use-bmh-matchers*: Public special variables
Special Variable, *zero-length-num*: Private special variables
start: Private structures
start-of-end-string-p: Private classes
startp: Private classes
str: Private structures
str: Private classes
string: Public conditions

T
test: Private classes
test-function: Private classes
then-regex: Private classes

V
vector: Private structures
vector: Private structures

Jump to:   *   +  
C   D   E   F   G   L   M   N   O   P   R   S   T   V  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   B   C   E   F   L   O   P   R   S   U   V   W  
Index Entry  Section

A
alternation: Private classes
anchor: Private classes
api.lisp: The cl-ppcre/api․lisp file

B
back-reference: Private classes
branch: Private classes

C
char-class: Private classes
charmap: Private structures
charmap.lisp: The cl-ppcre/charmap․lisp file
charset: Private structures
charset.lisp: The cl-ppcre/charset․lisp file
chartest.lisp: The cl-ppcre/chartest․lisp file
cl-ppcre: The cl-ppcre system
cl-ppcre: The cl-ppcre package
cl-ppcre.asd: The cl-ppcre/cl-ppcre․asd file
Class, alternation: Private classes
Class, anchor: Private classes
Class, back-reference: Private classes
Class, branch: Private classes
Class, char-class: Private classes
Class, everything: Private classes
Class, filter: Private classes
Class, lookahead: Private classes
Class, lookbehind: Private classes
Class, regex: Private classes
Class, register: Private classes
Class, repetition: Private classes
Class, seq: Private classes
Class, standalone: Private classes
Class, str: Private classes
Class, void: Private classes
Class, word-boundary: Private classes
closures.lisp: The cl-ppcre/closures․lisp file
Condition, ppcre-error: Public conditions
Condition, ppcre-invocation-error: Public conditions
Condition, ppcre-syntax-error: Public conditions
convert.lisp: The cl-ppcre/convert․lisp file

E
errors.lisp: The cl-ppcre/errors․lisp file
everything: Private classes

F
File, api.lisp: The cl-ppcre/api․lisp file
File, charmap.lisp: The cl-ppcre/charmap․lisp file
File, charset.lisp: The cl-ppcre/charset․lisp file
File, chartest.lisp: The cl-ppcre/chartest․lisp file
File, cl-ppcre.asd: The cl-ppcre/cl-ppcre․asd file
File, closures.lisp: The cl-ppcre/closures․lisp file
File, convert.lisp: The cl-ppcre/convert․lisp file
File, errors.lisp: The cl-ppcre/errors․lisp file
File, lexer.lisp: The cl-ppcre/lexer․lisp file
File, optimize.lisp: The cl-ppcre/optimize․lisp file
File, packages.lisp: The cl-ppcre/packages․lisp file
File, parser.lisp: The cl-ppcre/parser․lisp file
File, regex-class-util.lisp: The cl-ppcre/regex-class-util․lisp file
File, regex-class.lisp: The cl-ppcre/regex-class․lisp file
File, repetition-closures.lisp: The cl-ppcre/repetition-closures․lisp file
File, scanner.lisp: The cl-ppcre/scanner․lisp file
File, specials.lisp: The cl-ppcre/specials․lisp file
File, util.lisp: The cl-ppcre/util․lisp file
filter: Private classes

L
lexer: Private structures
lexer.lisp: The cl-ppcre/lexer․lisp file
lookahead: Private classes
lookbehind: Private classes

O
optimize.lisp: The cl-ppcre/optimize․lisp file

P
Package, cl-ppcre: The cl-ppcre package
packages.lisp: The cl-ppcre/packages․lisp file
parser.lisp: The cl-ppcre/parser․lisp file
ppcre-error: Public conditions
ppcre-invocation-error: Public conditions
ppcre-syntax-error: Public conditions

R
regex: Private classes
regex-class-util.lisp: The cl-ppcre/regex-class-util․lisp file
regex-class.lisp: The cl-ppcre/regex-class․lisp file
register: Private classes
repetition: Private classes
repetition-closures.lisp: The cl-ppcre/repetition-closures․lisp file

S
scanner.lisp: The cl-ppcre/scanner․lisp file
seq: Private classes
specials.lisp: The cl-ppcre/specials․lisp file
standalone: Private classes
str: Private classes
Structure, charmap: Private structures
Structure, charset: Private structures
Structure, lexer: Private structures
System, cl-ppcre: The cl-ppcre system

U
util.lisp: The cl-ppcre/util․lisp file

V
void: Private classes

W
word-boundary: Private classes

Jump to:   A   B   C   E   F   L   O   P   R   S   U   V   W