The check-bnf Reference Manual

This is the check-bnf Reference Manual, version 8.1.30, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Feb 15 04:31:51 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 check-bnf

Macro arguments checker.

Author

SATO Shinichi

Source Control

(GIT git@github.com:hyotang666/check-bnf)

Bug Tracker

https://github.com/hyotang666/check-bnf/issues

License

MIT

Version

8.1.30

Dependencies
  • alexandria (system).
  • millet (system).
  • closer-mop (system).
  • matrix-case (system).
Source

check-bnf.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


3.1.1 check-bnf/check-bnf.asd

Source

check-bnf.asd.

Parent Component

check-bnf (system).

ASDF Systems

check-bnf.


3.1.2 check-bnf/check-bnf.lisp

Source

check-bnf.asd.

Parent Component

check-bnf (system).

Packages

check-bnf.

Public Interface
Internals

3.1.3 check-bnf/defbnf.lisp

Dependency

check-bnf.lisp (file).

Source

check-bnf.asd.

Parent Component

check-bnf (system).

Public Interface

4 Packages

Packages are listed by definition order.


4.1 check-bnf

Source

check-bnf.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

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


5.1 Public Interface


5.1.1 Macros

Macro: check-bnf ((&key whole) &body def+)

# CHECK-BNF

## Description:
Macro argument checker like CL:CHECK-TYPE.
In most simple case, its like CL:CHECK-TYPE.

“‘lisp
#?(let ((var ’symbol))
(check-bnf ()
((var symbol))))
=> NIL
“‘

“‘lisp
#?(let ((var "string"))
(check-bnf ()
((var symbol))))
:invokes-debugger syntax-error
, :test
“‘
You can check some place at once.

“‘lisp
#?(let ((a ’symbol)
(b "string"))
(check-bnf ()
((a symbol))
((b string))))
=> NIL
“‘
When type-specifier is expanded to T,
Efficient code is generated.

“‘lisp
#?(check-bnf ()
((a t)))
:expanded-to NIL
“‘

“‘lisp
#?(check-bnf ()
((a* t)))
:expanded-to (let ((check-bnf::*whole* nil)
(check-bnf::*bnf* ’((a* t))))
(labels ((a* (a*)
(if (typep a* ’(and atom (not null)))
(let ((check-bnf::*default-condition* ’check-bnf::violate-list))
(syntax-error ’a* "~A require LIST but ~S." ’a* a*))
nil)))
(a* a*)))
“‘
Also it occur in OR form.

“‘lisp
#?(check-bnf ()
((a (or symbol t string))))
:expanded-to NIL
“‘

“‘lisp
#?(check-bnf ()
((a (or symbol b string))
(b t)))
:expanded-to NIL
“‘

“‘lisp
#?(check-bnf ()
((a (or b c))
(b integer)
(c t)))
:expanded-to NIL
“‘
When you know VAR is list, and it has 0 or more elt. (a.k.a. *)
You can write like below.

“‘lisp
#?(let ((var* nil))
(check-bnf ()
((var* symbol))))
=> NIL
“‘

“‘lisp
#?(let ((var* ’(symbol)))
(check-bnf ()
((var* symbol))))
=> NIL
“‘

“‘lisp
#?(let ((var* ’("string")))
(check-bnf ()
((var* symbol))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((var* :not-list))
(check-bnf ()
((var* symbol))))
:invokes-debugger syntax-error
, :test
“‘
When expected T, efficient code is generated.

