The cl-ppcre Reference Manual

Table of Contents

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

The cl-ppcre Reference Manual

This is the cl-ppcre Reference Manual, version 2.0.11, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 03:29:23 2018 GMT+0.


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

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.


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

2 Systems

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


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

2.1 cl-ppcre

Author

Dr. Edi Weitz

License

BSD

Description

Perl-compatible regular expression library

Version

2.0.11

Source

cl-ppcre.asd (file)

Components

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

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 files   [Contents][Index]

3.1.1 cl-ppcre.asd

Location

cl-ppcre.asd

Systems

cl-ppcre (system)

Packages

cl-ppcre-asd


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

3.1.2 cl-ppcre/packages.lisp

Parent

cl-ppcre (system)

Location

packages.lisp

Packages

cl-ppcre


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

3.1.3 cl-ppcre/specials.lisp

Dependency

packages.lisp (file)

Parent

cl-ppcre (system)

Location

specials.lisp

Exported Definitions
Internal Definitions

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

3.1.4 cl-ppcre/util.lisp

Dependency

specials.lisp (file)

Parent

cl-ppcre (system)

Location

util.lisp

Internal Definitions

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

3.1.5 cl-ppcre/errors.lisp

Dependency

util.lisp (file)

Parent

cl-ppcre (system)

Location

errors.lisp

Exported Definitions
Internal Definitions

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

3.1.6 cl-ppcre/charset.lisp

Dependency

errors.lisp (file)

Parent

cl-ppcre (system)

Location

charset.lisp

Internal Definitions

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

3.1.7 cl-ppcre/charmap.lisp

Dependency

charset.lisp (file)

Parent

cl-ppcre (system)

Location

charmap.lisp

Internal Definitions

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

3.1.8 cl-ppcre/chartest.lisp

Dependency

charmap.lisp (file)

Parent

cl-ppcre (system)

Location

chartest.lisp

Exported Definitions

create-optimized-test-function (function)

Internal Definitions

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


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

3.1.9 cl-ppcre/lexer.lisp

Dependency

chartest.lisp (file)

Parent

cl-ppcre (system)

Location

lexer.lisp

Internal Definitions

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

3.1.10 cl-ppcre/parser.lisp

Dependency

lexer.lisp (file)

Parent

cl-ppcre (system)

Location

parser.lisp

Exported Definitions

parse-string (function)

Internal Definitions

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

3.1.11 cl-ppcre/regex-class.lisp

Dependency

parser.lisp (file)

Parent

cl-ppcre (system)

Location

regex-class.lisp

Internal Definitions

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

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

Dependency

regex-class.lisp (file)

Parent

cl-ppcre (system)

Location

regex-class-util.lisp

Internal Definitions

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

3.1.13 cl-ppcre/convert.lisp

Dependency

regex-class-util.lisp (file)

Parent

cl-ppcre (system)

Location

convert.lisp

Internal Definitions

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

3.1.14 cl-ppcre/optimize.lisp

Dependency

convert.lisp (file)

Parent

cl-ppcre (system)

Location

optimize.lisp

Internal Definitions

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

3.1.15 cl-ppcre/closures.lisp

Dependency

optimize.lisp (file)

Parent

cl-ppcre (system)

Location

closures.lisp

Internal Definitions

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

3.1.16 cl-ppcre/repetition-closures.lisp

Dependency

closures.lisp (file)

Parent

cl-ppcre (system)

Location

repetition-closures.lisp

Internal Definitions

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

3.1.17 cl-ppcre/scanner.lisp

Dependency

repetition-closures.lisp (file)

Parent

cl-ppcre (system)

Location

scanner.lisp

Internal Definitions

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

3.1.18 cl-ppcre/api.lisp

Dependency

scanner.lisp (file)

Parent

cl-ppcre (system)

Location

api.lisp

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 cl-ppcre-asd

Source

cl-ppcre.asd

Use List

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

4.2 cl-ppcre

Source

packages.lisp (file)

Nickname

