Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the check-bnf Reference Manual, version 6.5.3, generated automatically by Declt version 3.0 "Montgomery Scott" on Fri Jun 26 09:58:46 2020 GMT+0.
| • Introduction | What check-bnf is all about | |
| • Systems | The systems documentation | |
| • Files | The files documentation | |
| • Packages | The packages documentation | |
| • Definitions | The symbols documentation | |
| • Indexes | Concepts, functions, variables and data types |
Macro arguments checker.
Common Lisp has true macro. Writing macro means extending compiler i.e. creating new language.
Lack of documentations. Do you want to use LANGUAGE which has no documentation nor BNF?
Check-bnf provides bnf like syntax checker.
It allows you to write macro arguments definition.
It helps the third person to understand your macro.
(defmacro defun (&whole whole name lambda-list &body body)
(check-bnf (:whole whole)
((name (or symbol setf-name))
(setf-name ((eql setf) symbol)))
((lambda-list list)))
(list* name lambda-list body))
(defun "name" () :dummy)
;; SYNTAX-ERROR
Syntax-error in DEFUN
NAME := [ SYMBOL | SETF-NAME ]
SETF-NAME := ((EQL SETF) SYMBOL)
but "name"
in (DEFUN "name" NIL :DUMMY)
For detail, see spec/check-bnf.lisp
MIT
SBCL
Next: Files, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The check-bnf system |
SATO Shinichi
MIT
Macro arguments checker.
6.5.3
check-bnf.asd (file)
check-bnf.lisp (file)
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
| • The check-bnf.asd file | ||
| • The check-bnf/check-bnf.lisp file |
Next: The check-bnf/check-bnf․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
/home/quickref/quicklisp/dists/quicklisp/software/check-bnf-20200610-git/check-bnf.asd
check-bnf (system)
Previous: The check-bnf․asd file, Up: Lisp files [Contents][Index]
check-bnf (system)
check-bnf.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The check-bnf package |
check-bnf.lisp (file)
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions | ||
| • Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported macros | ||
| • Exported functions | ||
| • Exported conditions | ||
| • Exported types |
Next: Exported functions, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
# 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))))
:signals syntax-error
“‘
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 (let ((check-bnf::*whole* nil))
(let ((check-bnf::*bnf* ’((a t))))
(labels ((a (a)
(declare (ignore a))
nil))
(a a))))
“‘
“‘lisp
#?(check-bnf ()
((a* t)))
:expanded-to (let ((check-bnf::*whole* nil))
(let ((check-bnf::*bnf* ’((a* t))))
(labels ((a* (a*)
(if (typep a* ’(and atom (not null)))
(syntax-error ’a* "Require LIST but ~S." a*)
nil)))
(a* a*))))
“‘
Also it occur in OR form.
“‘lisp
#?(check-bnf ()
((a (or symbol t string))))
:expanded-to (let ((check-bnf::*whole* nil))
(let ((check-bnf::*bnf* ’((a (or symbol t string)))))
(labels ((a (a)
(declare (ignore a))
nil))
(a a))))
“‘
“‘lisp
#?(check-bnf ()
((a (or symbol b string))
(b t)))
:expanded-to (let ((check-bnf::*whole* nil))
(let ((check-bnf::*bnf* ’((a (or symbol b string))
(b t))))
(labels ((a (a)
(declare (ignore a))
nil)
(b (b)
(declare (ignore b))
nil))
(a a))))
“‘
“‘lisp
#?(check-bnf ()
((a (or b c))
(b integer)
(c t)))
:expanded-to (let ((check-bnf::*whole* nil))
(let ((check-bnf::*bnf* ’((a (or b c))
(b integer)
(c t))))
(labels ((a (a)
(declare (ignore a))
nil)
(b (b)
(unless (typep b ’integer)
(syntax-error ’b "but ~S, it is type-of ~S"
b (type-of b))))
(c (c)
(declare (ignore c))
nil))
(a a))))
“‘
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))))
:signals syntax-error
“‘
“‘lisp
#?(let ((var* :not-list))
(check-bnf ()
((var* symbol))))
:signals syntax-error
“‘
When expected T, efficient code is generated.
“‘lisp
#?(let ((option* ()))
(check-bnf:check-bnf ()
((option* keyword T))))
=> NIL
“‘
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))))
:signals syntax-error
“‘
“‘lisp
#?(let ((var* ’(:key 1 "not-key" 2)))
(check-bnf ()
((var* keyword integer))))
:signals syntax-error
“‘
“‘lisp
#?(let ((var* ’(not "ballanced" plist)))
(check-bnf ()
((var* keyword string))))
:signals syntax-error
“‘
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)))))
:signals syntax-error
“‘
“‘lisp
#?(let ((var* ’((:key "value") (:not "ballanced" clause))))
(check-bnf ()
((var* (keyword string)))))
:signals syntax-error
“‘
“‘lisp
#?(let ((var* ’((:key "value") (:not-ballanced))))
(check-bnf ()
((var* (keyword string)))))
:signals syntax-error
“‘
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))))
:signals syntax-error
“‘
“‘lisp
#?(let ((var+ ’("not-integer")))
(check-bnf ()
((var+ integer))))
:signals syntax-error
“‘
“‘lisp
#?(let ((var+ :not-cons))
(check-bnf ()
((var+ integer))))
:signals syntax-error
“‘
### 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.
note! clisp specific bug(?).
i do not know why but clisp does not call specified report function.
so header and footer is not generated.
after bug is removed, guard below will be failed.
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
“‘
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 ((option "not-symbol"))
(check-bnf ()
((option (or null symbol)))))
:signals syntax-error
“‘
“‘lisp
#?(let ((function-name "not function-name"))
(check-bnf ()
((function-name (or name setf-name))
(name symbol)
(setf-name ((eql setf) name)))))
:signals syntax-error
“‘
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))))
:signals syntax-error
“‘
## 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))))
:signals syntax-error
“‘
#### 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))))
:signals syntax-error
“‘
“‘lisp
#?(let ((var ’("string" "list")))
(check-bnf ()
((var (or string name*))
(name symbol))))
:signals syntax-error
“‘
#### 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))))
:signals syntax-error
“‘
“‘lisp
#?(let ((ll "not symbol"))
(check-bnf ()
((ll (var?))
(var symbol))))
:signals syntax-error
“‘
check-bnf.lisp (file)
Next: Exported conditions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
check-bnf.lisp (file)
Next: Exported types, Previous: Exported functions, Up: Exported definitions [Contents][Index]
check-bnf.lisp (file)
:whole
(quote nil)
whole-form<=syntax-error (generic function)
:definitions
(quote nil)
bnf-definitions (generic function)
| Initarg | Value |
|---|---|
| :format-control | "" |
Previous: Exported conditions, Up: Exported definitions [Contents][Index]
# EXPRESSION
## description:
## compound type specifier kind:
## compound type specifier syntax:
## compound type specifier arguments:
## compound type specifier description:
check-bnf.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal special variables | ||
| • Internal functions | ||
| • Internal generic functions | ||
| • Internal types |
Next: Internal functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
check-bnf.lisp (file)
check-bnf.lisp (file)
Next: Internal generic functions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
check-bnf.lisp (file)
# 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 say](https://clisp.sourceforge.io/impnotes.html#clpp)
### > the lisp pretty printer implementation is not perfect yet.
### so two tests below are ignored in clisp.
### fortunately this is just printing, not check-bnf feature itself.
check-bnf.lisp (file)
check-bnf.lisp (file)
Next: Internal types, Previous: Internal functions, Up: Internal definitions [Contents][Index]
check-bnf.lisp (file)
check-bnf.lisp (file)
Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
check-bnf.lisp (file)
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index | ||
| • Function index | ||
| • Variable index | ||
| • Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | C F L |
|---|
| Jump to: | C F L |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | *
+
<
B C D E F G I L M O P S T W |
|---|
| Jump to: | *
+
<
B C D E F G I L M O P S T W |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | *
D S W |
|---|
| Jump to: | *
D S W |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | C E P S T |
|---|
| Jump to: | C E P S T |
|---|