“‘lisp
#?(CHECK-BNF () ((OPTION* KEYWORD T)))
:expanded-to (LET ((check-bnf::*WHOLE* NIL) (check-bnf::*BNF* ’((OPTION* KEYWORD T))))
(LABELS ((OPTION* (OPTION*)
(IF (TYPEP OPTION* ’(AND ATOM (NOT NULL)))
(let ((check-bnf::*default-condition* ’check-bnf::violate-list))
(SYNTAX-ERROR ’OPTION* "~A require LIST but ~S." ’option*
OPTION*))
(LOOP :FOR args :ON OPTION* :BY #’CDDR
:for (G11516 G11517)
:= (if (typep args ’(cons * (cons * *))) args
(let ((check-bnf::*default-condition* ’check-bnf::may-syntax-error))
(syntax-error ’option*
"~A : Length mismatch. Lack last ~{~S~^ ~} of ~S~:@_in ~S" ’option*
(subseq ’(keyword t)
(mod (length args) 2))
’(keyword t) args)))
:DO (FUNCALL
(check-bnf::RESIGNALER ’OPTION* args) (check-bnf::CAPTURE-SYNTAX-ERROR
(UNLESS (TYPEP G11516 ’KEYWORD)
(SYNTAX-ERROR ’OPTION*
"~A : ~S comes. It is type-of ~S." ’option* G11516 (TYPE-OF G11516))))
(check-bnf::IGNORED G11517))))))
(OPTION* OPTION*)))
“‘
If you do not like names var as XXX*, you can specify alias.

“‘lisp
#?(let ((vars ’(symbol)))
(check-bnf ()
(((var* vars) symbol))))
=> NIL
“‘
e.g. specify for plist.

“‘lisp
#?(let ((var* ’(:key "value" :key2 "value2")))
(check-bnf ()
((var* keyword string))))
=> NIL
“‘

“‘lisp
#?(let ((var* ’(:key 2 :key2 "not integer")))
(check-bnf ()
((var* keyword integer))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((var* ’(:key 1 "not-key" 2)))
(check-bnf ()
((var* keyword integer))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((var* ’(:not "ballanced" :plist)))
(check-bnf ()
((var* keyword string))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((var* ’(0 1)))
(check-bnf ()
((var* keyword string))))
:invokes-debugger syntax-error
, :test
“‘
e.g. specify for alist.

“‘lisp
#?(let ((var* ’((:key "value") (:key2 "value2"))))
(check-bnf ()
((var* (keyword string)))))
=> nil
“‘

“‘lisp
#?(let ((var* ’((:key "value") (:key2 :not-string))))
(check-bnf ()
((var* (keyword string)))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((var* ’((:key "value") (:not "ballanced" clause))))
(check-bnf ()
((var* (keyword string)))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((var* ’((:key "value") (:not-ballanced))))
(check-bnf ()
((var* (keyword string)))))
:invokes-debugger syntax-error
, :test
“‘
of course dotted are valid.

“‘lisp
#?(let ((var* ’((:key . "value"))))
(check-bnf ()
((var* (keyword . string)))))
=> nil
“‘
when you know var is list, and it has 1 or more elt, (a.k.a. +)
you can write like below.

“‘lisp
#?(let ((var+ ’(1)))
(check-bnf ()
((var+ integer))))
=> nil
“‘

“‘lisp
#?(let ((var+ ’()))
(check-bnf ()
((var+ integer))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((var+ ’("not-integer")))
(check-bnf ()
((var+ integer))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((var+ :not-cons))
(check-bnf ()
((var+ integer))))
:invokes-debugger syntax-error
, :test
“‘

### syntax
(check-bnf (&key ((:whole whole?))) &rest def+)
=> result

## arguments and values:
whole := form, evaluated.

“‘lisp
#?(check-bnf (:whole no-such-var)
((dummy dummy)))
:signals (or error
warning ; for ccl
)
“‘
expects var for &whole.
when specified, header and footer is generated in error message.

“‘lisp
#?(let ((a "not-symbol"))
(check-bnf ()
((a symbol))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((a "not-symbol"))
(check-bnf (:whole ’(whole ("not-symbol")))
((a symbol))))
:invokes-debugger syntax-error
, :test
“‘
def := (clause+)+
clause := (var-spec spec+)
var-spec := [ name | (name name) ]
name := symbol, otherwise error.

“‘lisp
#?(check-bnf ()
(("not-symbol" dummy)))
:signals syntax-error
, :lazy
“‘
not evaluated.

“‘lisp
#?(check-bnf ()
(((intern "not evaluated") dummy)))
:signals syntax-error
, :lazy
“‘
NAME must not be a type name.

“‘lisp
#?(deftype type-name () ’symbol)
=> TYPE-NAME
“‘

