Common Lisp Package: LISPBUILDER-REGEX

README:

FUNCTION

Public

COMPILE-EXPR (REGEXPR)

Parse a string regex expression, and compile it into matcher object. Uses the pattern cache.

COMPILE-STR (PATSTR)

Parse a string regex expression, and compile it into matcher object. Uses the pattern cache.

MATCH-STR (MATCHER CANDSTR &KEY (REGS (MAKE-REGS (MATCHER-NUMREGS MATCHER))) (START 0) (LENGTH (- (LENGTH CANDSTR) START)) (START-IS-ANCHOR (= START 0)) (END-IS-ANCHOR (= LENGTH (LENGTH CANDSTR))) ACCEPTFN HOOKS)

Run a matcher against a candidate string, without scanning (so it is implicitly anchored). Returns (values t start end regs) on success, nil on failure.

MATCHER-NUMREGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PARSE-STR (STR)

Parse a string into a parse tree.

SCAN-STR (MATCHER CANDSTR &KEY (REGS (MAKE-REGS (MATCHER-NUMREGS MATCHER))) (START 0) (LENGTH (LENGTH CANDSTR)) (START-IS-ANCHOR (= START 0)) (END-IS-ANCHOR (= LENGTH (LENGTH CANDSTR))) ACCEPTFN HOOKS)

Run a matcher against a candidate string, scanning forward if necessary. Returns (values t start end regs) on success, nil on failure.

Undocumented

ALLOW-BACKMATCH (&OPTIONAL (FLAG T))

ALLOW-NONGREEDY-QUANTIFIERS (&OPTIONAL (FLAG T))

ALLOW-NONREGISTER-GROUPS (&OPTIONAL (FLAG T))

ALLOW-RANGEMATCH (&OPTIONAL (FLAG T))

ALT-NODE-CHILD (ALT-NODE IDX)

ALT-NODE-CHILDREN (ALT-NODE)

ALT-NODE-FIRST (ALT-NODE)

ALT-NODE-NUMCHILDREN (ALT-NODE)

ALT-NODE-P (NODE)

ALT-NODE-SECOND (ALT-NODE)

BACKMATCH-NODE-P (NODE)

BACKMATCH-NODE-REGNUM (BACKMATCH-NODE)

CHAR-NODE-CHAR (CHAR-NODE)

CHAR-NODE-P (NODE)

CHARCLASS-NODE-CHARS (CHARCLASS-NODE)

CHARCLASS-NODE-NEGATED-P (CHARCLASS-NODE)

CHARCLASS-NODE-P (NODE)

CLEAR-PATTERN-CACHE

COMPILE-VERBOSE (&OPTIONAL (FLAG T))

DOT-MATCHES-NEWLINE (&OPTIONAL (FLAG T))

END-ANCHOR-NODE-P (NODE)

ESCAPE-SPECIAL-CHARS (&OPTIONAL (FLAG T))

FORCE-SAFE-MATCH (&OPTIONAL (FLAG T))

HOOK-NODE-FUNCTION (HOOK-NODE)

HOOK-NODE-FUNCTION-P (HOOK-NODE)

HOOK-NODE-INDEX-P (HOOK-NODE)

HOOK-NODE-P (NODE)

HOOK-NODE-SYMBOL-P (HOOK-NODE)

KLEENE-NODE-CHILD (KLEENE-NODE)

KLEENE-NODE-GREEDY-P (NODE)

KLEENE-NODE-NONGREEDY-P (NODE)

KLEENE-NODE-P (NODE)

MACROEXPAND-REGEX-STR (PATSTR)

MAKE-ALT-NODE-ARGS (&REST CHILD-NODES)

MAKE-ALT-NODE-LIST (CHILD-NODES)

MAKE-BACKMATCH-NODE (REGNUM)

MAKE-CHAR-NODE (CHR)

MAKE-CHARCLASS-NODE (CHARS &KEY NEGATED)

MAKE-END-ANCHOR-NODE

MAKE-HOOK-NODE (FXN-ID)

MAKE-KLEENE-NODE (CHILD-NODE GREEDYP)

