The cl-irregsexp Reference Manual

3.1.1 cl-irregsexp/cl-irregsexp.asd

Source

cl-irregsexp.asd.

Parent Component

cl-irregsexp (system).

ASDF Systems

cl-irregsexp.

Packages

cl-irregsexp.system.

---

3.1.2 cl-irregsexp/src/packages.lisp

Source

cl-irregsexp.asd.

Parent Component

src (module).

Packages

• cl-irregsexp.utils.
• cl-irregsexp.
• cl-irregsexp.bytestrings.

---

3.1.3 cl-irregsexp/src/opt.lisp

Dependency

packages.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Internals

*optimize-unsafe* (special variable).

---

3.1.4 cl-irregsexp/src/macros.lisp

Dependency

opt.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Public Interface

• (setf alist-get) (setf expander).
• alist-get (function).
• concat-sym (function).
• concat-sym-from-sym-package (function).
• declaim-defun-consistent-ftype (macro).
• defun-careful (macro).
• defun-consistent (macro).
• defun-speedy (macro).
• load-time-constantp (function).
• read-only-load-time-value (macro).

Internals

• *defun-speedy-declaration* (special variable).
• appendf (macro).
• compiler-macroexpand-1 (function).
• concat-sym-package (function).
• defun-consistent-names (function).
• function-name-p (function).
• macroexpand-and-compiler-macroexpand (function).
• racons (function).
• (setf ralist-get) (setf expander).
• ralist-get (function).
• unsafe-return-from (macro).

---

3.1.5 cl-irregsexp/src/byte-vector.lisp

Dependencies

• packages.lisp (file).
• macros.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Public Interface

• byte-vector (type).
• make-byte-vector (function).
• simple-byte-vector (type).

---

3.1.6 cl-irregsexp/src/utf8.lisp

Dependencies

• macros.lisp (file).
• byte-vector.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Public Interface

• utf8-decode (compiler macro).
• utf8-decode (function).
• utf8-encode (compiler macro).
• utf8-encode (function).

Internals

• utf8-char-length (function).
• utf8-decode-consistent-internal (function).
• utf8-decode-consistent-internal-careful (function).
• utf8-decode-really (function).
• utf8-encode-consistent-internal (function).
• utf8-encode-consistent-internal-careful (function).
• utf8-encode-really (function).

---

3.1.7 cl-irregsexp/src/force.lisp

Dependency

utf8.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Public Interface

• byte-vector-to-string (compiler macro).
• byte-vector-to-string (function).
• force-byte-vector (compiler macro).
• force-byte-vector (function).
• force-simple-byte-vector (compiler macro).
• force-simple-byte-vector (function).
• force-simple-string (compiler macro).
• force-simple-string (function).
• force-string (compiler macro).
• force-string (function).

Internals

• byte-vector-to-simple-byte-vector (compiler macro).
• byte-vector-to-simple-byte-vector (function).
• byte-vector-to-simple-byte-vector-consistent-internal (function).
• byte-vector-to-simple-byte-vector-consistent-internal-careful (function).
• byte-vector-to-string-consistent-internal (function).
• byte-vector-to-string-consistent-internal-careful (function).
• force-byte-vector-consistent-internal (function).
• force-byte-vector-consistent-internal-careful (function).
• force-list (function).
• force-sequence (function).
• force-simple-byte-vector-consistent-internal (function).
• force-simple-byte-vector-consistent-internal-careful (function).
• force-simple-string-consistent-internal (function).
• force-simple-string-consistent-internal-careful (function).
• force-simple-vector (compiler macro).
• force-simple-vector (function).
• force-simple-vector-consistent-internal (function).
• force-simple-vector-consistent-internal-careful (function).
• force-string-consistent-internal (function).
• force-string-consistent-internal-careful (function).

---

3.1.8 cl-irregsexp/src/type-specializations.lisp

Dependency

force.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Internals

• *specialized-types* (special variable).
• *type-specific-match-functions* (special variable).
• all-specialized-func-symbols (function).
• specialized-func-symbol (function).
• with-define-specialized-match-functions (macro).
• with-specialized-match-functions (macro).

---

3.1.9 cl-irregsexp/src/harness.lisp

Dependencies