“‘lisp
#?(check-bnf ()
((type-name ’symbol)))
:signals syntax-error
, :lazy
“‘
clause require one or more, otherwise syntax error.

“‘lisp
#?(check-bnf ())
:signals syntax-error
, :lazy
“‘
spec := [ type-specifier | bnf ]
bnf := [ name | list-bnf | or-form ]
list-bnf := (spec+)
or-form := (or spec+)
spec require one or more, otherwise error.

“‘lisp
#?(check-bnf ()
((dummy)))
:signals syntax-error
, :lazy
“‘

“‘lisp
#?(check-bnf ()
((dummy+ nil)))
:signals syntax-error
, :lazy
“‘
result := null

## affected by:
none

## side-effects:
none

## notes:
to check optional argument (e.g. &optional or &key), you can write like below.

“‘lisp
#?(let ((option))
(check-bnf ()
((option (or null symbol)))))
=> nil
“‘

“‘lisp
#?(let ((option ’symbol))
(check-bnf ()
((option (or null symbol)))))
=> nil
“‘

“‘lisp
#?(let ((function-name "not function-name"))
(check-bnf ()
((function-name (or name setf-name))
(name symbol)
(setf-name ((eql setf) name)))))
:invokes-debugger syntax-error
, :test
“‘
to check optional value in list, you can write like below.

“‘lisp
#?(let ((args ’(option and others)))
(check-bnf ()
((args (option? other*))
(option? (eql option))
(other* symbol))))
=> nil
“‘

“‘lisp
#?(let ((args ’(and others)))
(check-bnf ()
((args (option? other*))
(option? (eql option))
(other* symbol))))
=> nil
“‘

“‘lisp
#?(let ((args ’("not option nor other*" and others)))
(check-bnf ()
((args (option? other*))
(option? (eql option))
(other* symbol))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(LET (VAR)
(CHECK-BNF ()
((VAR (A* B*))
(A SYMBOL)
(B INTEGER))))
=> NIL
“‘

“‘lisp
#?(LET ((VAR ’(SYM)))
(CHECK-BNF ()
((VAR (A* B*))
(A SYMBOL)
(B INTEGER))))
=> NIL
“‘

“‘lisp
#?(LET ((VAR ’(SYM SYM)))
(CHECK-BNF ()
((VAR (A* B*))
(A SYMBOL)
(B INTEGER))))
=> NIL
“‘

“‘lisp
#?(LET ((VAR ’(SYM SYM 1)))
(CHECK-BNF ()
((VAR (A* B*))
(A SYMBOL)
(B INTEGER))))
=> NIL
“‘

“‘lisp
#?(LET ((VAR ’(SYM SYM 1 2)))
(CHECK-BNF ()
((VAR (A* B*))
(A SYMBOL)
(B INTEGER))))
=> NIL
“‘

“‘lisp
#?(LET ((VAR ’(SYM SYM "string")))
(CHECK-BNF ()
((VAR (A* B*))
(A SYMBOL)
(B INTEGER))))
:invokes-debugger SYNTAX-ERROR
, :test
“‘
Key value pair in heads.

“‘lisp
#?(LET ((ARGS ’(:KEY 1 :KEY 2 "doc")))
(CHECK-BNF ()
((ARGS (OPTION* DOC?))
(OPTION* KEYWORD INTEGER)
(DOC? STRING))))
=> NIL
“‘

“‘lisp
#?(LET ((ARGS ’(:KEY 1 :KEY 2)))
(CHECK-BNF ()
((ARGS (OPTION* DOC?))
(OPTION* KEYWORD INTEGER)
(DOC? STRING))))
=> NIL
“‘

“‘lisp
#?(LET ((ARGS ’(:KEY 1 :KEY 2 not-string)))
(CHECK-BNF ()
((ARGS (OPTION* DOC?))
(OPTION* KEYWORD INTEGER)
(DOC? STRING))))
:invokes-debugger syntax-error
, :test
“‘

## exceptional-situations:
every name should not conflicts cl symbol.

“‘lisp
#?(let ((list nil))
(check-bnf ()
((list list))))
=> unspecified
“‘

## example.