MAKE-OPTIONAL-NODE (CHILD-NODE GREEDYP)

MAKE-PKLEENE-NODE (CHILD-NODE GREEDYP)

MAKE-RANGE-NODE (CHILD-NODE MIN MAX GREEDYP)

MAKE-REGEND-NODE (REGNUM)

MAKE-REGISTER-NODE (REGNUM CHILD)

MAKE-REGS (N)

MAKE-REGSTART-NODE (REGNUM)

MAKE-SEQ-NODE-ARGS (&REST CHILD-NODES)

MAKE-SEQ-NODE-LIST (CHILD-NODES)

MAKE-SPECCLASS-NODE (CLASS &KEY NEGATED)

MAKE-START-ANCHOR-NODE

MAKE-STRING-NODE (STR)

MAKE-SUCCESS-NODE (RC)

MATCH-SIMPLE-STRINGS-ONLY (&OPTIONAL (FLAG T))

SETFMATCHER-NUMREGS (NEW-VALUE INSTANCE)

MATCHER-P (OBJECT)

OPTIONAL-NODE-CHILD (OPTIONAL-NODE)

OPTIONAL-NODE-GREEDY-P (NODE)

OPTIONAL-NODE-NONGREEDY-P (NODE)

OPTIONAL-NODE-P (NODE)

PKLEENE-NODE-CHILD (PKLEENE-NODE)

PKLEENE-NODE-GREEDY-P (NODE)

PKLEENE-NODE-NONGREEDY-P (NODE)

PKLEENE-NODE-P (NODE)

RANGE-NODE-CHILD (RANGE-NODE)

RANGE-NODE-GREEDY-P (NODE)

RANGE-NODE-MAX (RANGE-NODE)

RANGE-NODE-MIN (RANGE-NODE)

RANGE-NODE-NONGREEDY-P (NODE)

RANGE-NODE-P (NODE)

REGEND-NODE-P (NODE)

REGEND-NODE-REGNUM (REND-NODE)

REGISTER-END (REGS N)

REGISTER-MATCHED-P (REGS N)

REGISTER-NODE-CHILD (REG-NODE)

REGISTER-NODE-P (NODE)

REGISTER-NODE-REGNUM (REG-NODE)

REGISTER-START (REGS N)

REGISTERS-MATCH-RIGHTMOST (&OPTIONAL (FLAG T))

REGSTART-NODE-P (NODE)

REGSTART-NODE-REGNUM (RSTART-NODE)

SEQ-NODE-CHILD (SEQ-NODE IDX)

SEQ-NODE-CHILDREN (SEQ-NODE)

SEQ-NODE-NUMCHILDREN (SEQ-NODE)

SEQ-NODE-P (NODE)

SPECCLASS-NODE-CLASS (SPECCLASS-NODE)

SPECCLASS-NODE-NEGATED-P (SPECCLASS-NODE)

SPECCLASS-NODE-P (NODE)

START-ANCHOR-NODE-P (NODE)

STRING-NODE-P (NODE)

STRING-NODE-STRING (STRING-NODE)

SUCCESS-NODE-P (NODE)

SUCCESS-NODE-RC (SUCCESS-NODE)

Private

CLOSURE-INFO-INITFN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CLOSURE-INFO-LINKFN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CLOSURE-INFO-MATCHFN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

EXPAND-CHAR-CLASS (CHARS)

Expand an encoded char class into an explicit enumeration of all the chars, e.g. 'a-fA-F' --> 'abcdefABCDEF'.

GET-SPEC-PAT-FXN (PATCLASS)

Return the function to test for the special pattern?