• type-specializations.lisp (file).
• simplify.lisp (file).
• force.lisp (file).
• output-code.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Internals

• certainly-not-returning (function).
• check-len-available-simple-byte-vector (macro).
• check-len-available-simple-string (macro).
• dynamic-literal-simple-byte-vector (macro).
• dynamic-literal-simple-string (macro).
• eat-simple-byte-vector (macro).
• eat-simple-string (macro).
• eat-unchecked-simple-byte-vector (macro).
• eat-unchecked-simple-string (macro).
• elt-target-simple-byte-vector (macro).
• elt-target-simple-string (macro).
• fail (function).
• force-to-target-element-type-simple-byte-vector (compiler macro).
• force-to-target-element-type-simple-byte-vector (function).
• force-to-target-element-type-simple-byte-vector-consistent-internal (function).
• force-to-target-element-type-simple-byte-vector-consistent-internal-careful (function).
• force-to-target-element-type-simple-string (compiler macro).
• force-to-target-element-type-simple-string (function).
• force-to-target-element-type-simple-string-consistent-internal (function).
• force-to-target-element-type-simple-string-consistent-internal-careful (function).
• force-to-target-sequence-simple-byte-vector (macro).
• force-to-target-sequence-simple-string (macro).
• integer-match-index (type).
• len-available-simple-byte-vector (macro).
• len-available-simple-string (macro).
• peek-one-simple-byte-vector (macro).
• peek-one-simple-string (macro).
• peek-one-unchecked-simple-byte-vector (macro).
• peek-one-unchecked-simple-string (macro).
• peek-simple-byte-vector (macro).
• peek-simple-string (macro).
• target-subseq-simple-byte-vector (macro).
• target-subseq-simple-string (macro).
• to-int (compiler macro).
• to-int (function).
• to-int-consistent-internal (function).
• to-int-consistent-internal-careful (function).
• with-fail (macro).
• with-match (macro).
• with-match-block (macro).
• with-match-env (macro).
• with-save-restore-pos (macro).

---

3.1.10 cl-irregsexp/src/output-code.lisp

Dependency

simplify.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Internals

• choice-output-code (function).
• choice-output-match-until-code (function).
• decider-skip-table (function).
• output-code (method).
• output-code (method).
• output-code (method).
• output-finish-match-code (function).
• output-match-until-code (method).
• output-match-until-code (method).
• output-match-until-code (method).

---

3.1.11 cl-irregsexp/src/ir.lisp

Dependency

packages.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Internals

• choice (structure).
• choice-list (reader).
• (setf choice-list) (writer).
• choice-p (function).
• const (structure).
• const-p (function).
• const-value (reader).
• (setf const-value) (writer).
• copy-choice (function).
• copy-const (function).
• copy-decider (function).
• copy-irregsexp-seq (function).
• copy-match-end (function).
• copy-path (function).
• copy-simplifier (function).
• decider (structure).
• decider-differing-point (reader).
• (setf decider-differing-point) (writer).
• decider-end (reader).
• (setf decider-end) (writer).
• decider-p (function).
• decider-paths (reader).
• (setf decider-paths) (writer).
• make-choice (function).
• make-const (function).
• make-decider (function).
• make-match-end (function).
• make-path (function).
• make-seq (function).
• make-simplifier (function).
• match-end (structure).
• match-end-p (function).
• path (structure).
• path-after (reader).
• (setf path-after) (writer).
• path-p (function).
• path-prefix (reader).
• (setf path-prefix) (writer).
• seq (structure).
• seq-list (reader).
• (setf seq-list) (writer).
• seq-p (function).
• simplifier (structure).
• simplifier-lambda (reader).
• (setf simplifier-lambda) (writer).
• simplifier-name (reader).
• (setf simplifier-name) (writer).
• simplifier-p (function).

---

3.1.12 cl-irregsexp/src/simplify.lisp

Dependencies

• type-specializations.lisp (file).
• ir.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Internals

• choice-to-fast-decider (function).
• decider-len (function).
• decider-possible (function).
• defsimplifier (macro).
• defsimplifier-go (macro).
• maybe-build-fast-decider (function).
• merge-simplify (generic function).
• output-code (generic function).
• output-match-until-code (generic function).
• output-simplified (function).
• path-after-code (function).
• path-split (function).
• simplifier-run (function).
• simplify (function).
• simplify-seq (function).
• split-choice-prefix (generic function).