“‘lisp
#?(let ((var ’(symbol symbol)))
(check-bnf ()
((var (symbol symbol option*))
(option* keyword string))))
=> nil
“‘

“‘lisp
#?(let ((var ’(symbol symbol)))
(check-bnf ()
((var (symbol symbol option?))
(option? keyword))))
=> nil
“‘

“‘lisp
#?(let ((var ’(symbol symbol)))
(check-bnf ()
((var (symbol symbol required))
(required keyword))))
:invokes-debugger syntax-error
, :test
“‘

#### right side xxx*

“‘lisp
#?(let ((var ’(symbol)))
(check-bnf ()
((var (or string name*))
(name symbol))))
=> nil
“‘

“‘lisp
#?(let ((var "string"))
(check-bnf ()
((var (or string name*))
(name symbol))))
=> nil
“‘

“‘lisp
#?(let ((var ()))
(check-bnf ()
((var (or string name*))
(name symbol))))
=> nil
“‘

“‘lisp
#?(let ((var :not-list))
(check-bnf ()
((var (or string name*))
(name symbol))))
:invokes-debugger syntax-error
, :test
“‘

#### right side xxx?

“‘lisp
#?(let ((ll nil))
(check-bnf ()
((ll (var?))
(var symbol))))
=> nil
“‘

“‘lisp
#?(let ((ll ’(var)))
(check-bnf ()
((ll (var?))
(var symbol))))
=> nil
“‘

“‘lisp
#?(let ((ll ’(var too much)))
(check-bnf ()
((ll (var?))
(var symbol))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((ll "not list"))
(check-bnf ()
((ll (var?))
(var symbol))))
:invokes-debugger syntax-error
, :test
“‘

“‘lisp
#?(let ((ll ’("not symbol")))
(check-bnf ()
((ll (var?))
(var symbol))))
:invokes-debugger syntax-error
, :test
“‘

## Practical case examples.

#### deftype.

“‘lisp
#?(let ((name ’name)
(lambda-list ’())
(body ’("doc" t)))
(check-bnf ()
((name (and symbol (not (or keyword boolean)))))
((lambda-list list))
((body (doc? declaration* expression*))
(doc? string)
(declaration* ((eql declare) t*)))))
=> NIL
“‘

“‘lisp
#?(let ((body ’("doc" t)))
(check-bnf ()
((body (string? declaration* expression*))
(declaration* ((eql declare) t*)))))
=> NIL
“‘

## Tests

“‘lisp
#?(let ((ll "not-list"))
(check-bnf ()
((ll <lambda-list>))))
:invokes-debugger syntax-error
, :test
“‘

#### Support compound type specifier.

#### ISSUE: Right side expression may be type specifier accidentally?

#### e.g. (vector spec)

