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

• check-bnf (macro).
• defbnf (macro).
• doc (macro).
• expression (type).
• initialize-instance (method).
• syntax-error (function).
• syntax-error (condition).

Internals

• *-checker (function).
• *bnf* (special variable).
• *default-condition* (special variable).
• *whole* (special variable).
• +-checker (function).
• <*form-body> (function).
• <*form> (function).
• <+form> (function).
• <check-type-form> (function).
• <local-atom-check-form> (function).
• <local-check-form> (function).
• <local-cons-check-form> (function).
• <local-fun> (function).
• <local-or-check-form> (function).
• <local-type-check-form> (function).
• <require-form> (function).
• <spec-form> (function).
• at-least-n-cons (function).
• bnf-definitions (reader method).
• bnf-definitions (reader method).
• but-extended-marker (function).
• capture-syntax-error (macro).
• cboundp (function).
• check-cons (function).
• checker (class).
• checker-p (function).
• cons-equal (function).
• copy-spec (function).
• definitions (function).
• extended-marker (function).
• extended-marker (type).
• ignored (function).
• length-mismatch (condition).
• local-check (function).
• may-syntax-error (condition).
• pprint-bnf (function).
• pprint-check-bnf (function).
• pprint-def-clause (function).
• pprint-def-elt (function).
• pprint-defbnf (function).
• pprint-definitions (function).
• resignaler (function).
• spec (function).
• spec (structure).
• spec-checker (reader).
• spec-name (reader).
• spec-p (function).
• t-p (function).
• type-specifier (type).
• violate-list (condition).
• whole-form<=syntax-error (reader method).

3.1.3 check-bnf/defbnf.lisp

Dependency

check-bnf.lisp (file).

Source

check-bnf.asd.

Parent Component

check-bnf (system).

Public Interface

• <declaration> (function).
• <function-type> (function).
• <lambda-list> (function).

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

• length-mismatch.
• may-syntax-error.
• violate-list.

Direct methods

• bnf-definitions.
• whole-form<=syntax-error.

Direct Default Initargs

Initarg	Value
: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.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

• bnf-definitions.
• initialize-instance.

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.