Common Lisp Package: CL-IRREGSEXP

README:

FUNCTION

Private

CHOICE-LIST (INSTANCE)

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

CONST-VALUE (INSTANCE)

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

DECIDER-DIFFERING-POINT (INSTANCE)

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

DECIDER-END (INSTANCE)

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

DECIDER-PATHS (INSTANCE)

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

PATH-AFTER (INSTANCE)

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

PATH-PREFIX (INSTANCE)

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

SEQ-LIST (INSTANCE)

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

SIMPLIFIER-LAMBDA (INSTANCE)

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

SIMPLIFIER-NAME (INSTANCE)

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

Undocumented

ALL-SPECIALIZED-FUNC-SYMBOLS (FUNC)

BIND-MACRO-EXPANDER (FORM)

BYTE-VECTOR-TO-SIMPLE-BYTE-VECTOR (VAL)

BYTE-VECTOR-TO-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL (VAL)

BYTE-VECTOR-TO-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL-CAREFUL (VAL)

CERTAINLY-NOT-RETURNING (STATEMENTS)

SETFCHOICE-LIST (NEW-VALUE INSTANCE)

CHOICE-OUTPUT-CODE (CHOICE)

CHOICE-OUTPUT-MATCH-UNTIL-CODE (CHOICE)

CHOICE-P (OBJECT)

CHOICE-TO-FAST-DECIDER (CHOICE)

COMPILER-MACROEXPAND-1 (FORM &OPTIONAL ENV)

CONCAT-SYM-PACKAGE (PACKAGE &REST ARGS)

CONST-P (OBJECT)

SETFCONST-VALUE (NEW-VALUE INSTANCE)

COPY-CHOICE (INSTANCE)

COPY-CONST (INSTANCE)

COPY-DECIDER (INSTANCE)

COPY-IRREGSEXP-SEQ (INSTANCE)

COPY-MATCH-END (INSTANCE)

COPY-PATH (INSTANCE)

COPY-SIMPLIFIER (INSTANCE)

SETFDECIDER-DIFFERING-POINT (NEW-VALUE INSTANCE)

SETFDECIDER-END (NEW-VALUE INSTANCE)

DECIDER-LEN (DECIDER)

DECIDER-P (OBJECT)

SETFDECIDER-PATHS (NEW-VALUE INSTANCE)

DECIDER-POSSIBLE (DECIDER I)

DECIDER-SKIP-TABLE (DECIDER)

DEFUN-CONSISTENT-NAMES (NAME)

FAIL

FORCE-LIST (VAL)

FORCE-SEQUENCE (VAL)

FORCE-SIMPLE-VECTOR (V)

FORCE-SIMPLE-VECTOR-CONSISTENT-INTERNAL (V)

FORCE-SIMPLE-VECTOR-CONSISTENT-INTERNAL-CAREFUL (V)

FORCE-TO-TARGET-ELEMENT-TYPE-SIMPLE-BYTE-VECTOR (C)

FORCE-TO-TARGET-ELEMENT-TYPE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL (C)

FORCE-TO-TARGET-ELEMENT-TYPE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL-CAREFUL (C)

FORCE-TO-TARGET-ELEMENT-TYPE-SIMPLE-STRING (C)

FORCE-TO-TARGET-ELEMENT-TYPE-SIMPLE-STRING-CONSISTENT-INTERNAL (C)

FORCE-TO-TARGET-ELEMENT-TYPE-SIMPLE-STRING-CONSISTENT-INTERNAL-CAREFUL (C)

FUNCTION-ABBREVIATION (FORM)

FUNCTION-NAME-P (NAME)

GENERATE-DIGIT-MATCHER (BASE VAR)

GENERATE-INTEGER-MATCHER (&KEY (BASE 10) LEAST LARGEST LENGTH (MAX-LENGTH LENGTH) (MIN-LENGTH LENGTH))

GENERATE-MATCH-BIND (BINDINGS &OPTIONAL ENV)

GENERATE-MIN-IGNORE-NIL (&REST ARGS)

GENERATE-UNSIGNED-MATCHER (&KEY (BASE 10) LARGEST LENGTH (MAX-LENGTH LENGTH) (MIN-LENGTH LENGTH))