“‘lisp
#?(let ((index 3))
(check-bnf ()
((index (mod #.array-total-size-limit)))))
=> NIL
“‘

Package

check-bnf.

Source

check-bnf.lisp.

Macro: defbnf (definition)
Package

check-bnf.

Source

check-bnf.lisp.

Macro: doc (&body forms)
Package

check-bnf.

Source

check-bnf.lisp.


5.1.2 Ordinary functions

Function: <declaration> (<declaration>)
Package

check-bnf.

Source

defbnf.lisp.

Function: <function-type> (<function-type>)
Package

check-bnf.

Source

defbnf.lisp.

Function: <lambda-list> (<lambda-list>)
Package

check-bnf.

Source

defbnf.lisp.

Function: syntax-error (name format-control &rest format-arguments)
Package

check-bnf.

Source

check-bnf.lisp.


5.1.3 Standalone methods

Method: initialize-instance :after ((checker checker) &key function &allow-other-keys)
Source

check-bnf.lisp.


5.1.4 Conditions

Condition: syntax-error
Package

check-bnf.

Source

check-bnf.lisp.

Direct superclasses
  • cell-error.
  • program-error.
  • simple-error.
Direct subclasses
Direct methods
Direct Default Initargs
InitargValue
:format-control
Direct slots
Slot: whole
Initform

(quote nil)

Initargs

:whole

Readers

whole-form<=syntax-error.

Writers

This slot is read-only.

Slot: definitions
Initform

(quote nil)

Initargs

:definitions

Readers

bnf-definitions.

Writers

This slot is read-only.


5.1.5 Types

Type: expression ()

# EXPRESSION

## description:

## compound type specifier kind:

## compound type specifier syntax:

## compound type specifier arguments:

## compound type specifier description:

Package

check-bnf.

Source

check-bnf.lisp.


5.2 Internals


5.2.1 Special variables

Special Variable: *bnf*
Package

check-bnf.

Source

check-bnf.lisp.

Special Variable: *default-condition*
Package

check-bnf.

Source

check-bnf.lisp.

Special Variable: *whole*
Package

check-bnf.

Source

check-bnf.lisp.


5.2.2 Macros

Macro: capture-syntax-error (form)
Package

check-bnf.

Source

check-bnf.lisp.


5.2.3 Ordinary functions

Function: *-checker (name elt-checker)
Package

check-bnf.

Source

check-bnf.lisp.

Function: +-checker (name elt-checker)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <*form-body> (name spec+)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <*form> (name spec+)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <+form> (name spec+)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <check-type-form> (name var type-specifier)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <local-atom-check-form> (name var spec)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <local-check-form> (name var spec)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <local-cons-check-form> (name var spec)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <local-fun> (clause)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <local-or-check-form> (name var spec)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <local-type-check-form> (name var spec)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <require-form> (name spec+)
Package

check-bnf.

Source

check-bnf.lisp.

Function: <spec-form> (spec name)
Package

check-bnf.

Source

check-bnf.lisp.

Function: at-least-n-cons (n)
Package

check-bnf.

Source

check-bnf.lisp.

Function: but-extended-marker (thing)
Package

check-bnf.

Source

check-bnf.lisp.

Function: cboundp (symbol)
Package

check-bnf.

Source

check-bnf.lisp.

Function: check-cons (actual-args specs names)
Package

check-bnf.

Source

check-bnf.lisp.

Function: checker-p (thing)
Package

check-bnf.

Source

check-bnf.lisp.

Function: cons-equal (list1 list2)
Package

check-bnf.

Source

check-bnf.lisp.

Function: copy-spec (instance)
Package

check-bnf.

Source

check-bnf.lisp.

Function: definitions (thing bnf)

Collect definitions that related to THING from BNF

Package

check-bnf.

Source

check-bnf.lisp.

Function: extended-marker (name)

Return extended-marker if NAME has, otherwirse nil.

Package

check-bnf.

Source

check-bnf.lisp.

Function: ignored (arg)
Package

check-bnf.

Source

check-bnf.lisp.

Function: local-check (actual spec)
Package

check-bnf.

Source

check-bnf.lisp.

Function: pprint-bnf (stream exp &rest noise)
Package

check-bnf.

Source

check-bnf.lisp.

Function: pprint-check-bnf (stream exp)

# PPRINT-CHECK-BNF

## description:

### syntax
(pprint-check-bnf stream exp)
=> result

## arguments and values:
stream :=
exp :=
result :=

## affected by:

## side-effects:

## notes:

## exceptional-situations:

## tests:

“‘lisp
#?(pprint-check-bnf nil ’(check-bnf))
:outputs "(CHECK-BNF)"
“‘

“‘lisp
#?(pprint-check-bnf nil ’(check-bnf nil))
:outputs "(CHECK-BNF ())"
“‘

“‘lisp
#?(pprint-check-bnf nil ’(check-bnf nil nil))
:outputs "(CHECK-BNF () ())"
“‘

“‘lisp
#?(pprint-check-bnf nil ’(check-bnf nil not-list))
=> unspecified
“‘
depending on implementation.
CLISP specific guard #2.

“‘lisp
#?(pprint-check-bnf nil ’(check-bnf ()
((a symbol))
((b string))))
:outputs "(CHECK-BNF ()
((A SYMBOL))
((B STRING)))"
“‘

“‘lisp
#?(pprint-check-bnf nil ’(check-bnf ()
((a symbol))
((b string))))
:outputs "(CHECK-BNF ()
((A SYMBOL))
((B STRING)))"
“‘
CLISP specific guard #3.