---

3.1.13 cl-irregsexp/src/helpers.lisp

Dependency

harness.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Internals

• generate-digit-matcher (function).
• generate-integer-matcher (function).
• generate-min-ignore-nil (function).
• generate-unsigned-matcher (function).
• literal-simple-byte-vector (macro).
• literal-simple-string (macro).
• match-all (macro).
• match-any-simple-byte-vector (macro).
• match-any-simple-string (macro).
• match-element-range-simple-byte-vector (macro).
• match-element-range-simple-string (macro).
• match-end-simple-byte-vector (macro).
• match-end-simple-string (macro).
• match-fixnum-simple-byte-vector (macro).
• match-fixnum-simple-string (macro).
• match-float-simple-byte-vector (macro).
• match-float-simple-string (macro).
• match-integer-simple-byte-vector (macro).
• match-integer-simple-string (macro).
• match-multiple-simple-byte-vector (macro).
• match-multiple-simple-string (macro).
• match-not (macro).
• match-one-or-more-simple-byte-vector (macro).
• match-one-or-more-simple-string (macro).
• match-one-whitespace-simple-byte-vector (macro).
• match-one-whitespace-simple-string (macro).
• match-positive-fixnum-simple-byte-vector (macro).
• match-positive-fixnum-simple-string (macro).
• match-remaining-simple-byte-vector (macro).
• match-remaining-simple-string (macro).
• match-unsigned-integer-simple-byte-vector (macro).
• match-unsigned-integer-simple-string (macro).
• match-until-and-eat-simple-byte-vector (macro).
• match-until-and-eat-simple-string (macro).
• match-until-internal-simple-byte-vector (macro).
• match-until-internal-simple-string (macro).
• match-until-simple-byte-vector (macro).
• match-until-simple-string (macro).
• match-zero-or-more-simple-byte-vector (macro).
• match-zero-or-more-simple-string (macro).
• try-match (macro).

---

3.1.14 cl-irregsexp/src/bind.lisp

Dependencies

• helpers.lisp (file).
• harness.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Public Interface

• if-match-bind (macro).
• match-bind (macro).
• match-failed (condition).

Internals

• *match-bind-function-abbreviations* (special variable).
• *match-bind-macros* (special variable).
• *match-bind-operator-abbreviations* (special variable).
• bind-macro-expander (function).
• def-match-bind-macro (macro).
• function-abbreviation (function).
• generate-match-bind (function).
• match-bind-internal (macro).
• match-bind-macro-body (function).
• operator-abbreviation (function).
• set-match-bind-macro (function).

---

3.1.15 cl-irregsexp/src/replace.lisp

Dependencies

• bind.lisp (file).
• byte-vector.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Public Interface

• match-replace-all (macro).
• match-replace-one (macro).

Internals

• match-replace-helper (macro).
• replace-concatenate-sequences (function).

---

3.1.16 cl-irregsexp/src/split.lisp

Dependency

bind.lisp (file).

Source

cl-irregsexp.asd.

Parent Component

src (module).

Public Interface

match-split (macro).

---

5.1.1 Macros

Macro: declaim-defun-consistent-ftype (name input-type output-type) ¶

Package

cl-irregsexp.utils.

Source

macros.lisp.

Macro: defun-careful (name lambda-list &body body) ¶

Package

cl-irregsexp.utils.

Source

macros.lisp.

Macro: defun-consistent (name lambda-list &body body) ¶

Package

cl-irregsexp.utils.

Source

macros.lisp.

Macro: defun-speedy (name lambda-list &body body) ¶

Package

cl-irregsexp.utils.

Source

macros.lisp.

Macro: if-match-bind (bindings string &optional then else) ¶

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

Package

cl-irregsexp.

Source

bind.lisp.

Macro: match-bind (bindings string &body body) ¶

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

Package

cl-irregsexp.

Source

bind.lisp.

Macro: 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

Package

cl-irregsexp.

Source

replace.lisp.

Macro: match-replace-one (string &body match-replacements) ¶

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

Package