ppcre

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [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 (file)

Special Variable: *allow-quoting*

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

Package

cl-ppcre

Source

specials.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 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 (file)

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 (file)

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 (file)

Function: parse-string STRING

Translate the regex string STRING into a parse tree.

Package

cl-ppcre

Source

parser.lisp (file)

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 (file)

Writer

(setf parse-tree-synonym) (function)

Function: (setf parse-tree-synonym) NEW-PARSE-TREE SYMBOL

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

Package

cl-ppcre

Source

api.lisp (file)

Reader

parse-tree-synonym (function)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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 (file)

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 Function: 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
Method: ppcre-syntax-error-pos (CONDITION ppcre-syntax-error)
Source

errors.lisp (file)

Generic Function: 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
Method: ppcre-syntax-error-string (CONDITION ppcre-syntax-error)
Source

errors.lisp (file)

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 (file)

Methods
Method: scan PARSE-TREE TARGET-STRING &key START END (REAL-START-POS *REAL-START-POS*)
Method: scan (SCANNER function) TARGET-STRING &key START END (REAL-START-POS *REAL-START-POS*)
Method: scan (REGEX-STRING string) TARGET-STRING &key START END (REAL-START-POS *REAL-START-POS*)

Previous: , Up: Exported definitions   [Contents][Index]

5.1.6 Conditions

Condition: ppcre-error ()

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

Package

cl-ppcre

Source

errors.lisp (file)

Direct superclasses

simple-error (condition)

Direct subclasses
Condition: ppcre-invocation-error ()

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

Package

cl-ppcre

Source

errors.lisp (file)

Direct superclasses

ppcre-error (condition)

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 (file)

Direct superclasses

ppcre-error (condition)

Direct methods
Direct slots
Slot: string
Initargs

:string

Readers

ppcre-syntax-error-string (generic function)

Slot: pos
Initargs

:pos

Readers

ppcre-syntax-error-pos (generic function)

Direct Default Initargs
InitargValue
:stringcl-ppcre::*syntax-error-string*
:posnil

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

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [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 (file)

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 (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Special variables

Special Variable: *end-pos*

Where to stop scanning within *STRING*.

Package

cl-ppcre

Source

specials.lisp (file)

Special Variable: *end-string-pos*

Start of the next possible end-string candidate.

Package

cl-ppcre

Source

specials.lisp (file)

Special Variable: *extended-mode-p*

Whether the parser will start in extended mode.

Package

cl-ppcre

Source

specials.lisp (file)

Special Variable: *hyperdoc-base-uri*
Package

cl-ppcre

Source

specials.lisp (file)

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 (file)

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 (file)

Special Variable: *reg-ends*

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

Package

cl-ppcre

Source

specials.lisp (file)

Special Variable: *reg-starts*

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

Package

cl-ppcre

Source

specials.lisp (file)

Special Variable: *regs-maybe-start*

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

Package

cl-ppcre

Source

specials.lisp (file)

Special Variable: *rep-num*

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

Package

cl-ppcre

Source

specials.lisp (file)

Special Variable: *repeat-counters*

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

Package

cl-ppcre

Source

specials.lisp (file)

Special Variable: *special-optimize-settings*

Special optimize settings used only by a few declaration expressions.

Package

cl-ppcre

Source

specials.lisp (file)

Special Variable: *standard-optimize-settings*

The standard optimize settings used by most declaration expressions.

Package

cl-ppcre

Source

specials.lisp (file)

Special Variable: *start-pos*

Where to start scanning within *STRING*.

Package

cl-ppcre

Source

specials.lisp (file)

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 (file)

Special Variable: *syntax-error-string*

The string which caused the syntax error.

Package

cl-ppcre

Source

errors.lisp (file)

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 (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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 (file)

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 (file)

Macro: char-searcher-aux &key CASE-INSENSITIVE-P

Auxiliary macro used by CREATE-CHAR-SEARCHER.

Package

cl-ppcre

Source

scanner.lisp (file)

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 (file)

Macro: defconstant NAME VALUE &optional DOC

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

Package

cl-ppcre

Source

util.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

Macro: maybe-coerce-to-simple-string STRING

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

Package

cl-ppcre

Source

util.lisp (file)

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 (file)

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 (file)

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 (file)

Macro: signal-invocation-error FORMAT-CONTROL &rest FORMAT-ARGUMENTS
Package

cl-ppcre

Source

errors.lisp (file)

Macro: signal-syntax-error FORMAT-CONTROL &rest FORMAT-ARGUMENTS
Package

cl-ppcre

Source

errors.lisp (file)

Macro: signal-syntax-error* POS FORMAT-CONTROL &rest FORMAT-ARGUMENTS
Package

cl-ppcre

Source

errors.lisp (file)

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 (file)

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 (file)

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 (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: charmap-complementp INSTANCE
Function: (setf charmap-complementp) VALUE INSTANCE
Package

cl-ppcre

Source

charmap.lisp (file)

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 (file)

Function: charmap-count INSTANCE
Function: (setf charmap-count) VALUE INSTANCE
Package

cl-ppcre

Source

charmap.lisp (file)

Function: charmap-end INSTANCE
Function: (setf charmap-end) VALUE INSTANCE
Package

cl-ppcre

Source

charmap.lisp (file)

Function: charmap-p OBJECT
Package

cl-ppcre

Source

charmap.lisp (file)

Function: charmap-start INSTANCE
Function: (setf charmap-start) VALUE INSTANCE
Package

cl-ppcre

Source

charmap.lisp (file)

Function: charmap-vector INSTANCE
Function: (setf charmap-vector) VALUE INSTANCE
Package

cl-ppcre

Source

charmap.lisp (file)

Function: charset-count INSTANCE
Function: (setf charset-count) VALUE INSTANCE
Package

cl-ppcre

Source

charset.lisp (file)

Function: charset-depth INSTANCE
Function: (setf charset-depth) VALUE INSTANCE
Package

cl-ppcre

Source

charset.lisp (file)

Function: charset-p OBJECT
Package

cl-ppcre

Source

charset.lisp (file)

Function: charset-vector INSTANCE
Function: (setf charset-vector) VALUE INSTANCE
Package

cl-ppcre

Source

charset.lisp (file)

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 (file)

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 (file)

Function: complement* TEST-FUNCTION

Like COMPLEMENT but optimized for unary functions.

Package

cl-ppcre

Source

util.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: copy-charmap INSTANCE
Package

cl-ppcre

Source

charmap.lisp (file)

Function: copy-charset INSTANCE
Package

cl-ppcre

Source

charset.lisp (file)

Function: copy-lexer INSTANCE
Package

cl-ppcre

Source

lexer.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: end-of-string-p LEXER

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

Package

cl-ppcre

Source

lexer.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: get-token LEXER

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

Package

cl-ppcre

Source

lexer.lisp (file)

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 (file)

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 (file)

Function: hyperdoc-lookup SYMBOL TYPE
Package

cl-ppcre

Source

specials.lisp (file)

Function: in-charmap-p CHAR CHARMAP

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

Package

cl-ppcre

Source

charmap.lisp (file)

Function: in-charset-p CHAR SET

Checks whether the character CHAR is in the charset SET.

Package

cl-ppcre

Source

charset.lisp (file)

Function: lexer-last-pos INSTANCE
Function: (setf lexer-last-pos) VALUE INSTANCE
Package

cl-ppcre

Source

lexer.lisp (file)

Function: lexer-len INSTANCE
Package

cl-ppcre

Source

lexer.lisp (file)

Function: lexer-p OBJECT
Package

cl-ppcre

Source

lexer.lisp (file)

Function: lexer-pos INSTANCE
Function: (setf lexer-pos) VALUE INSTANCE
Package

cl-ppcre

Source

lexer.lisp (file)

Function: lexer-reg INSTANCE
Function: (setf lexer-reg) VALUE INSTANCE
Package

cl-ppcre

Source

lexer.lisp (file)

Function: lexer-str INSTANCE
Package

cl-ppcre

Source

lexer.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: make-charmap% &key (VECTOR VECTOR) (START START) (END END) (COUNT COUNT) (COMPLEMENTP COMPLEMENTP)
Package

cl-ppcre

Source

charmap.lisp (file)

Function: make-charset ()
Package

cl-ppcre

Source

charset.lisp (file)

Function: make-lexer STRING
Package

cl-ppcre

Source

lexer.lisp (file)

Function: make-lexer-internal &key (STR STR) (LEN LEN) (REG REG) (POS POS) (LAST-POS LAST-POS)
Package

cl-ppcre

Source

lexer.lisp (file)

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 (file)

Function: map-charset FUNCTION CHARSET

Calls FUNCTION with all characters in SET. Returns NIL.

Package

cl-ppcre

Source

charset.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: nsubseq SEQUENCE START &optional END

Returns a subsequence by pointing to location in original sequence.

Package

cl-ppcre

Source

util.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: read-char-property LEXER FIRST-CHAR
Package

cl-ppcre

Source

lexer.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: string-list-to-simple-string STRING-LIST

Concatenates a list of strings to one simple-string.

Package

cl-ppcre

Source

util.lisp (file)

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 (file)

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 (file)

Function: unget-token LEXER

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

Package

cl-ppcre

Source

lexer.lisp (file)

Function: whitespacep CHR

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

Package

cl-ppcre

Source

util.lisp (file)

Function: word-boundary-p START-POS

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

Package

cl-ppcre

Source

closures.lisp (file)

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 (file)


Next: , Previous: , Up: Internal definitions   [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 (file)

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 Function: case-insensitive-p OBJECT
Package

cl-ppcre

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

If we match case-insensitively.

Source

regex-class.lisp (file)

Method: case-insensitive-p (BACK-REFERENCE back-reference)

Whether we check case-insensitively.

Source

regex-class.lisp (file)

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 (file)

Methods
Method: case-mode (REGEX regex) OLD-CASE-MODE
Method: case-mode (STR str) OLD-CASE-MODE
Generic Function: choices OBJECT
Generic Function: (setf choices) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: choices (ALTERNATION alternation)
Method: (setf choices) NEW-VALUE (ALTERNATION alternation)

A list of REGEX objects

Source

regex-class.lisp (file)

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 (file)

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 (file)

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 Function: contains-register-p OBJECT
Package

cl-ppcre

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

Whether the regex contains a register.

Source

regex-class.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Methods
Method: create-matcher-aux (REPETITION repetition) NEXT-FN
Source

repetition-closures.lisp (file)

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 (file)

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 (file)

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 (file)

Methods
Method: create-non-greedy-no-zero-matcher (REPETITION repetition) NEXT-FN
Generic Function: elements OBJECT
Generic Function: (setf elements) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: elements (SEQ seq)
Method: (setf elements) NEW-VALUE (SEQ seq)

A list of REGEX objects.

Source

regex-class.lisp (file)

Generic Function: else-regex OBJECT
Generic Function: (setf else-regex) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: else-regex (BRANCH branch)
Method: (setf else-regex) NEW-VALUE (BRANCH branch)

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

Source

regex-class.lisp (file)

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 (file)

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 (file)

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 (file)

Methods
Method: flatten (REGEX regex)
Method: flatten (BRANCH branch)
Method: flatten (ALTERNATION alternation)
Method: flatten (SEQ seq)
Generic Function: fn OBJECT
Generic Function: (setf fn) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: fn (FILTER filter)
Method: (setf fn) NEW-VALUE (FILTER filter)

The user-defined function.

Source

regex-class.lisp (file)

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 (file)

Methods
Method: gather-strings (REGEX regex)
Method: gather-strings (BRANCH branch)
Method: gather-strings (ALTERNATION alternation)
Method: gather-strings (SEQ seq)
Generic Function: greedyp OBJECT
Package

cl-ppcre

Methods
Method: greedyp (REPETITION repetition)

Whether the repetition is greedy.

Source

regex-class.lisp (file)

Generic Function: len OBJECT
Generic Function: (setf len) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: len (VOID void)
Source

regex-class-util.lisp (file)

Method: len (FILTER filter)

The fixed length of this filter or NIL.

Source

regex-class.lisp (file)

Method: len (STR str)
Method: (setf len) NEW-VALUE (STR str)

The length of the string.

Source

regex-class.lisp (file)

Method: len (REPETITION repetition)

The length of the enclosed regex. NIL if unknown.

Source

regex-class.lisp (file)

Method: len (LOOKBEHIND lookbehind)
Method: (setf len) NEW-VALUE (LOOKBEHIND lookbehind)

The (fixed) length of the enclosed regex.

Source

regex-class.lisp (file)

Generic Function: maximum OBJECT
Generic Function: (setf maximum) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: maximum (REPETITION repetition)
Method: (setf maximum) NEW-VALUE (REPETITION repetition)

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

Source

regex-class.lisp (file)

Generic Function: min-len OBJECT
Package

cl-ppcre

Methods
Method: min-len (REPETITION repetition)

The minimal length of the enclosed regex.

Source

regex-class.lisp (file)

Generic Function: min-rest OBJECT
Generic Function: (setf min-rest) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: min-rest (REPETITION repetition)
Method: (setf min-rest) NEW-VALUE (REPETITION repetition)

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

Source

regex-class.lisp (file)

Generic Function: minimum OBJECT
Generic Function: (setf minimum) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: minimum (REPETITION repetition)
Method: (setf minimum) NEW-VALUE (REPETITION repetition)

The minimal number of repetitions.

Source

regex-class.lisp (file)

Generic Function: multi-line-p OBJECT
Package

cl-ppcre

Methods
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 (file)

Generic Function: name OBJECT
Generic Function: (setf name) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: name (BACK-REFERENCE back-reference)
Method: (setf name) NEW-VALUE (BACK-REFERENCE back-reference)

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

Source

regex-class.lisp (file)

Method: name (REGISTER register)

Name of this register or NIL.

Source

regex-class.lisp (file)

Generic Function: negatedp OBJECT
Package

cl-ppcre

Methods
Method: negatedp (WORD-BOUNDARY word-boundary)

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

Source

regex-class.lisp (file)

Generic Function: no-newline-p OBJECT
Package

cl-ppcre

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

Whether we ignore #\Newline at the end.

Source

regex-class.lisp (file)

Generic Function: num OBJECT
Generic Function: (setf num) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: num (BACK-REFERENCE back-reference)
Method: (setf num) NEW-VALUE (BACK-REFERENCE back-reference)

The number of the register this reference refers to.

Source

regex-class.lisp (file)

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 (file)

Generic Function: offset OBJECT
Generic Function: (setf offset) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: offset (STR str)
Method: (setf offset) NEW-VALUE (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 (file)

Generic Function: positivep OBJECT
Package

cl-ppcre

Methods
Method: positivep (LOOKBEHIND lookbehind)

Whether this assertion is positive.

Source

regex-class.lisp (file)

Method: positivep (LOOKAHEAD lookahead)

Whether this assertion is positive.

Source

regex-class.lisp (file)

Generic Function: regex OBJECT
Generic Function: (setf regex) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: regex (STANDALONE standalone)
Method: (setf regex) NEW-VALUE (STANDALONE standalone)

The inner regex.

Source

regex-class.lisp (file)

Method: regex (REGISTER register)
Method: (setf regex) NEW-VALUE (REGISTER register)

The inner regex.

Source

regex-class.lisp (file)

Method: regex (REPETITION repetition)
Method: (setf regex) NEW-VALUE (REPETITION repetition)

The REGEX that’s repeated.

Source

regex-class.lisp (file)

Method: regex (LOOKBEHIND lookbehind)
Method: (setf regex) NEW-VALUE (LOOKBEHIND lookbehind)

The REGEX object we’re checking.

Source

regex-class.lisp (file)

Method: regex (LOOKAHEAD lookahead)
Method: (setf regex) NEW-VALUE (LOOKAHEAD lookahead)

The REGEX object we’re checking.

Source

regex-class.lisp (file)

Generic Function: regex-length REGEX

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

Package

cl-ppcre

Source

regex-class-util.lisp (file)

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 (file)

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 (file)

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 (file)

Methods
Method: resolve-property (PROPERTY-NAME string)
Method: resolve-property (FUNCTION-NAME symbol)
Method: resolve-property (TEST-FUNCTION function)
Generic Function: single-line-p OBJECT
Package

cl-ppcre

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

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

Source

regex-class.lisp (file)

Generic Function: skip OBJECT
Generic Function: (setf skip) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: skip (VOID void)
Source

regex-class-util.lisp (file)

Method: skip (STR str)
Method: (setf skip) NEW-VALUE (STR str)

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

Source

regex-class.lisp (file)

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 (file)

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
Generic Function: (setf start-of-end-string-p) NEW-VALUE OBJECT
Package

cl-ppcre

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

regex-class-util.lisp (file)

Method: start-of-end-string-p (STR str)
Method: (setf start-of-end-string-p) NEW-VALUE (STR str)

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

Source

regex-class.lisp (file)

Generic Function: startp OBJECT
Package

cl-ppcre

Methods
Method: startp (ANCHOR anchor)

Whether this is a "start anchor".

Source

regex-class.lisp (file)

Generic Function: str OBJECT
Generic Function: (setf str) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: str (VOID void)
Source

regex-class-util.lisp (file)

Method: str (STR str)
Method: (setf str) NEW-VALUE (STR str)

The actual string.

Source

regex-class.lisp (file)

Generic Function: test OBJECT
Generic Function: (setf test) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: test (BRANCH branch)
Method: (setf test) NEW-VALUE (BRANCH branch)

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

Source

regex-class.lisp (file)

Generic Function: test-function OBJECT
Package

cl-ppcre

Methods
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 (file)

Generic Function: then-regex OBJECT
Generic Function: (setf then-regex) NEW-VALUE OBJECT
Package

cl-ppcre

Methods
Method: then-regex (BRANCH branch)
Method: (setf then-regex) NEW-VALUE (BRANCH branch)

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

Source

regex-class.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.6 Structures

Structure: charmap ()
Package

cl-ppcre

Source

charmap.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

make-load-form (method)

Direct slots
Slot: vector
Type

simple-bit-vector

Initform

#*0

Readers

charmap-vector (function)

Writers

(setf charmap-vector) (function)

Slot: start
Type

fixnum

Initform

0

Readers

charmap-start (function)

Writers

(setf charmap-start) (function)

Slot: end
Type

fixnum

Initform

0

Readers

charmap-end (function)

Writers

(setf charmap-end) (function)

Slot: count
Type

(or fixnum null)

Readers

charmap-count (function)

Writers

(setf charmap-count) (function)

Slot: complementp
Type

boolean

Readers

charmap-complementp (function)

Writers

(setf charmap-complementp) (function)

Structure: charset ()
Package

cl-ppcre

Source

charset.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

make-load-form (method)

Direct slots
Slot: depth
Type

fixnum

Initform

cl-ppcre::+probe-depth+

Readers

charset-depth (function)

Writers

(setf charset-depth) (function)

Slot: count
Type

fixnum

Initform

0

Readers

charset-count (function)

Writers

(setf charset-count) (function)

Slot: vector
Type

(simple-array character (*))

Initform

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

Readers

charset-vector (function)

Writers

(setf charset-vector) (function)

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 (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: str
Type

string

Initform

""

Readers

lexer-str (function)

Writers

(setf lexer-str) (function)

Slot: len
Type

fixnum

Initform

0

Readers

lexer-len (function)

Writers

(setf lexer-len) (function)

Slot: reg
Type

fixnum

Initform

0

Readers

lexer-reg (function)

Writers

(setf lexer-reg) (function)

Slot: pos
Type

fixnum

Initform

0

Readers

lexer-pos (function)

Writers

(setf lexer-pos) (function)

Slot: last-pos
Type

list

Readers

lexer-last-pos (function)

Writers

(setf lexer-last-pos) (function)


Previous: , Up: Internal definitions   [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 (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: choices

A list of REGEX objects

Type

cons

Initargs

:choices

Readers

choices (generic function)

Writers

(setf choices) (generic function)

Class: anchor ()

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

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: startp

Whether this is a "start anchor".

Initargs

:startp

Readers

startp (generic function)

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 (generic function)

Slot: no-newline-p

Whether we ignore #\Newline at the end.

Initargs

:no-newline-p

Readers

no-newline-p (generic function)

Class: back-reference ()

BACK-REFERENCE objects represent backreferences.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: num

The number of the register this reference refers to.

Type

fixnum

Initargs

:num

Readers

num (generic function)

Writers

(setf num) (generic function)

Slot: name

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

Initargs

:name

Readers

name (generic function)

Writers

(setf name) (generic function)

Slot: case-insensitive-p

Whether we check case-insensitively.

Initargs

:case-insensitive-p

Readers

case-insensitive-p (generic function)

Class: branch ()

BRANCH objects represent Perl’s conditional regular expressions.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: test

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

Initargs

:test

Readers

test (generic function)

Writers

(setf test) (generic function)

Slot: then-regex

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

Initargs

:then-regex

Readers

then-regex (generic function)

Writers

(setf then-regex) (generic function)

Slot: else-regex

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

Initargs

:else-regex

Initform

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

Readers

else-regex (generic function)

Writers

(setf else-regex) (generic function)

Class: char-class ()

CHAR-CLASS objects represent character classes.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

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 (generic function)

Class: everything ()

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

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

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 (generic function)

Class: filter ()

FILTER objects represent arbitrary functions defined by the user.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: fn

The user-defined function.

Type

(or function symbol)

Initargs

:fn

Readers

fn (generic function)

Writers

(setf fn) (generic function)

Slot: len

The fixed length of this filter or NIL.

Initargs

:len

Readers

len (generic function)

Class: lookahead ()

LOOKAHEAD objects represent look-ahead assertions.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: regex

The REGEX object we’re checking.

Initargs

:regex

Readers

regex (generic function)

Writers

(setf regex) (generic function)

Slot: positivep

Whether this assertion is positive.

Initargs

:positivep

Readers

positivep (generic function)

Class: lookbehind ()

LOOKBEHIND objects represent look-behind assertions.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: regex

The REGEX object we’re checking.

Initargs

:regex

Readers

regex (generic function)

Writers

(setf regex) (generic function)

Slot: positivep

Whether this assertion is positive.

Initargs

:positivep

Readers

positivep (generic function)

Slot: len

The (fixed) length of the enclosed regex.

Type

fixnum

Initargs

:len

Readers

len (generic function)

Writers

(setf len) (generic function)

Class: regex ()

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

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Class: register ()

REGISTER objects represent register groups.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: regex

The inner regex.

Initargs

:regex

Readers

regex (generic function)

Writers

(setf regex) (generic function)

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 (generic function)

Slot: name

Name of this register or NIL.

Initargs

:name

Readers

name (generic function)

Class: repetition ()

REPETITION objects represent repetitions of regexes.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: regex

The REGEX that’s repeated.

Initargs

:regex

Readers

regex (generic function)

Writers

(setf regex) (generic function)

Slot: greedyp

Whether the repetition is greedy.

Initargs

:greedyp

Readers

greedyp (generic function)

Slot: minimum

The minimal number of repetitions.

Type

fixnum

Initargs

:minimum

Readers

minimum (generic function)

Writers

(setf minimum) (generic function)

Slot: maximum

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

Initargs

:maximum

Readers

maximum (generic function)

Writers

(setf maximum) (generic function)

Slot: min-len

The minimal length of the enclosed regex.

Initargs

:min-len

Readers

min-len (generic function)

Slot: len

The length of the enclosed regex. NIL if unknown.

Initargs

:len

Readers

len (generic function)

Slot: min-rest

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

Type

fixnum

Initform

0

Readers

min-rest (generic function)

Writers

(setf min-rest) (generic function)

Slot: contains-register-p

Whether the regex contains a register.

Initargs

:contains-register-p

Readers

contains-register-p (generic function)

Class: seq ()

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

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: elements

A list of REGEX objects.

Type

cons

Initargs

:elements

Readers

elements (generic function)

Writers

(setf elements) (generic function)

Class: standalone ()

A standalone regular expression.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: regex

The inner regex.

Initargs

:regex

Readers

regex (generic function)

Writers

(setf regex) (generic function)

Class: str ()

STR objects represent string.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: str

The actual string.

Type

string

Initargs

:str

Readers

str (generic function)

Writers

(setf str) (generic function)

Slot: len

The length of the string.

Type

fixnum

Initform

0

Readers

len (generic function)

Writers

(setf len) (generic function)

Slot: case-insensitive-p

If we match case-insensitively.

Initargs

:case-insensitive-p

Readers

case-insensitive-p (generic function)

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 (generic function)

Writers

(setf offset) (generic function)

Slot: skip

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

Initargs

:skip

Readers

skip (generic function)

Writers

(setf skip) (generic function)

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 (generic function)

Writers

(setf start-of-end-string-p) (generic function)

Class: void ()

VOID objects represent empty regular expressions.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Class: word-boundary ()

WORD-BOUNDARY objects represent word-boundary assertions.

Package

cl-ppcre

Source

regex-class.lisp (file)

Direct superclasses

regex (class)

Direct methods
Direct slots
Slot: negatedp

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

Initargs

:negatedp

Readers

negatedp (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
cl-ppcre.asd: The cl-ppcre<dot>asd file
cl-ppcre/api.lisp: The cl-ppcre/api<dot>lisp file
cl-ppcre/charmap.lisp: The cl-ppcre/charmap<dot>lisp file
cl-ppcre/charset.lisp: The cl-ppcre/charset<dot>lisp file
cl-ppcre/chartest.lisp: The cl-ppcre/chartest<dot>lisp file
cl-ppcre/closures.lisp: The cl-ppcre/closures<dot>lisp file
cl-ppcre/convert.lisp: The cl-ppcre/convert<dot>lisp file
cl-ppcre/errors.lisp: The cl-ppcre/errors<dot>lisp file
cl-ppcre/lexer.lisp: The cl-ppcre/lexer<dot>lisp file
cl-ppcre/optimize.lisp: The cl-ppcre/optimize<dot>lisp file
cl-ppcre/packages.lisp: The cl-ppcre/packages<dot>lisp file
cl-ppcre/parser.lisp: The cl-ppcre/parser<dot>lisp file
cl-ppcre/regex-class-util.lisp: The cl-ppcre/regex-class-util<dot>lisp file
cl-ppcre/regex-class.lisp: The cl-ppcre/regex-class<dot>lisp file
cl-ppcre/repetition-closures.lisp: The cl-ppcre/repetition-closures<dot>lisp file
cl-ppcre/scanner.lisp: The cl-ppcre/scanner<dot>lisp file
cl-ppcre/specials.lisp: The cl-ppcre/specials<dot>lisp file
cl-ppcre/util.lisp: The cl-ppcre/util<dot>lisp file

F
File, Lisp, cl-ppcre.asd: The cl-ppcre<dot>asd file
File, Lisp, cl-ppcre/api.lisp: The cl-ppcre/api<dot>lisp file
File, Lisp, cl-ppcre/charmap.lisp: The cl-ppcre/charmap<dot>lisp file
File, Lisp, cl-ppcre/charset.lisp: The cl-ppcre/charset<dot>lisp file
File, Lisp, cl-ppcre/chartest.lisp: The cl-ppcre/chartest<dot>lisp file
File, Lisp, cl-ppcre/closures.lisp: The cl-ppcre/closures<dot>lisp file
File, Lisp, cl-ppcre/convert.lisp: The cl-ppcre/convert<dot>lisp file
File, Lisp, cl-ppcre/errors.lisp: The cl-ppcre/errors<dot>lisp file
File, Lisp, cl-ppcre/lexer.lisp: The cl-ppcre/lexer<dot>lisp file
File, Lisp, cl-ppcre/optimize.lisp: The cl-ppcre/optimize<dot>lisp file
File, Lisp, cl-ppcre/packages.lisp: The cl-ppcre/packages<dot>lisp file
File, Lisp, cl-ppcre/parser.lisp: The cl-ppcre/parser<dot>lisp file
File, Lisp, cl-ppcre/regex-class-util.lisp: The cl-ppcre/regex-class-util<dot>lisp file
File, Lisp, cl-ppcre/regex-class.lisp: The cl-ppcre/regex-class<dot>lisp file
File, Lisp, cl-ppcre/repetition-closures.lisp: The cl-ppcre/repetition-closures<dot>lisp file
File, Lisp, cl-ppcre/scanner.lisp: The cl-ppcre/scanner<dot>lisp file
File, Lisp, cl-ppcre/specials.lisp: The cl-ppcre/specials<dot>lisp file
File, Lisp, cl-ppcre/util.lisp: The cl-ppcre/util<dot>lisp file

L
Lisp File, cl-ppcre.asd: The cl-ppcre<dot>asd file
Lisp File, cl-ppcre/api.lisp: The cl-ppcre/api<dot>lisp file
Lisp File, cl-ppcre/charmap.lisp: The cl-ppcre/charmap<dot>lisp file
Lisp File, cl-ppcre/charset.lisp: The cl-ppcre/charset<dot>lisp file
Lisp File, cl-ppcre/chartest.lisp: The cl-ppcre/chartest<dot>lisp file
Lisp File, cl-ppcre/closures.lisp: The cl-ppcre/closures<dot>lisp file
Lisp File, cl-ppcre/convert.lisp: The cl-ppcre/convert<dot>lisp file
Lisp File, cl-ppcre/errors.lisp: The cl-ppcre/errors<dot>lisp file
Lisp File, cl-ppcre/lexer.lisp: The cl-ppcre/lexer<dot>lisp file
Lisp File, cl-ppcre/optimize.lisp: The cl-ppcre/optimize<dot>lisp file
Lisp File, cl-ppcre/packages.lisp: The cl-ppcre/packages<dot>lisp file
Lisp File, cl-ppcre/parser.lisp: The cl-ppcre/parser<dot>lisp file
Lisp File, cl-ppcre/regex-class-util.lisp: The cl-ppcre/regex-class-util<dot>lisp file
Lisp File, cl-ppcre/regex-class.lisp: The cl-ppcre/regex-class<dot>lisp file
Lisp File, cl-ppcre/repetition-closures.lisp: The cl-ppcre/repetition-closures<dot>lisp file
Lisp File, cl-ppcre/scanner.lisp: The cl-ppcre/scanner<dot>lisp file
Lisp File, cl-ppcre/specials.lisp: The cl-ppcre/specials<dot>lisp file
Lisp File, cl-ppcre/util.lisp: The cl-ppcre/util<dot>lisp file

Jump to:   C   F   L  

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: Internal functions
%add-to-charset/expand: Internal functions

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

*
*string*-equal: Internal functions
*string*=: Internal functions

A
add-to-charset: Internal functions
all-matches: Exported compiler macros
all-matches: Exported functions
all-matches-as-strings: Exported compiler macros
all-matches-as-strings: Exported functions

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

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

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

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

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

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

H
hyperdoc-lookup: Internal functions

I
in-charmap-p: Internal functions
in-charset-p: Internal functions
incf-after: Internal macros
insert-advance-fn: Internal macros
insert-char-class-tester: Internal macros

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

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

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

O
offset: Internal generic functions
offset: Internal generic functions

P
parse-register-name-aux: Internal functions
parse-string: Exported functions
parse-tree-synonym: Exported functions
positivep: Internal generic functions
positivep: Internal generic functions
positivep: Internal generic functions
ppcre-syntax-error-pos: Exported generic functions
ppcre-syntax-error-pos: Exported generic functions
ppcre-syntax-error-string: Exported generic functions
ppcre-syntax-error-string: Exported generic functions
print-symbol-info: Internal functions

Q
quant: Internal functions
quote-meta-chars: Exported functions
quote-sections: Internal functions

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

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

T
test: Internal generic functions
test: Internal generic functions
test-function: Internal generic functions
test-function: Internal generic functions
then-regex: Internal generic functions
then-regex: Internal generic functions
try-number: Internal functions

U
unescape-char: Internal functions
unget-token: Internal functions

W
whitespacep: Internal functions
with-rebinding: Internal macros
with-unique-names: Internal macros
word-boundary-p: Internal functions
word-char-p: Internal 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*: Exported special variables
*allow-quoting*: Exported special variables
*end-pos*: Internal special variables
*end-string-pos*: Internal special variables
*extended-mode-p*: Internal special variables
*hyperdoc-base-uri*: Internal special variables
*last-pos-stores*: Internal special variables
*optimize-char-classes*: Exported special variables
*property-resolver*: Exported special variables
*real-start-pos*: Internal special variables
*reg-ends*: Internal special variables
*reg-starts*: Internal special variables
*regex-char-code-limit*: Exported special variables
*regs-maybe-start*: Internal special variables
*rep-num*: Internal special variables
*repeat-counters*: Internal special variables
*special-optimize-settings*: Internal special variables
*standard-optimize-settings*: Internal special variables
*start-pos*: Internal special variables
*string*: Internal special variables
*syntax-error-string*: Internal special variables
*use-bmh-matchers*: Exported special variables
*zero-length-num*: Internal special variables

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

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

D
depth: Internal structures

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

F
fn: Internal classes

G
greedyp: Internal classes

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

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

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

O
offset: Internal classes

P
pos: Exported conditions
pos: Internal structures
positivep: Internal classes
positivep: Internal classes

R
reg: Internal structures
regex: Internal classes
regex: Internal classes
regex: Internal classes
regex: Internal classes
regex: Internal classes

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

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

V
vector: Internal structures
vector: Internal 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   P   R   S   V   W  
Index Entry  Section

A
alternation: Internal classes
anchor: Internal classes

B
back-reference: Internal classes
branch: Internal classes

C
char-class: Internal classes
charmap: Internal structures
charset: Internal structures
cl-ppcre: The cl-ppcre system
cl-ppcre: The cl-ppcre package
cl-ppcre-asd: The cl-ppcre-asd package
Class, alternation: Internal classes
Class, anchor: Internal classes
Class, back-reference: Internal classes
Class, branch: Internal classes
Class, char-class: Internal classes
Class, everything: Internal classes
Class, filter: Internal classes
Class, lookahead: Internal classes
Class, lookbehind: Internal classes
Class, regex: Internal classes
Class, register: Internal classes
Class, repetition: Internal classes
Class, seq: Internal classes
Class, standalone: Internal classes
Class, str: Internal classes
Class, void: Internal classes
Class, word-boundary: Internal classes
Condition, ppcre-error: Exported conditions
Condition, ppcre-invocation-error: Exported conditions
Condition, ppcre-syntax-error: Exported conditions

E
everything: Internal classes

F
filter: Internal classes

L
lexer: Internal structures
lookahead: Internal classes
lookbehind: Internal classes

P
Package, cl-ppcre: The cl-ppcre package
Package, cl-ppcre-asd: The cl-ppcre-asd package
ppcre-error: Exported conditions
ppcre-invocation-error: Exported conditions
ppcre-syntax-error: Exported conditions

R
regex: Internal classes
register: Internal classes
repetition: Internal classes

S
seq: Internal classes
standalone: Internal classes
str: Internal classes
Structure, charmap: Internal structures
Structure, charset: Internal structures
Structure, lexer: Internal structures
System, cl-ppcre: The cl-ppcre system

V
void: Internal classes

W
word-boundary: Internal classes

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