“‘lisp
#?(format nil "~<~:@_~:>" nil)
=> ""
, :test
“‘

“‘lisp
#?(pprint-check-bnf nil ’(check-bnf ()
((function-name (or name setf-name)) (name symbol)
(setf-name ((eql setf) name))))) :outputs "(CHECK-BNF ()
((FUNCTION-NAME (OR NAME SETF-NAME))
(NAME SYMBOL)
(SETF-NAME ((EQL SETF) NAME))))"
“‘

“‘lisp
#?(PPRINT-CHECK-BNF NIL
’(CHECK-BNF () (A
B)))
:outputs "(CHECK-BNF ()
(A
B))"
“‘

Package

check-bnf.

Source

check-bnf.lisp.

Function: pprint-def-clause (stream exp &rest noise)
Package

check-bnf.

Source

check-bnf.lisp.

Function: pprint-def-elt (stream exp &rest noise)
Package

check-bnf.

Source

check-bnf.lisp.

Function: pprint-defbnf (stream exp)
Package

check-bnf.

Source

check-bnf.lisp.

Function: pprint-definitions (stream definitions &rest noise)
Package

check-bnf.

Source

check-bnf.lisp.

Function: resignaler (name actual-args)
Package

check-bnf.

Source

check-bnf.lisp.

Function: spec (name checker)
Package

check-bnf.

Source

check-bnf.lisp.

Reader: spec-checker (instance)
Package

check-bnf.

Source

check-bnf.lisp.

Target Slot

checker.

Reader: spec-name (instance)
Package

check-bnf.

Source

check-bnf.lisp.

Target Slot

name.

Function: spec-p (object)
Package

check-bnf.

Source

check-bnf.lisp.

Function: t-p (thing &optional *bnf*)
Package

check-bnf.

Source

check-bnf.lisp.


5.2.4 Generic functions

Generic Reader: bnf-definitions (object)
Package

check-bnf.

Methods
Reader Method: bnf-definitions ((checker checker))

automatically generated reader method

Source

check-bnf.lisp.

Target Slot

definitions.

Reader Method: bnf-definitions ((condition syntax-error))
Source

check-bnf.lisp.

Target Slot

definitions.

Generic Reader: whole-form<=syntax-error (condition)
Package

check-bnf.

Methods
Reader Method: whole-form<=syntax-error ((condition syntax-error))
Source

check-bnf.lisp.

Target Slot

whole.


5.2.5 Conditions

Condition: length-mismatch
Package

check-bnf.

Source

check-bnf.lisp.

Direct superclasses

syntax-error.

Condition: may-syntax-error
Package

check-bnf.

Source

check-bnf.lisp.

Direct superclasses

syntax-error.

Condition: violate-list
Package

check-bnf.

Source

check-bnf.lisp.

Direct superclasses

syntax-error.


5.2.6 Structures

Structure: spec
Package

check-bnf.

Source

check-bnf.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Type

symbol

Initform

(error "name is required for spec.")

Readers

spec-name.

Writers

This slot is read-only.

Slot: checker
Type

function

Initform

(error "checker is required for spec.")

Readers

spec-checker.

Writers

This slot is read-only.


5.2.7 Classes

Class: checker
Package

check-bnf.

Source

check-bnf.lisp.

Direct superclasses

funcallable-standard-object.

Direct methods
Direct slots
Slot: definitions
Initargs

:definitions

Readers

bnf-definitions.

Writers

This slot is read-only.


5.2.8 Types

Type: extended-marker ()
Package

check-bnf.

Source

check-bnf.lisp.

Type: type-specifier ()
Package

check-bnf.

Source

check-bnf.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   *   +   <  
A   B   C   D   E   F   G   I   L   M   P   R   S   T   W  
Index Entry  Section

*
*-checker: Private ordinary functions

+
+-checker: Private ordinary functions