MATCHER-ACCEPTFN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MATCHER-MATCHEXPR (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MATCHER-MATCHSTR (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MATCHER-SIMPLE-STRING-MATCHFN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MATCHER-STRING-MATCHFN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ODIGITP (CH)

Is this character an octal digit?

PUNCTP (CH)

Is this character a punctuation mark?

RE-SCANNER-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RE-SCANNER-MODE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RE-SCANNER-POS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RE-SCANNER-REGNUM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RE-SCANNER-STR (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RE-SCANNER-UNGOT-TOKEN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RE-SCANNER-UNGOT-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SHOW-TOKENS (STR)

Parse a string regex expression into a regex parse tree.

SPACEP (CH)

Is this character some type of whitespace?

WORTH-ALT-CASE-PARTITIONING-P (NUM-CHILDREN NUM-UNKNOWN-CHAR-SETS NUM-KNOWN-CHAR-SETS)

Is it worth partitioning an alt into a case-alt?

XDIGITP (CH)

Is this character a hexidecimal digit?

Undocumented

ADD-INSTR (STATENUM INSTR)

ALLOC-INSTR

ANY-NODE-P (NODE)

APPEND-STRINGS (STRINGS)

CANONICALIZE (TREE)

CANONICALIZE-ONCE (NODE)

CASEALT-NODE-CHILDREN (CASEALT-NODE)

CASEALT-NODE-NUMCHILDREN (CASEALT-NODE)

CASEALT-NODE-P (NODE)

CHAR-CLASS-SEQ-P (SEQ)

CHAR-OR-CLASS-NODE-P (NODE)

CLASSSEQ-NODE-P (NODE)

CLASSSEQ-NODE-SEQ (CLASSSEQ-NODE)

SETFCLOSURE-INFO-INITFN (NEW-VALUE INSTANCE)

SETFCLOSURE-INFO-LINKFN (NEW-VALUE INSTANCE)

SETFCLOSURE-INFO-MATCHFN (NEW-VALUE INSTANCE)

CLOSURE-INFO-P (OBJECT)

COERCETOSTRING (X)

COMBINE-ALT-CHARCLASS (NODES)

COMBINE-SEQUENCE-TEXT (NODES)

COMPILE-EXPR-TO-MATCHER (PARSE-TREE &OPTIONAL STR)

COMPILE-EXPR-TO-MATCHFN (PARSE-TREE &KEY (SIMPLIFYP T))

COMPUTE-MAX-REGNUM (NODE)

CONTAINS-LOOPING-PATTERN-P (TREE)

CONTAINS-REGISTERS-P (TREE)

COPY-CLOSURE-INFO (INSTANCE)

COPY-MATCHER (INSTANCE)

COPY-RE-SCANNER (INSTANCE)

EMIT-ALT (CHILD-NODES NEXT)

EMIT-CASEALT (CHILD-NODES NEXT)

EMIT-GREEDY-KLEENE-FULL-TERMCHECK (CHILD-NODE NEXT)

EMIT-GREEDY-KLEENE-NO-TERMCHECK (CHILD-NODE NEXT)

EMIT-GREEDY-KLEENE-SIMPLE-TERMCHECK (CHILD-NODE NEXT)

EMIT-INSTR (NODE NEXT)

EMIT-LOOKAHEAD (CHILD-NODE NEXT)

EMIT-NGKLEENE-FULL-TERMCHECK (CHILD-NODE NEXT)

EMIT-NGKLEENE-NO-TERMCHECK (CHILD-NODE NEXT)

EMIT-NGKLEENE-SIMPLE-TERMCHECK (CHILD-NODE NEXT)

EMIT-NLOOKAHEAD (CHILD-NODE NEXT)

EMIT-SEQUENCE (CHILDREN NEXT)

ENDWORD-NODE-P (NODE)

EXPAND-RANGE (GREEDYP LOWBOUND HIGHBOUND NODE)

FIX-ESCAPE-CHAR (CHR)

FLATTEN-ALT (NODES)

FLATTEN-SEQUENCE (NODES)

GEN-ALT-2-FULL-TERMCHECK-CLOSURE (NEXT1 NEXT2 &AUX (FIRSTTIMEP T) (SEEN1 (MAKE-HASH-TABLE)) (SEEN2 (MAKE-HASH-TABLE)))

GEN-ALT-2-NO-TERMCHECK-CLOSURE (NEXT1 NEXT2)

GEN-ALT-2-SIMPLE-TERMCHECK-1-CLOSURE (NEXT1 NEXT2 &AUX (OLDPOS -1))

GEN-ALT-2-SIMPLE-TERMCHECK-2-CLOSURE (NEXT1 NEXT2 &AUX (OLDPOS -1))

GEN-ALT-NO-TERMCHECK-CLOSURE (NUM-NEXTS NEXTS)

GEN-ANY-CLOSURE (NEXT)

GEN-BACKMATCH-CLOSURE (REGNUM NEXT)

GEN-CASEALT-CLOSURE (NUM-JUMP-ENTRIES JMPTBL)

GEN-CCLASS-2-CLOSURE (CHR1 CHR2 NEXT)

GEN-CCLASS-2-GREEDY-KLEENE-CLOSURE (CHR1 CHR2 NEXT)

GEN-CCLASS-CLOSURE (CHRS NEXT)

GEN-CCLASS-GREEDY-KLEENE-CLOSURE (CHRS NEXT)

GEN-CHAR-CLOSURE (CHR NEXT)

GEN-CHAR-GREEDY-KLEENE-CLOSURE (CHR NEXT)

GEN-CLASSSEQ-CLOSURE (LEN CHRCLASSES NEXT)

GEN-CLOSURE (OPCODE ARGS)

GEN-CLOSURES (CPSCODE)

GEN-ENDANCHOR-CLOSURE (NEXT)

GEN-ENDWORD-CLOSURE (NEXT)

GEN-HOOK-CLOSURE (HOOKFN NEXT)

GEN-INSTR-LIST (TREE)

GEN-LEFT-RSTART-CLOSURE (REGNUM NEXT)

GEN-LOOKAHEAD-CLOSURE (CHILDFN NEXT)

GEN-NLOOKAHEAD-CLOSURE (CHILDFN NEXT)

GEN-NOT-CCLASS-2-CLOSURE (CHR1 CHR2 NEXT)

GEN-NOT-CCLASS-2-GREEDY-KLEENE-CLOSURE (CHR1 CHR2 NEXT)

GEN-NOT-CCLASS-CLOSURE (CHRS NEXT)

GEN-NOT-CCLASS-GREEDY-KLEENE-CLOSURE (CHRS NEXT)

GEN-NOT-CHAR-CLOSURE (CHR NEXT)

GEN-NOT-CHAR-GREEDY-KLEENE-CLOSURE (CHR NEXT)

GEN-NOT-SPECCLASS-CLOSURE (CLASSFN NEXT)

GEN-NOT-SPECCLASS-GREEDY-KLEENE-CLOSURE (CLASSFN NEXT)

GEN-REND-CLOSURE (REGNUM NEXT)

GEN-RIGHT-RSTART-CLOSURE (REGNUM NEXT)

GEN-SPECCLASS-CLOSURE (CLASSFN NEXT)

GEN-SPECCLASS-GREEDY-KLEENE-CLOSURE (CLASSFN NEXT)

GEN-STARTANCHOR-CLOSURE (NEXT)

GEN-STARTWORD-CLOSURE (NEXT)

GEN-STR-GREEDY-KLEENE-CLOSURE (LEN PATSTR NEXT)

GEN-STRING-CLOSURE (LEN PATSTR NEXT)

GEN-SUCCESS-CLOSURE (RC)

GENERATE-CHAR-RANGE (STRM START END)

GET-DISCRIMINANT-CHARS-ALIST (NODE)

HOIST-ALT-ENDS (NODES)

HOIST-ALT-PREFIX (NODES)

HOIST-ALT-SUFFIX (NODES)

IMPROVE (TREE)

IMPROVE-ONCE (NODE)

LOOKAHEAD-NODE-EXPR (LOOKAHEAD-NODE)

LOOKAHEAD-NODE-P (NODE)

MAKE-ANCHORED-MATCHER (MATCHFN)

MAKE-ANY-NODE

MAKE-CASEALT-JMPTABLE (JUMPS)

MAKE-CASEALT-NODE-ARGS (&REST CHILD-NODES)

MAKE-CASEALT-NODE-LIST (CHILD-NODES)

MAKE-CLASSSEQ-NODE (SEQ)

MAKE-CLOSURE-INFO (&KEY ((MATCHFN DUM434) NIL) ((INITFN DUM435) NIL) ((LINKFN DUM436) NIL))

MAKE-DISCRIMINANT-CHAR-ALIST (NODES &AUX ALIST)

MAKE-ENDWORD-NODE

MAKE-INIT-CLOSURE (RESET-FNS NEXT)

MAKE-LOOKAHEAD-NODE (EXPR)

MAKE-MATCHER (&KEY ((SIMPLE-STRING-MATCHFN DUM513) NIL) ((STRING-MATCHFN DUM514) NIL) ((NUMREGS DUM515) NIL) ((MATCHSTR DUM516) NIL) ((MATCHEXPR DUM517) NIL) ((ACCEPTFN DUM518) NIL))

MAKE-NLOOKAHEAD-NODE (EXPR)

MAKE-RE-SCANNER (&KEY ((STR DUM384) ) ((POS DUM385) 0) ((END DUM386) 0) ((MODE DUM387) 'IN-REGEX) ((REGNUM DUM388) 0) ((UNGOT-TOKEN DUM389) NIL) ((UNGOT-VALUE DUM390) NIL))

MAKE-STARTWORD-NODE

MATCH-STR-ALL-PARMS (MATCHER CANDSTR REGS START LENGTH START-IS-ANCHOR END-IS-ANCHOR ACCEPTFN HOOKS)

SETFMATCHER-ACCEPTFN (NEW-VALUE INSTANCE)

SETFMATCHER-MATCHEXPR (NEW-VALUE INSTANCE)

SETFMATCHER-MATCHSTR (NEW-VALUE INSTANCE)

SETFMATCHER-SIMPLE-STRING-MATCHFN (NEW-VALUE INSTANCE)

SETFMATCHER-STRING-MATCHFN (NEW-VALUE INSTANCE)

NEWLY-COMPILED-EXPR-MATCHER (REGEXPR)

NEWLY-COMPILED-STR-MATCHER (PATSTR)

NEXT (SCANNER)

NEXTCHAR (SCANNER)

NLOOKAHEAD-NODE-EXPR (NLOOKAHEAD-NODE)

NLOOKAHEAD-NODE-P (NODE)

NULLABLE-PATTERN-P (NODE)

OBVIOUSLY-NULLABLE-PATTERN (TREE)

OPTIMIZE-REGEX-TREE (TREE)

PARSE-CHAR-CLASS (TOKEN VALUE SCANNER)

PARSE-CHAR-CLASS-CONTENTS (TOKEN VALUE SCANNER &AUX LST)

PARSE-CONCAT (TOKEN VALUE SCANNER)

PARSE-GROUP (TOKEN VALUE SCANNER)

PARSE-QUANT (TOKEN VALUE SCANNER)

PARSE-REGEX (TOKEN VALUE SCANNER)

PARSE-STD-CHAR-CLASS (IN)

PARSE-TERM (TOKEN VALUE SCANNER)

PARSE-UNION (TOKEN VALUE SCANNER)

PARTITION-CHARCLASS-ALT (NODES)

PARTITION-CHARCLASS-SEQUENCE (SEQ)

PARTITION-ON-LEADING-CHAR (CHILDREN)

PARTITION-STRING-SEQUENCE (SEQ)

POSITIVE-CHARCLASS-NODE-P (NODE)

QUANTIFY (TOKEN VALUE EXPR)

RE-SCANNER (STR &OPTIONAL (START 0) (LENGTH (LENGTH STR)))

SETFRE-SCANNER-END (NEW-VALUE INSTANCE)

SETFRE-SCANNER-MODE (NEW-VALUE INSTANCE)

RE-SCANNER-P (OBJECT)

SETFRE-SCANNER-POS (NEW-VALUE INSTANCE)

SETFRE-SCANNER-REGNUM (NEW-VALUE INSTANCE)

SETFRE-SCANNER-STR (NEW-VALUE INSTANCE)

SETFRE-SCANNER-UNGOT-TOKEN (NEW-VALUE INSTANCE)

SETFRE-SCANNER-UNGOT-VALUE (NEW-VALUE INSTANCE)

RESOLVE-INITFN (CLOSURE-VEC INSTR-NUM)

RESOLVE-INSTR (CLOSURE-VEC INSTR-NUM)

RESOLVE-LINKFN (CLOSURE-VEC INSTR-NUM)

SAFER-SOME (FXN LST)

SCAN-NUM (SCANNER)

SCAN-RANGE-BOUNDS (SCANNER)

SCAN-STR-ALL-PARMS (MATCHER STR REGS START LENGTH START-IS-ANCHOR END-IS-ANCHOR ACCEPTFN HOOKS)

SELECT-ALT-INSTRS (CHILDREN)

SELECT-CASEALT-INSTR (CHILDREN)

SELECT-CHAR-INSTR (CHR)

SELECT-CHARCLASS-INSTR (CHARS)

SELECT-CLASSSEQ-INSTR (CLASSSEQ)

SELECT-GREEDY-KLEENE-INSTR (CHILD &AUX (NULLPAT (NULLABLE-PATTERN-P CHILD)) (LOOPPAT (CONTAINS-LOOPING-PATTERN-P CHILD)))

SELECT-GREEDY-OPTIONAL-INSTR (CHILD)

SELECT-INSTRUCTIONS (NODE)

SELECT-NEGATED-CHARCLASS-INSTR (CHARS)

SELECT-NEGATED-SPECCLASS-INSTR (CLASS)

SELECT-NONGREEDY-KLEENE-INSTR (CHILD)

SELECT-NONGREEDY-OPTIONAL-INSTR (CHILD)

SELECT-SEQUENCE-INSTRS (CHILDREN)

SELECT-SPECCLASS-INSTR (CLASS)

SELECT-STRING-INSTR (STR)

SEQ-BUTLAST (NODE)

SEQ-FIRST (NODE)

SEQ-FIRST-CHAR (NODE)

SEQ-LAST (NODE)

SEQ-REST (NODE)

SIMPLIFY (TREE)

SIMPLIFY-ONCE (NODE)

SORT-LC-PRED (A B)

SPECIAL-CLASS (CHARS)

SPLIT-ALTS (TREE)

SPLIT-ALTS-AUX (NODE)

STARTWORD-NODE-P (NODE)

STRING-SEQ-P (SEQ)

SUBALT-IF-NECESSARY (CASEALT-ARM)

TESTCOMP (STR)

TESTMATCH (STR PAT &KEY HOOKS)

TEXT-NODE-P (NODE)

TREE-ANY (FXN TREE)

UNCACHED-COMPILE-EXPR (REGEXPR &OPTIONAL STR)

UNCACHED-COMPILE-STR (PATSTR)

UNGET (SCANNER TOKEN VALUE)

UNGETCHAR (SCANNER)

UNREGISTER (NODE)

WORDCHARP (CH)

MACRO

Public

Undocumented

DEFREGEX (NAME PATSTR &REST REST)

MACROEXPAND-REGEX-EXPR (REGEX-EXPR)

Private

Undocumented

MAKE-NONTEXT-CLOSURE (&KEY MATCHER INITIALIZER LINKER)

MAKE-TEXT-CLOSURE (&KEY MATCHER INITIALIZER LINKER)

VARIABLE

Private

Undocumented

*ALLOW-BACKMATCH*

*ALLOW-NONGREEDY-QUANTIFIERS*

*ALLOW-NONREGISTER-GROUPS*

*ALLOW-RANGEMATCH*

*DOT-MATCHES-NEWLINE*

*ESCAPE-SPECIAL-CHARS*

*FORCE-SAFE-MATCH*

*MATCH-SIMPLE-STRINGS-ONLY*

*PATTERN-CACHE*

*REGEX-COMPILE-VERBOSE*

*REGISTERS-MATCH-RIGHTMOST*

+SPECIAL-CLASS-NAMES+

CLASS

Public

Undocumented

MATCHER

Private

Undocumented

CLOSURE-INFO

RE-SCANNER (STR &OPTIONAL (START 0) (LENGTH (LENGTH STR)))

CONSTANT

Private

+MAX-REGEX-STR-CACHE+

Max number of entries in the regex compiler cache.