cl-irregsexp.

Source

replace.lisp.

Macro: match-split (pattern string) ¶

Package

cl-irregsexp.

Source

split.lisp.

Macro: read-only-load-time-value (form) ¶

Package

cl-irregsexp.utils.

Source

macros.lisp.

---

5.1.2 Compiler macros

Compiler Macro: byte-vector-to-string (vec) ¶

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Compiler Macro: force-byte-vector (val) ¶

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Compiler Macro: force-simple-byte-vector (val) ¶

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Compiler Macro: force-simple-string (val) ¶

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Compiler Macro: force-string (val) ¶

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Compiler Macro: utf8-decode (vec) ¶

Package

cl-irregsexp.bytestrings.

Source

utf8.lisp.

Compiler Macro: utf8-encode (str) ¶

Package

cl-irregsexp.bytestrings.

Source

utf8.lisp.

---

5.1.3 Ordinary functions

Function: alist-get (alist key &key test) ¶

Setf Expander: (setf alist-get) (place key &key test) ¶

Package

cl-irregsexp.utils.

Source

macros.lisp.

Function: byte-vector-to-string (vec) ¶

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: concat-sym (&rest args) ¶

Package

cl-irregsexp.utils.

Source

macros.lisp.

Function: concat-sym-from-sym-package (sym &rest args) ¶

Package

cl-irregsexp.utils.

Source

macros.lisp.

Function: force-byte-vector (val) ¶

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-simple-byte-vector (val) ¶

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-simple-string (val) ¶

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-string (val) ¶

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: load-time-constantp (form &optional env) ¶

Package

cl-irregsexp.utils.

Source

macros.lisp.

Function: make-byte-vector (len) ¶

Package

cl-irregsexp.bytestrings.

Source

byte-vector.lisp.

Function: utf8-decode (vec) ¶

Package

cl-irregsexp.bytestrings.

Source

utf8.lisp.

Function: utf8-encode (str) ¶

Package

cl-irregsexp.bytestrings.

Source

utf8.lisp.

---

5.1.4 Conditions

Condition: match-failed ¶

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

Package

cl-irregsexp.

Source

bind.lisp.

Direct superclasses

error.

Direct slots

Slot: match-form ¶

Initargs

:matching

Slot: target-string ¶

Initargs

:string

---

5.1.5 Types

Type: byte-vector (&optional len) ¶

Vector of unsigned byte 8, often a UTF-8 encoded string

Package

cl-irregsexp.bytestrings.

Source

byte-vector.lisp.

Type: simple-byte-vector (&optional len) ¶

Package

cl-irregsexp.bytestrings.

Source

byte-vector.lisp.

---

5.2.1 Special variables

Special Variable: *defun-speedy-declaration* ¶

Package

cl-irregsexp.

Source

macros.lisp.

Special Variable: *match-bind-function-abbreviations* ¶

Package

cl-irregsexp.

Source

bind.lisp.

Special Variable: *match-bind-macros* ¶

Package

cl-irregsexp.

Source

bind.lisp.

Special Variable: *match-bind-operator-abbreviations* ¶

Package

cl-irregsexp.

Source

bind.lisp.

Special Variable: *optimize-unsafe* ¶

Package

cl-irregsexp.

Source

opt.lisp.

Special Variable: *specialized-types* ¶

Package

cl-irregsexp.

Source

type-specializations.lisp.

Special Variable: *type-specific-match-functions* ¶

Package

cl-irregsexp.

Source

type-specializations.lisp.

---

5.2.2 Macros

Macro: appendf (place &rest lists) ¶

Package

cl-irregsexp.

Source

macros.lisp.

Macro: check-len-available-simple-byte-vector (len) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: check-len-available-simple-string (len) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: def-match-bind-macro (name lambda-list &body body) ¶

Package

cl-irregsexp.

Source

bind.lisp.