MACROEXPAND-AND-COMPILER-MACROEXPAND (FORM &OPTIONAL ENV)

MAKE-CHOICE (&KEY ((LIST DUM36) NIL))

MAKE-CONST (&KEY ((VALUE DUM0) NIL))

MAKE-DECIDER (&KEY ((PATHS DUM184) NIL) ((END DUM185) NIL) ((DIFFERING-POINT DUM186) NIL))

MAKE-MATCH-END (&KEY)

MAKE-PATH (&KEY ((PREFIX DUM146) NIL) ((AFTER DUM147) NIL))

MAKE-SEQ (&KEY ((LIST DUM72) NIL))

MAKE-SIMPLIFIER (&KEY ((NAME DUM108) NIL) ((LAMBDA DUM109) NIL))

MATCH-BIND-MACRO-BODY (LAMBDA-LIST BODY)

MATCH-END-P (OBJECT)

MAYBE-BUILD-FAST-DECIDER (PATHS END)

OPERATOR-ABBREVIATION (FORM)

OUTPUT-FINISH-MATCH-CODE (DECIDER)

OUTPUT-SIMPLIFIED (FORM)

SETFPATH-AFTER (NEW-VALUE INSTANCE)

PATH-AFTER-CODE (PATH)

PATH-P (OBJECT)

SETFPATH-PREFIX (NEW-VALUE INSTANCE)

PATH-SPLIT (PATH LEN)

RACONS (KEY VALUE RALIST)

