Common Lisp Package: COM.INFORMATIMAGO.COMMON-LISP.REGEXP.REGEXP-POSIX

NOT COMPLETE YET. This package implement POSIX Regular Expressions in Common-Lisp. This is interesting because it's available on any Common-Lisp platform while external C regexp libraries or internals are available or not, and not always implement these same syntax or semantic. Posix Regexp implemented in Common-Lisp. See specifications at: http://www.opengroup.org/onlinepubs/007904975/basedefs/xbd_chap09.html This is a strict implementation that will work both in clisp (Common-Lisp) and emacs (with cl and pjb-cl Common-Lisp extensions). This implementation is entirely in lisp, contrarily to what regexp packages are available under clisp or emacs. Thus it has the advantage of portability and availability (you don't have to compile or link a lisp system written in some barbarous language, and you get the same regexp features in all programs including this module). License: AGPL3 Copyright Pascal J. Bourguignon 2002 - 2012 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses/>

README:

FUNCTION

Public

MATCH (REGEXP STRING &OPTIONAL START END)

Common-Lisp: This function returns as first value a match structure containing the indices of the start and end of the first match for the regular expression REGEXP in STRING, or nil if there is no match. If START is non-nil, the search starts at that index in STRING. If END is non-nil, only (subseq STRING START END) is considered. The next values are match structures for every '(...)' construct in REGEXP, in the order that the open parentheses appear in REGEXP. start: the first character of STRING to be considered (defaults to 0) end: the after last character of STRING to be considered (defaults to (length string)). RETURN: index of start of first match for REGEXP in STRING, nor nil.

MATCH-END (INSTANCE)

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

MATCH-START (INSTANCE)

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

MATCH-STRING (STRING MATCH)

Extracts the substring of STRING corresponding to a given pair of start and end indices. The result is shared with STRING. If you want a freshly consed string, use copy-string or (coerce (match-string ...) 'simple-string).

RE-NSUB (INSTANCE)

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

REGCOMP (PATTERN &KEY (EXTENDED NIL) (IGNORE-CASE NIL) (NOSUB NIL) (NEWLINE NIL))

RETURN: A regex-t representing the compiled regular expression PATTERN. RAISE: An ERROR condition, in case of syntax error.

REGEXEC (REGEX STRING &KEY (NMATCH NIL) (BOL T) (EOL T))

RETURN: match ; (or (not match) (null nmatch) (zerop nmatch) (re-nosub regex)) ==> nil (eq t nmatch) ==> A vector of regmatch-t with (1+ (re-nsub regex)) items (numberp nmatch) ==> A vector of regmatch-t with nmatch items. WARNING: Entry #0 of the result vector is always the start and end of the whole expression. To get the start and end of the last subexpression you need to pass :nmatch (1+ (re-nsub regex)) [or T].

RM-EO (INSTANCE)

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

RM-SO (INSTANCE)

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

Undocumented

SETFMATCH-END (NEW-VALUE INSTANCE)

SETFMATCH-START (NEW-VALUE INSTANCE)

SETFRE-NSUB (NEW-VALUE INSTANCE)

REGEXP-QUOTE (STRING)

SETFRM-EO (NEW-VALUE INSTANCE)

SETFRM-SO (NEW-VALUE INSTANCE)

Private

BE-BRACKET-EXPRESSION (SC)

DO: Parses a bracket-expression. RETURN: (rk:matching expression...) or (rk:non-matching expression...) or (:error message) or nil. NOTES: bracket_expression : '[' matching_list ']' | '[' nonmatching_list ']' ; matching_list : bracket_list ; nonmatching_list : '^' bracket_list ;

BE-BRACKET-LIST (SC)

DO: Parses a bracket-list. RETURN: (:follow-list expression...) or nil. NOTES: bracket_list : follow_list | follow_list '-' ;

BE-CHARACTER-CLASS (SC)

DO: Parses a character class RETURN: (rk:character-class class-name) or (:error message) or nil if not looking at '[:'. NOTES: character_class : Open_colon class_name Colon_close ;

BE-COLLATING-SYMBOL (SC)

DO: Parses a collating-symbol. RETURN: (rk:collating-symbol coll-elem) or (:error message) or nil if not looking at '[='. NOTE: collating_symbol : Open_dot COLL_ELEM_SINGLE Dot_close | Open_dot COLL_ELEM_MULTI Dot_close | Open_dot META_CHAR Dot_close ; COLL_ELEM_SINGLE and META_CHAR form a partition of all characters.

BE-END-RANGE (SC)

DO: Parses an end-range. RETURN: character or (rk:collating-symbol coll-elem) NOTES: end_range : COLL_ELEM_SINGLE | collating_symbol ; COLL_ELEM_SINGLE Any single-character collating element, unless it is a META_CHAR. META_CHAR One of the characters: ^ When found first in a bracket expression - When found anywhere but first (after an initial '^' , if any) or last in a bracket expression, or as the ending range point in a range expression ] When found anywhere but first (after an initial '^' , if any) in a bracket expression