Macro: defsimplifier (name lambda-list &body body) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Macro: defsimplifier-go (name lambda-list &body body) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Macro: dynamic-literal-simple-byte-vector (v) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: dynamic-literal-simple-string (v) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: eat-simple-byte-vector (&optional len) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: eat-simple-string (&optional len) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: eat-unchecked-simple-byte-vector (&optional len) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: eat-unchecked-simple-string (&optional len) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: elt-target-simple-byte-vector (i) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: elt-target-simple-string (i) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: force-to-target-sequence-simple-byte-vector (v) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: force-to-target-sequence-simple-string (v) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: len-available-simple-byte-vector () ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: len-available-simple-string () ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: literal-simple-byte-vector (&rest unused20) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: literal-simple-string (&rest unused159) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-all (&rest options) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-any-simple-byte-vector (&rest unused20) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-any-simple-string (&rest unused71) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-bind-internal (args-for-with-match bindings &body body) ¶

Package

cl-irregsexp.

Source

bind.lisp.

Macro: match-element-range-simple-byte-vector (&rest unused20) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-element-range-simple-string (&rest unused107) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-end-simple-byte-vector (&rest unused20) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-end-simple-string (&rest unused63) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-fixnum-simple-byte-vector (&rest args) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-fixnum-simple-string (&rest args) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-float-simple-byte-vector (&key base) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-float-simple-string (&key base) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-integer-simple-byte-vector (&rest args) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-integer-simple-string (&rest args) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-multiple-simple-byte-vector (&rest unused20) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-multiple-simple-string (&rest unused144) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-not (&rest matches) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-one-or-more-simple-byte-vector (&rest unused20) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-one-or-more-simple-string (&rest unused66) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-one-whitespace-simple-byte-vector (&rest unused20) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-one-whitespace-simple-string (&rest unused63) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-positive-fixnum-simple-byte-vector (&rest args) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-positive-fixnum-simple-string (&rest args) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-remaining-simple-byte-vector () ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-remaining-simple-string () ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-replace-helper (string &key op after result-init match-replacements) ¶

Package

cl-irregsexp.

Source

replace.lisp.

Macro: match-unsigned-integer-simple-byte-vector (&rest args) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-unsigned-integer-simple-string (&rest args) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-until-and-eat-simple-byte-vector (&rest matches) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-until-and-eat-simple-string (&rest matches) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-until-internal-simple-byte-vector (&rest matches) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-until-internal-simple-string (&rest matches) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-until-simple-byte-vector (&rest unused20) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-until-simple-string (&rest unused68) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-zero-or-more-simple-byte-vector (&rest unused20) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: match-zero-or-more-simple-string (&rest unused66) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: peek-one-simple-byte-vector (&optional i) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: peek-one-simple-string (&optional i) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: peek-one-unchecked-simple-byte-vector (&optional i) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: peek-one-unchecked-simple-string (&optional i) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: peek-simple-byte-vector (&optional len) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: peek-simple-string (&optional len) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: target-subseq-simple-byte-vector (start end) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: target-subseq-simple-string (start end) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: try-match (&body body) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Macro: unsafe-return-from (block &optional value) ¶

Package

cl-irregsexp.

Source

macros.lisp.

Macro: with-define-specialized-match-functions (&body match-functions) ¶

Package

cl-irregsexp.

Source

type-specializations.lisp.

Macro: with-fail (body &body fail-actions) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: with-match ((target &key on-failure) &body body) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: with-match-block (&body body) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: with-match-env ((type target) &body body) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: with-save-restore-pos (&body body) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Macro: with-specialized-match-functions ((type) &body body) ¶

Package

cl-irregsexp.

Source

type-specializations.lisp.

---

5.2.3 Compiler macros

Compiler Macro: byte-vector-to-simple-byte-vector (val) ¶

Package

cl-irregsexp.

Source

force.lisp.

Compiler Macro: force-simple-vector (v) ¶

Package

cl-irregsexp.

Source

force.lisp.

Compiler Macro: force-to-target-element-type-simple-byte-vector (c) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Compiler Macro: force-to-target-element-type-simple-string (c) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Compiler Macro: to-int (val) ¶

Package

cl-irregsexp.

Source

harness.lisp.

---

5.2.4 Ordinary functions

Function: all-specialized-func-symbols (func) ¶

Package

cl-irregsexp.

Source

type-specializations.lisp.

Function: bind-macro-expander (form) ¶

Package

cl-irregsexp.

Source

bind.lisp.

Function: byte-vector-to-simple-byte-vector (val) ¶

Package

cl-irregsexp.