<
<*form-body>: Private ordinary functions
<*form>: Private ordinary functions
<+form>: Private ordinary functions
<check-type-form>: Private ordinary functions
<declaration>: Public ordinary functions
<function-type>: Public ordinary functions
<lambda-list>: Public ordinary functions
<local-atom-check-form>: Private ordinary functions
<local-check-form>: Private ordinary functions
<local-cons-check-form>: Private ordinary functions
<local-fun>: Private ordinary functions
<local-or-check-form>: Private ordinary functions
<local-type-check-form>: Private ordinary functions
<require-form>: Private ordinary functions
<spec-form>: Private ordinary functions

A
at-least-n-cons: Private ordinary functions

B
bnf-definitions: Private generic functions
bnf-definitions: Private generic functions
bnf-definitions: Private generic functions
but-extended-marker: Private ordinary functions

C
capture-syntax-error: Private macros
cboundp: Private ordinary functions
check-bnf: Public macros
check-cons: Private ordinary functions
checker-p: Private ordinary functions
cons-equal: Private ordinary functions
copy-spec: Private ordinary functions

D
defbnf: Public macros
definitions: Private ordinary functions
doc: Public macros

E
extended-marker: Private ordinary functions

F
Function, *-checker: Private ordinary functions
Function, +-checker: Private ordinary functions
Function, <*form-body>: Private ordinary functions
Function, <*form>: Private ordinary functions
Function, <+form>: Private ordinary functions
Function, <check-type-form>: Private ordinary functions
Function, <declaration>: Public ordinary functions
Function, <function-type>: Public ordinary functions
Function, <lambda-list>: Public ordinary functions
Function, <local-atom-check-form>: Private ordinary functions
Function, <local-check-form>: Private ordinary functions
Function, <local-cons-check-form>: Private ordinary functions
Function, <local-fun>: Private ordinary functions
Function, <local-or-check-form>: Private ordinary functions
Function, <local-type-check-form>: Private ordinary functions
Function, <require-form>: Private ordinary functions
Function, <spec-form>: Private ordinary functions
Function, at-least-n-cons: Private ordinary functions
Function, but-extended-marker: Private ordinary functions
Function, cboundp: Private ordinary functions
Function, check-cons: Private ordinary functions
Function, checker-p: Private ordinary functions
Function, cons-equal: Private ordinary functions
Function, copy-spec: Private ordinary functions
Function, definitions: Private ordinary functions
Function, extended-marker: Private ordinary functions
Function, ignored: Private ordinary functions
Function, local-check: Private ordinary functions
Function, pprint-bnf: Private ordinary functions
Function, pprint-check-bnf: Private ordinary functions
Function, pprint-def-clause: Private ordinary functions
Function, pprint-def-elt: Private ordinary functions
Function, pprint-defbnf: Private ordinary functions
Function, pprint-definitions: Private ordinary functions
Function, resignaler: Private ordinary functions
Function, spec: Private ordinary functions
Function, spec-checker: Private ordinary functions
Function, spec-name: Private ordinary functions
Function, spec-p: Private ordinary functions
Function, syntax-error: Public ordinary functions
Function, t-p: Private ordinary functions

G
Generic Function, bnf-definitions: Private generic functions
Generic Function, whole-form<=syntax-error: Private generic functions

I
ignored: Private ordinary functions
initialize-instance: Public standalone methods

L
local-check: Private ordinary functions

M
Macro, capture-syntax-error: Private macros
Macro, check-bnf: Public macros
Macro, defbnf: Public macros
Macro, doc: Public macros
Method, bnf-definitions: Private generic functions
Method, bnf-definitions: Private generic functions
Method, initialize-instance: Public standalone methods
Method, whole-form<=syntax-error: Private generic functions

P
pprint-bnf: Private ordinary functions
pprint-check-bnf: Private ordinary functions
pprint-def-clause: Private ordinary functions
pprint-def-elt: Private ordinary functions
pprint-defbnf: Private ordinary functions
pprint-definitions: Private ordinary functions

R
resignaler: Private ordinary functions

S
spec: Private ordinary functions
spec-checker: Private ordinary functions
spec-name: Private ordinary functions
spec-p: Private ordinary functions
syntax-error: Public ordinary functions

T
t-p: Private ordinary functions

W
whole-form<=syntax-error: Private generic functions
whole-form<=syntax-error: Private generic functions