BE-EQUIVALENCE-CLASS (SC)

DO: Parses an equivalence class. RETURN: (rk:equivalence-class coll-elem) or (:error message) or nil if not looking at '[='. NOTE: equivalence_class : Open_equal COLL_ELEM_SINGLE Equal_close | Open_equal COLL_ELEM_MULTI Equal_close ; META_CHAR One of the characters: ^ When found first in a bracket expression - When found anywhere but first (after an initial '^' , if any) or last in a bracket expression, or as the ending range point in a range expression ] When found anywhere but first (after an initial '^' , if any) in a bracket expression Inside an equivalence-class: ^ is not first in a bracket expression ==> ^ is not meta-char ] is not first in a bracket expression ==> ] is meta-char - isn't first, shouldn't be last, isn't ending a range ==> - is meta-char

BE-EXPRESSION-TERM (SC)

DO: RETURN: (or (rk:equivalence-class ec) (rk:character-class cc) (rk:collating-symbol cs) character (rk:range start end) nil) NOTES: expression_term : single_expression | range_expression ;

BE-FOLLOW-LIST (SC)

DO: RETURN: (:follow-list expression...) or (:error message) or nil follow_list : expression_term | follow_list expression_term ;

BE-RANGE-EXPRESSION (SC)

DO: Parses a range-expression. RETURN: (rk:range start end) or nil of not looking at a range-expression. NOTES: range_expression : start_range end_range | start_range '-' ;

BE-SINGLE-EXPRESSION (SC)

DO: Parses a single-expression. RETURN: (or (rk:equivalence-class ec) (rk:character-class cc) (rk:collating-symbol cs) character nil) NOTES: single_expression : end_range | character_class | equivalence_class ;

BE-START-RANGE (SC)

DO: Parses a start-range. RETURN: character or (rk:collating-symbol coll-elem) or nil if not looking at a start-range. NOTES: start_range : end_range '-' ;

BRE-BASIC-REG-EXP (SC)

basic_reg_exp : RE_expression | L_ANCHOR | R_ANCHOR | L_ANCHOR R_ANCHOR | L_ANCHOR RE_expression | RE_expression R_ANCHOR | L_ANCHOR RE_expression R_ANCHOR ;

BRE-DUPL-SYMBOL (SC)

DO: Parse RETURN: (rk:repeat min max) with min,max in (or rk:infinity (integer 0)) or (:error message) or nil if not looking at a re-dupl-symbol. NOTES: RE_dupl_symbol : '*' | Back_open_brace DUP_COUNT Back_close_brace | Back_open_brace DUP_COUNT ',' Back_close_brace | Back_open_brace DUP_COUNT ',' DUP_COUNT Back_close_brace ;

BRE-EXPRESSION (SC)

RE_expression : simple_RE | RE_expression simple_RE ;

BRE-NONDUPL-RE (SC)

nondupl_RE : one_char_or_coll_elem_RE | Back_open_paren RE_expression Back_close_paren | BACKREF ;

BRE-ONE-CHAR-OR-COLL-ELEM (SC)