Source

force.lisp.

Function: byte-vector-to-simple-byte-vector-consistent-internal (val) ¶

Package

cl-irregsexp.

Source

force.lisp.

Function: byte-vector-to-simple-byte-vector-consistent-internal-careful (val) ¶

Package

cl-irregsexp.

Source

force.lisp.

Function: byte-vector-to-string-consistent-internal (vec) ¶

UTF-8 decode VEC to a string

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: byte-vector-to-string-consistent-internal-careful (vec) ¶

UTF-8 decode VEC to a string

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: certainly-not-returning (statements) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Reader: choice-list (instance) ¶

Writer: (setf choice-list) (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Target Slot

list.

Function: choice-output-code (choice) ¶

Package

cl-irregsexp.

Source

output-code.lisp.

Function: choice-output-match-until-code (choice) ¶

Package

cl-irregsexp.

Source

output-code.lisp.

Function: choice-p (object) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: choice-to-fast-decider (choice) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Function: compiler-macroexpand-1 (form &optional env) ¶

Package

cl-irregsexp.

Source

macros.lisp.

Function: concat-sym-package (package &rest args) ¶

Package

cl-irregsexp.

Source

macros.lisp.

Function: const-p (object) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Reader: const-value (instance) ¶

Writer: (setf const-value) (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Target Slot

value.

Function: copy-choice (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: copy-const (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: copy-decider (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: copy-irregsexp-seq (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: copy-match-end (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: copy-path (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: copy-simplifier (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Reader: decider-differing-point (instance) ¶

Writer: (setf decider-differing-point) (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Target Slot

differing-point.

Reader: decider-end (instance) ¶

Writer: (setf decider-end) (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Target Slot

end.

Function: decider-len (decider) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Function: decider-p (object) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Reader: decider-paths (instance) ¶

Writer: (setf decider-paths) (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Target Slot

paths.

Function: decider-possible (decider i) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Function: decider-skip-table (decider) ¶

Package

cl-irregsexp.

Source

output-code.lisp.

Function: defun-consistent-names (name) ¶

Package

cl-irregsexp.

Source

macros.lisp.

Function: fail () ¶

Package

cl-irregsexp.

Source

harness.lisp.

Function: force-byte-vector-consistent-internal (val) ¶

Return a representation of VAL as a UTF-8 byte-vector, doing the work at compile-time if possible.

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-byte-vector-consistent-internal-careful (val) ¶

Return a representation of VAL as a UTF-8 byte-vector, doing the work at compile-time if possible.

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-list (val) ¶

Package

cl-irregsexp.

Source

force.lisp.

Function: force-sequence (val) ¶

Package

cl-irregsexp.

Source

force.lisp.

Function: force-simple-byte-vector-consistent-internal (val) ¶

Return a representation of VAL as a UTF-8 simple byte-vector, doing the work at compile-time if possible.

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-simple-byte-vector-consistent-internal-careful (val) ¶

Return a representation of VAL as a UTF-8 simple byte-vector, doing the work at compile-time if possible.

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-simple-string-consistent-internal (val) ¶

Return a representation of VAL as a string, doing the work at compile-time if possible.

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-simple-string-consistent-internal-careful (val) ¶

Return a representation of VAL as a string, doing the work at compile-time if possible.

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-simple-vector (v) ¶

Package

cl-irregsexp.

Source

force.lisp.

Function: force-simple-vector-consistent-internal (v) ¶

Package

cl-irregsexp.

Source

force.lisp.

Function: force-simple-vector-consistent-internal-careful (v) ¶

Package

cl-irregsexp.

Source

force.lisp.

Function: force-string-consistent-internal (val) ¶

Return a representation of VAL as a string, doing the work at compile-time if possible.

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-string-consistent-internal-careful (val) ¶

Return a representation of VAL as a string, doing the work at compile-time if possible.

Package

cl-irregsexp.bytestrings.

Source

force.lisp.

Function: force-to-target-element-type-simple-byte-vector (c) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Function: force-to-target-element-type-simple-byte-vector-consistent-internal (c) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Function: force-to-target-element-type-simple-byte-vector-consistent-internal-careful (c) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Function: force-to-target-element-type-simple-string (c) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Function: force-to-target-element-type-simple-string-consistent-internal (c) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Function: force-to-target-element-type-simple-string-consistent-internal-careful (c) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Function: function-abbreviation (form) ¶

Package

cl-irregsexp.

Source

bind.lisp.

Function: function-name-p (name) ¶

Package

cl-irregsexp.

Source

macros.lisp.

Function: generate-digit-matcher (base var) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Function: generate-integer-matcher (&key base least largest length max-length min-length) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Function: generate-match-bind (bindings &optional env) ¶

Package

cl-irregsexp.

Source

bind.lisp.

Function: generate-min-ignore-nil (&rest args) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Function: generate-unsigned-matcher (&key base largest length max-length min-length) ¶

Package

cl-irregsexp.

Source

helpers.lisp.

Function: macroexpand-and-compiler-macroexpand (form &optional env) ¶

Package

cl-irregsexp.

Source

macros.lisp.

Function: make-choice (&key list) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: make-const (&key value) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: make-decider (&key paths end differing-point) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: make-match-end (&key) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: make-path (&key prefix after) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: make-seq (&key list) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: make-simplifier (&key name lambda) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: match-bind-macro-body (lambda-list body) ¶

Package

cl-irregsexp.

Source

bind.lisp.

Function: match-end-p (object) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: maybe-build-fast-decider (paths end) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Function: operator-abbreviation (form) ¶

Package

cl-irregsexp.

Source

bind.lisp.

Function: output-finish-match-code (decider) ¶

Package

cl-irregsexp.

Source

output-code.lisp.

Function: output-simplified (form) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Reader: path-after (instance) ¶

Writer: (setf path-after) (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Target Slot

after.

Function: path-after-code (path) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Function: path-p (object) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Reader: path-prefix (instance) ¶

Writer: (setf path-prefix) (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Target Slot

prefix.

Function: path-split (path len) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Function: racons (key value ralist) ¶

Package

cl-irregsexp.

Source

macros.lisp.

Function: ralist-get (alist key &key test) ¶

Setf Expander: (setf ralist-get) (place key &key test) ¶

Package

cl-irregsexp.

Source

macros.lisp.

Function: replace-concatenate-sequences (prototype total-length sequences) ¶

Package

cl-irregsexp.

Source

replace.lisp.

Reader: seq-list (instance) ¶

Writer: (setf seq-list) (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Target Slot

list.

Function: seq-p (object) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: set-match-bind-macro (name function) ¶

Package

cl-irregsexp.

Source

bind.lisp.

Reader: simplifier-lambda (instance) ¶

Writer: (setf simplifier-lambda) (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Target Slot

lambda.

Reader: simplifier-name (instance) ¶

Writer: (setf simplifier-name) (instance) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Target Slot

name.

Function: simplifier-p (object) ¶

Package

cl-irregsexp.

Source

ir.lisp.

Function: simplifier-run (simplifier form) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Function: simplify (form) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Function: simplify-seq (body) ¶

Package

cl-irregsexp.

Source

simplify.lisp.

Function: specialized-func-symbol (func type) ¶

Package

cl-irregsexp.

Source

type-specializations.lisp.

Function: to-int (val) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Function: to-int-consistent-internal (val) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Function: to-int-consistent-internal-careful (val) ¶

Package

cl-irregsexp.

Source

harness.lisp.

Function: utf8-char-length (char) ¶

Package

cl-irregsexp.

Source

utf8.lisp.

Function: utf8-decode-consistent-internal (vec) ¶

Package

cl-irregsexp.bytestrings.

Source

utf8.lisp.

Function: utf8-decode-consistent-internal-careful (vec) ¶

Package

cl-irregsexp.bytestrings.

Source

utf8.lisp.

Function: utf8-decode-really (vec) ¶

Package

cl-irregsexp.

Source

utf8.lisp.

Function: utf8-encode-consistent-internal (str) ¶

Package

cl-irregsexp.bytestrings.

Source

utf8.lisp.

Function: utf8-encode-consistent-internal-careful (str) ¶

Package

cl-irregsexp.bytestrings.

Source

utf8.lisp.

Function: utf8-encode-really (string) ¶

Package

cl-irregsexp.

Source

utf8.lisp.

---