RALIST-GET (ALIST KEY &KEY (TEST #'EQL))

REPLACE-CONCATENATE-SEQUENCES (PROTOTYPE TOTAL-LENGTH SEQUENCES)

SETFSEQ-LIST (NEW-VALUE INSTANCE)

SEQ-P (OBJECT)

SET-MATCH-BIND-MACRO (NAME FUNCTION)

SETFSIMPLIFIER-LAMBDA (NEW-VALUE INSTANCE)

SETFSIMPLIFIER-NAME (NEW-VALUE INSTANCE)

SIMPLIFIER-P (OBJECT)

SIMPLIFIER-RUN (SIMPLIFIER FORM)

SIMPLIFY (FORM)

SIMPLIFY-SEQ (BODY)

SPECIALIZED-FUNC-SYMBOL (FUNC TYPE)

TO-INT (VAL)

TO-INT-CONSISTENT-INTERNAL (VAL)

TO-INT-CONSISTENT-INTERNAL-CAREFUL (VAL)

UTF8-CHAR-LENGTH (CHAR)

UTF8-DECODE-REALLY (VEC)

UTF8-ENCODE-REALLY (STRING)

MACRO

Public

IF-MATCH-BIND (BINDINGS STRING &OPTIONAL (THEN T) (ELSE NIL))

Perform a match bind, but return ELSE on failure instead of raising match-failed

MATCH-BIND (BINDINGS STRING &BODY BODY)

Try to parse STRING according to BINDINGS. If successful, execute BODY. Otherwise raise match-failed

MATCH-REPLACE-ALL (STRING &BODY MATCH-REPLACEMENTS)

For each (match replacment) in MATCH-REPLACEMENTS replace each value of match with the value of replacement in STRING

MATCH-REPLACE-ONE (STRING &BODY MATCH-REPLACEMENTS)

As match-replace-all but at most one replacement is made

Undocumented

MATCH-SPLIT (PATTERN STRING)

Private

ONCE-ONLY (SPECS &BODY FORMS)

Evaluates FORMS with symbols specified in SPECS rebound to temporary variables, ensuring that each initform is evaluated only once. Each of SPECS must either be a symbol naming the variable to be rebound, or of the form: (symbol initform) Bare symbols in SPECS are equivalent to (symbol symbol) Example: (defmacro cons1 (x) (once-only (x) `(cons ,x ,x))) (let ((y 0)) (cons1 (incf y))) => (1 . 1)

WITH-UNIQUE-NAMES (NAMES &BODY FORMS)

Alias for WITH-GENSYMS.

Undocumented

APPENDF (PLACE &REST LISTS &ENVIRONMENT ENV)

CHECK-LEN-AVAILABLE-SIMPLE-BYTE-VECTOR (LEN)

CHECK-LEN-AVAILABLE-SIMPLE-STRING (LEN)

DEF-MATCH-BIND-MACRO (NAME LAMBDA-LIST &BODY BODY)

DEFSIMPLIFIER (NAME LAMBDA-LIST &BODY BODY)

DEFSIMPLIFIER-GO (NAME LAMBDA-LIST &BODY BODY)

DYNAMIC-LITERAL-SIMPLE-BYTE-VECTOR (V)

DYNAMIC-LITERAL-SIMPLE-STRING (V)

EAT-SIMPLE-BYTE-VECTOR (&OPTIONAL (LEN 1))

EAT-SIMPLE-STRING (&OPTIONAL (LEN 1))

EAT-UNCHECKED-SIMPLE-BYTE-VECTOR (&OPTIONAL (LEN 1))

EAT-UNCHECKED-SIMPLE-STRING (&OPTIONAL (LEN 1))

ELT-TARGET-SIMPLE-BYTE-VECTOR (I)

ELT-TARGET-SIMPLE-STRING (I)

FORCE-TO-TARGET-SEQUENCE-SIMPLE-BYTE-VECTOR (V)

FORCE-TO-TARGET-SEQUENCE-SIMPLE-STRING (V)

LEN-AVAILABLE-SIMPLE-BYTE-VECTOR

LEN-AVAILABLE-SIMPLE-STRING

LITERAL-SIMPLE-BYTE-VECTOR (&WHOLE WHOLE557 &REST UNUSED558)

LITERAL-SIMPLE-STRING (&WHOLE WHOLE727 &REST UNUSED728)

MATCH-ALL (&REST OPTIONS)

MATCH-ANY-SIMPLE-BYTE-VECTOR (&WHOLE WHOLE376 &REST UNUSED377)

MATCH-ANY-SIMPLE-STRING (&WHOLE WHOLE455 &REST UNUSED456)

MATCH-BIND-INTERNAL (ARGS-FOR-WITH-MATCH BINDINGS &BODY BODY &ENVIRONMENT ENV)

MATCH-ELEMENT-RANGE-SIMPLE-BYTE-VECTOR (&WHOLE WHOLE854 &REST UNUSED855)

MATCH-ELEMENT-RANGE-SIMPLE-STRING (&WHOLE WHOLE964 &REST UNUSED965)

MATCH-END-SIMPLE-BYTE-VECTOR (&WHOLE WHOLE2241 &REST UNUSED2242)

MATCH-END-SIMPLE-STRING (&WHOLE WHOLE2335 &REST UNUSED2336)

MATCH-FIXNUM-SIMPLE-BYTE-VECTOR (&REST ARGS)

MATCH-FIXNUM-SIMPLE-STRING (&REST ARGS)

MATCH-FLOAT-SIMPLE-BYTE-VECTOR (&KEY (BASE 10))

MATCH-FLOAT-SIMPLE-STRING (&KEY (BASE 10))

MATCH-INTEGER-SIMPLE-BYTE-VECTOR (&REST ARGS)

MATCH-INTEGER-SIMPLE-STRING (&REST ARGS)

MATCH-MULTIPLE-SIMPLE-BYTE-VECTOR (&WHOLE WHOLE1260 &REST UNUSED1261)

MATCH-MULTIPLE-SIMPLE-STRING (&WHOLE WHOLE1376 &REST UNUSED1377)

MATCH-NOT (&REST MATCHES)

MATCH-ONE-OR-MORE-SIMPLE-BYTE-VECTOR (&WHOLE WHOLE1515 &REST UNUSED1516)

MATCH-ONE-OR-MORE-SIMPLE-STRING (&WHOLE WHOLE1599 &REST UNUSED1600)

MATCH-ONE-WHITESPACE-SIMPLE-BYTE-VECTOR (&WHOLE WHOLE1903 &REST UNUSED1904)

MATCH-ONE-WHITESPACE-SIMPLE-STRING (&WHOLE WHOLE1994 &REST UNUSED1995)

MATCH-POSITIVE-FIXNUM-SIMPLE-BYTE-VECTOR (&REST ARGS)

MATCH-POSITIVE-FIXNUM-SIMPLE-STRING (&REST ARGS)

MATCH-REMAINING-SIMPLE-BYTE-VECTOR

MATCH-REMAINING-SIMPLE-STRING

MATCH-REPLACE-HELPER (STRING &KEY OP AFTER RESULT-INIT MATCH-REPLACEMENTS)

MATCH-UNSIGNED-INTEGER-SIMPLE-BYTE-VECTOR (&REST ARGS)

MATCH-UNSIGNED-INTEGER-SIMPLE-STRING (&REST ARGS)

MATCH-UNTIL-AND-EAT-SIMPLE-BYTE-VECTOR (&REST MATCHES)

MATCH-UNTIL-AND-EAT-SIMPLE-STRING (&REST MATCHES)

MATCH-UNTIL-INTERNAL-SIMPLE-BYTE-VECTOR (&REST MATCHES)

MATCH-UNTIL-INTERNAL-SIMPLE-STRING (&REST MATCHES)

MATCH-UNTIL-SIMPLE-BYTE-VECTOR (&WHOLE WHOLE221 &REST UNUSED222)

MATCH-UNTIL-SIMPLE-STRING (&WHOLE WHOLE287 &REST UNUSED288)

MATCH-ZERO-OR-MORE-SIMPLE-BYTE-VECTOR (&WHOLE WHOLE1706 &REST UNUSED1707)

MATCH-ZERO-OR-MORE-SIMPLE-STRING (&WHOLE WHOLE1793 &REST UNUSED1794)

PEEK-ONE-SIMPLE-BYTE-VECTOR (&OPTIONAL (I 0))

PEEK-ONE-SIMPLE-STRING (&OPTIONAL (I 0))

PEEK-ONE-UNCHECKED-SIMPLE-BYTE-VECTOR (&OPTIONAL (I 0))

PEEK-ONE-UNCHECKED-SIMPLE-STRING (&OPTIONAL (I 0))

PEEK-SIMPLE-BYTE-VECTOR (&OPTIONAL (LEN '(LEN-AVAILABLE-SIMPLE-BYTE-VECTOR)))

PEEK-SIMPLE-STRING (&OPTIONAL (LEN '(LEN-AVAILABLE-SIMPLE-STRING)))

TARGET-SUBSEQ-SIMPLE-BYTE-VECTOR (START END)

TARGET-SUBSEQ-SIMPLE-STRING (START END)

TRY-MATCH (&BODY BODY)

UNSAFE-RETURN-FROM (BLOCK &OPTIONAL VALUE)

WITH-DEFINE-SPECIALIZED-MATCH-FUNCTIONS (&BODY MATCH-FUNCTIONS)

WITH-FAIL (BODY &BODY FAIL-ACTIONS)

WITH-MATCH ((TARGET &KEY (ON-FAILURE '(ERROR 'MATCH-FAILED))) &BODY BODY)

WITH-MATCH-BLOCK (&BODY BODY)

WITH-MATCH-ENV ((TYPE TARGET) &BODY BODY)

WITH-SAVE-RESTORE-POS (&BODY BODY)

WITH-SPECIALIZED-MATCH-FUNCTIONS ((TYPE) &BODY BODY)

GENERIC-FUNCTION

Private

Undocumented

MERGE-SIMPLIFY (BEFORE AFTER)

OUTPUT-CODE (MATCHER)

OUTPUT-MATCH-UNTIL-CODE (MATCHER)

SPLIT-CHOICE-PREFIX (C)

VARIABLE

Private

Undocumented

*DEFUN-SPEEDY-DECLARATION*

*MATCH-BIND-FUNCTION-ABBREVIATIONS*

*MATCH-BIND-MACROS*

*MATCH-BIND-OPERATOR-ABBREVIATIONS*

*OPTIMIZE-UNSAFE*

*SPECIALIZED-TYPES*

*TYPE-SPECIFIC-MATCH-FUNCTIONS*

CLASS

Private

Undocumented

CHOICE

CONST

DECIDER

MATCH-END

PATH

SEQ

SIMPLIFIER

CONDITION

Public

MATCH-FAILED

Raised when the bindings in a match-bind do not match the target string