DO: Parses s single character or a coll-elem regexp. RETURN: (or (rk:matching ...) (rk:non-matching ...) rk:any character) NOTES: one_char_or_coll_elem_RE : ORD_CHAR | QUOTED_CHAR | '.' | bracket_expression ; QUOTED_CHARĀ  ^ . * [ $ \ ORD_CHAR any but SPEC_CHAR SPEC_CHAR For basic regular expressions, one of the following special characters: . Anywhere outside bracket expressions Anywhere outside bracket expressions [ Anywhere outside bracket expressions ^ When used as an anchor (see BRE Expression Anchoring ) or when first in a bracket expression $ When used as an anchor * Anywhere except first in an entire RE, anywhere in a bracket expression, directly following '(' , directly following an anchoring '^'. ==> ORD_CHAR excludes . [ and * but when first of the expression.

BRE-SIMPLE-RE (SC)

simple_RE : nondupl_RE | nondupl_RE RE_dupl_symbol ;

COMPILE-BRACKET-EXPRESSION (REGEXP)

RETURN: The charset described by the regex, either a rk:matching or a rk:non-matching. The charset is not complemented for rk:non-matching, this should be done by match function. regexp --> (or (rk:matching mexpr...) (rk:non-matching mexpr...) mexpr --> (or character (rk:collating-symbol string/collating-element) (rk:equivalence-class string/equivalence-class) (rk:character-class string/class-name) (rk:range (or coll-elem-single collating-symbol)/start (or coll-elem-single collating-symbol)/end)) NOTE: We don't compile bracket expressions for other atoms than characters!

COMPILE-REGEXP (REGEXP)

RETURN: A rnode representing the compiled regexp. regexp --> (or character rk:any rk:l-anchor rk:r-anchor (rk:matching mexpr...) (rk:non-matching mexpr...) (rk:backref integer) (rk:subexp regex) (rk:sequence regex...) (rk:repeat integer (or integer rk:infinity) bexp) (rk:alternative regex...))

COUNT-SUBEXP (REGEXP)

RETURN: The number of subexp found in regexp

ERE-BRANCH (SC)

ERE_branch : ERE_expression | ERE_branch ERE_expression ;

ERE-DUPL-SYMBOL (SC)

DO: Parse RETURN: (rk:repeat min max) with min,max in (or rk:infinity (integer 0)) or (:error message) or nil if not looking at a re-dupl-symbol. NOTES: ERE_dupl_symbol : '*' | '+' | '?' | '{' DUP_COUNT '}' | '{' DUP_COUNT ',' '}' | '{' DUP_COUNT ',' DUP_COUNT '}' ;

ERE-EXPRESSION (SC)

ERE_expression : one_char_or_coll_elem_ERE | '^' | '$' | '(' extended_reg_exp ')' | ERE_expression ERE_dupl_symbol ;

ERE-EXTENDED-REG-EXP (SC)

extended_reg_exp : ERE_branch | extended_reg_exp '|' ERE_branch ;

ERE-ONE-CHAR-OR-COLL-ELEM (SC)

DO: Parses s single character or a coll-elem regexp. RETURN: (or (rk:matching ...) (rk:non-matching ...) rk:any character) NOTES: one_char_or_coll_elem_ERE : ORD_CHAR | QUOTED_CHAR | '.' | bracket_expression ; QUOTED_CHARĀ  ^ . [ $ ( ) | * + ? { \ ORD_CHAR any but SPEC_CHAR SPEC_CHAR For basic regular expressions, one of the following special characters: . Anywhere outside bracket expressions Anywhere outside bracket expressions [ Anywhere outside bracket expressions ^ When used as an anchor (see BRE Expression Anchoring ) or when first in a bracket expression $ When used as an anchor * Anywhere except first in an entire RE, anywhere in a bracket expression, directly following '(' , directly following an anchoring '^'. ^ . [ $ ( ) | * + ? { ==> ORD_CHAR excludes . [ and * but when first of the expression.

MAKE-CHARSET

RETURN: An instance of a subclass of charset, selected according to the value of char-code-limit.

PJB-RE-SPLIT-STRING (STRING &OPTIONAL SEPARATORS)

DOES: Splits STRING into substrings where there are matches for SEPARATORS. RETURNS: A list of substrings. separators: A regexp matching the sub-string separators. Defaults to "[ ftnrv]+". NOTE: Current implementation only accepts as separators a literal string containing only one character.

RANGE-MAX (INSTANCE)

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

RANGE-MIN (INSTANCE)

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

RANGE-SET-SEEK (RS N)

RETURN: The last cons whose cdr+1 is >= n.

RE-ENV (INSTANCE)

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

RE-EXTENDED (INSTANCE)

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

RE-IGNORE-CASE (INSTANCE)

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

RE-INTEGER (SC)

DO: Parses an integer. RETURN: The integer, or NIL.

RE-NEWLINE (INSTANCE)

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

RE-NOSUB (INSTANCE)

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

RENV-BOL (INSTANCE)

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

RENV-EOL (INSTANCE)

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

RENV-EQUALF (INSTANCE)

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

RENV-LENGTH (INSTANCE)

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

RENV-NEWLINE (INSTANCE)

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

RENV-NEWLINEPF (INSTANCE)

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

RENV-POSITION (INSTANCE)

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

RENV-REGEXP (INSTANCE)

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

RENV-SEQUENCE (INSTANCE)

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

RENV-SUBEXPS (INSTANCE)

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

RMATCH-B-ANCHOR (NODE STATE ENV)

Beginning of string anchor.

RMATCH-E-ANCHOR (NODE STATE ENV)

End of string anchor.

RMATCH-L-ANCHOR (NODE STATE ENV)

Beginning of line anchor.

RMATCH-R-ANCHOR (NODE STATE ENV)

End of line anchor.

RMATCH-REPEAT-GREEDY (NODE STATE ENV)

DO: match min to max repeatition, greatest first.

RMATCH-REPEAT-SHY (NODE STATE ENV)

DO: match min to max repeatition, smallest first.

RNODE-CHILDREN (INSTANCE)

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

RNODE-MATCHF (INSTANCE)

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

RNODE-TOKEN (INSTANCE)

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

RSTATE-END (INSTANCE)

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

RSTATE-START (INSTANCE)

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

RSTATE-TRY (INSTANCE)

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

SC-ADVANCE (SC &OPTIONAL (INCREMENT 1))

PRE: (= p (sc-position sc)) POST: (= (min (sc-length sc) (+ p increment)) (sc-position sc)) RETURN: The character at position p+increment or nil if EOS.

SC-AFTER-NEXT-CHAR (SC)

RETURN: The after next character, or nil if EOS.

SC-BRACKET-POSITION (INSTANCE)

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

SC-CURR-CHAR (SC)

RETURN: The current character, or nil if EOS.

SC-EXPRESSION-START (INSTANCE)

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

SC-LOOKING-AT (SC SUBSTRING)

SC-NEXT-CHAR (SC)

RETURN: The next character, or nil if EOS.

SC-POSITION (INSTANCE)

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

SC-SCAN-TO (SC SUBSTRING)

RETURN: the substring of (sc-string sc) starting from current position to the position just before the first occurence of the substring found from this position. PRE: (= p (sc-position sc)) POST: (and (<= p (sc-position sc)) (or (and (< (sc-position sc) (length (sc-string sc))) (string= substring (substring (sc-string sc) p (sc-position sc)))) (= (sc-position sc) (length (sc-string sc)))) (forall i between p and (1- (sc-position sc)) (string/= substring (substring (sc-string sc) i (+ i (length substring))))))

SC-STRING (INSTANCE)

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

Undocumented

COPY-MATCH (INSTANCE)

COPY-RANGE (INSTANCE)

COPY-REGEX-T (INSTANCE)

COPY-REGMATCH-T (INSTANCE)

COPY-RENV (INSTANCE)

COPY-RNODE (INSTANCE)

COPY-RSTATE (INSTANCE)

COPY-SC (INSTANCE)

ERR (&REST ARGS)

ERRORP (EXPR)

FIND-MATCH-FUNCTION (NODE)

LENGTH>1 (LIST)

LESSP (A B)

LIGHTEN (OBJ)

MAKE-MATCH (&KEY ((START DUM4189) NIL) ((END DUM4190) NIL))

MAKE-RANGE (&KEY ((MIN DUM2390) NIL) ((MAX DUM2391) NIL))

MAKE-RANGE-SET (&OPTIONAL (RANGE-LIST NIL))

MAKE-RANGE-SET-VECTOR (RS)

MAKE-RANGE-VECTOR (&REST ARGUMENTS)

MAKE-REGEX-T (&KEY ((NSUB DUM4331) 0) ((ENV DUM4332) NIL) ((EXTENDED DUM4333) NIL) ((IGNORE-CASE DUM4334) NIL) ((NOSUB DUM4335) NIL) ((NEWLINE DUM4336) NIL))

MAKE-REGMATCH-T (&KEY ((SO DUM4461) -1) ((EO DUM4462) -1))

MAKE-RENV (&KEY ((EQUALF DUM3201) #'EQUAL) ((NEWLINEPF DUM3202) (COMPILE NIL (LAMBDA (CH) (EQL CH)))) ((SEQUENCE DUM3203) ) ((LENGTH DUM3204) 0) ((POSITION DUM3205) 0) ((SUBEXPS DUM3206) NIL) ((REGEXP DUM3207) NIL) ((BOL DUM3208) T) ((EOL DUM3209) T) ((NEWLINE DUM3210) T))

MAKE-RNODE (&KEY ((MATCHF DUM3012) NIL) ((TOKEN DUM3013) NIL) ((CHILDREN DUM3014) NIL))

MAKE-RSTATE (&KEY ((TRY DUM3088) NIL) ((START DUM3089) 0) ((END DUM3090) 0))

MAKE-SC (&KEY ((STRING DUM34) ) ((POSITION DUM35) 0) ((BRACKET-POSITION DUM36) 0) ((EXPRESSION-START DUM37) NIL))

MATCH-P (OBJECT)

PARSE-BASIC-RE (RESTRING)

PARSE-EXTENDED-RE (RESTRING)

PJB-RE-COLLECT-GROUPS (&REST ARGUMENTS)

PJB-RE-DECORATE-TREE (&REST ARGUMENTS)

PJB-RE-INIT (&REST ARGUMENTS)

PJB-RE-MATCH (&REST ARGUMENTS)

PJB-RE-PARSE-WHOLE-REGEXP (&REST ARGUMENTS)

PJB-RE-SLOT-BEGIN (&REST ARGUMENTS)

PJB-RE-SLOT-END (&REST ARGUMENTS)

RANGE-AFTER-LAST (RANGE)

RANGE-CONTAINS-P (RANGE N)

SETFRANGE-MAX (NEW-VALUE INSTANCE)

SETFRANGE-MIN (NEW-VALUE INSTANCE)

RANGE-P (OBJECT)

RANGE-SET-ADD-NUMBER (RS N)

RANGE-SET-CONTAINS-P (RS N)

RANGE-SET-COPY (RS &OPTIONAL (COPY NIL))

RANGE-SET-GUARD-P (RS)

RANGE-SET-UNION (RSA RSB &OPTIONAL (MIN NIL) (MAX NIL) (UNION NIL))

RCCOMPARE (RANGE CC)

SETFRE-ENV (NEW-VALUE INSTANCE)

SETFRE-EXTENDED (NEW-VALUE INSTANCE)

SETFRE-IGNORE-CASE (NEW-VALUE INSTANCE)

SETFRE-NEWLINE (NEW-VALUE INSTANCE)

SETFRE-NOSUB (NEW-VALUE INSTANCE)

REGEX-T-P (OBJECT)

REGMATCH-T-P (OBJECT)

SETFRENV-BOL (NEW-VALUE INSTANCE)

SETFRENV-EOL (NEW-VALUE INSTANCE)

SETFRENV-EQUALF (NEW-VALUE INSTANCE)

SETFRENV-LENGTH (NEW-VALUE INSTANCE)

SETFRENV-NEWLINE (NEW-VALUE INSTANCE)

SETFRENV-NEWLINEPF (NEW-VALUE INSTANCE)

RENV-P (OBJECT)

SETFRENV-POSITION (NEW-VALUE INSTANCE)

SETFRENV-REGEXP (NEW-VALUE INSTANCE)

SETFRENV-SEQUENCE (NEW-VALUE INSTANCE)

RENV-SET-REGEXP (ENV REGEXP)

RENV-SET-SEQUENCE (ENV NEW-SEQ)

SETFRENV-SUBEXPS (NEW-VALUE INSTANCE)

RMATCH-ALTERNATIVE (NODE STATE ENV)

RMATCH-ANY (NODE STATE ENV)

RMATCH-BACKREF (NODE STATE ENV)

RMATCH-ITEM (NODE STATE ENV)

RMATCH-MATCHING (NODE STATE ENV)

RMATCH-NON-MATCHING (NODE STATE ENV)

RMATCH-SEQUENCE (NODE STATE ENV)

RMATCH-SUBEXP (NODE STATE ENV)

SETFRNODE-CHILDREN (NEW-VALUE INSTANCE)

SETFRNODE-MATCHF (NEW-VALUE INSTANCE)

RNODE-P (OBJECT)

SETFRNODE-TOKEN (NEW-VALUE INSTANCE)

RNODE-WALK (NODE FUN)

SETFRSTATE-END (NEW-VALUE INSTANCE)

RSTATE-P (OBJECT)

RSTATE-RETRY (STATE POSITION)

SETFRSTATE-START (NEW-VALUE INSTANCE)

SETFRSTATE-TRY (NEW-VALUE INSTANCE)

SETFSC-BRACKET-POSITION (NEW-VALUE INSTANCE)

SC-EOS (SC)

SETFSC-EXPRESSION-START (NEW-VALUE INSTANCE)

SC-LENGTH (SC)

SC-P (OBJECT)

SETFSC-POSITION (NEW-VALUE INSTANCE)

SETFSC-STRING (NEW-VALUE INSTANCE)

SUBEXP-FILLED-P (SUBEXP)

TEST-RANGE-SET-UNION

MACRO

Private

TRY (&REST CLAUSES)

SYNTAX: (try (initially [sexp|(immediately-then)]...) (then sexp...))

Undocumented

IF^2 (C1 C2 TT TF FT FF)

INVARIANT (CONDITION &BODY BODY)

RNODE-MATCH (NODE STATE ENV)

SUBEXP-CLEAR (SUBEXP)

SUBEXP-END (SUBEXP)

SUBEXP-SET (SUBEXP START END)

SUBEXP-START (SUBEXP)

TOP (STACK)

TRY-ONCE (&BODY BODY)

WITH-RENS (ENV NODE STATE &BODY BODY)

WITH-RENV (ENV &BODY BODY)

WITH-RNODE (NODE &BODY BODY)

WITH-RSTATE (STATE &BODY BODY)

GENERIC-FUNCTION

Private

Undocumented

ADD-CHAR (CHARSET CHARACTER)

ADD-CLASS (CHARSET CHAR-CLASS-NAME)

ADD-RANGE (CHARSET CHAR-MIN CHAR-MAX)

CONTAINS-CHAR-P (CHARSET CHARACTER)

INVERSE (CHARSET)

PARSING-ERROR-ARGUMENTS (CONDITION)

SETFPARSING-ERROR-ARGUMENTS (NEW-VALUE CONDITION)

SLOT-ACCESSOR

Private

Undocumented

BITS (OBJECT)

SETFBITS (NEW-VALUE OBJECT)

CHAR-CLASSES (OBJECT)

SETFCHAR-CLASSES (NEW-VALUE OBJECT)

COMPLEMENTED (OBJECT)

SETFCOMPLEMENTED (NEW-VALUE OBJECT)

RANGE-SET (OBJECT)

SETFRANGE-SET (NEW-VALUE OBJECT)

RANGE-VECTOR (OBJECT)

SETFRANGE-VECTOR (NEW-VALUE OBJECT)

VARIABLE

Private

Undocumented

*CHARACTER-CLASSES*

*MATCH-FUNCTION-ALIST*

CLASS

Public

MATCH (REGEXP STRING &OPTIONAL START END)

This structure stores a (start,end) couple specifying the range matched by a group (or the whole regexp).

REGEX-T

NSUB: Number of parenthesized subexpressions.

REGMATCH-T

SO: Byte offset from start of string to start of substring. EO: Byte offset from start of string of the first character after the end of substring.

Private

CHARSET

An abstract class for a character set. This class defines the interface to whatever charset implementation.

CHARSET-BITMAP

A character set representation based on bit array. This is representation may be used when char-code-limit is 'small'.

CHARSET-RANGE

A character set representation based on binary trees of ranges and additional list of character classes. This is representation may be used when char-code-limit is 'big'.

RENV

An renv gather the environment (variables) used to run a compiled regexp matched, ie. rnode.

RNODE

A rnode represent a compiled regexp node

RSTATE

State data used when matching a rnode.

Undocumented

RANGE

SC

CONDITION

Private

Undocumented

PARSING-ERROR