The check-bnf Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

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 Tue Nov 15 04:26:37 2022 GMT+0.

Table of Contents


1 Introduction

CHECK-BNF 8.0.0

What is this?

Macro arguments checker.

Current lisp world

Common Lisp has a true macro. Writing macro means extending the compiler i.e. creating a new language.

Issues

Lack of documentation. Do you want to use LANGUAGE which has no documentation nor BNF?

Proposal

Check-bnf provides a bnf like syntax checker.

It allows you to write macro arguments definition.

It helps the third person to understand your macro.

Usage

* (defmacro mydefun (&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))

MYDEFUN
* (mydefun "name" () :dummy)

debugger invoked on a SYNTAX-ERROR in thread
#<THREAD "main thread" RUNNING {10016C0073}>:
  NAME : "name" comes.
  Last failed at SETF-NAME.
    Detail: SETF-NAME require CONS but "name".

    Definition

    NAME      := [ SYMBOL | SETF-NAME ]
    SETF-NAME := ((EQL SETF) SYMBOL)

For detail, see spec file.

DOC

You may emb bnf as documentation. Macro DOC allows you to do it by read time evaluation and read time labeling.

(defmacro your-macro (&whole w a)
  #.(check-bnf:doc "Header for your-macro"
      #0=(check-bnf:check-bnf (:whole w)
           ((a symbol))))
  #0#
  `',a)
=> YOUR-MACRO

(documentation 'your-macro 'function)
=> "Header for your-macro
A := SYMBOL
"

DEFBNF

Your macro may have similar syntax e.g. CASE, CCASE, and ECASE. In such cases, you can define global BNF by DEFBNF.

DEFBNF has almost the same syntax as CHECK-BNF but except accepts only one definition and alias is invalid.

Currently <LAMBDA-LIST>, <FUNCTION-TYPE> and <DECLARATION> is provided.

From developer

Product's goal

License

MIT

Developed with

SBCL

Tested with

Known issue.

CCL

Due to its own issue, ccl signals warnings. But the check-bnf features are works fine. In the test, we just muffled it.

CLISP

CLISP say

The Lisp Pretty Printer implementation is not perfect yet.

CHECK-BNF works fine but the printed message is a little bit strange in clisp. For details see spec file.

ABCL

CHECK-BNF works fine but the printed message is a little bit strange in abcl due to the abcl pretty printing issue.

Currently tests about pretty printings are ignored.

Allegro

Allegro insert pprint logical block automatically for condition. Consequently, error message format becomes different from other implementations. Two tests about error message format are skipped.

(simple-condition-format-control (make-condition 'simple-condition :format-control ""))
=> "~1@<~:@>"

Installation

quicklisp supported.

* (ql:quickload :check-bnf)

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

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.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

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.


Previous: , Up: Packages   [Contents][Index]

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.


Next: , Previous: , Up: Definitions   [Contents][Index]

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.


Previous: , Up: Public Interface   [Contents][Index]

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


Next: , Previous: , Up: Internals   [Contents][Index]

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.


Next: , Previous: , Up: Internals   [Contents][Index]

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.


Next: , Previous: , Up: Internals   [Contents][Index]

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.


Next: , Previous: , Up: Internals   [Contents][Index]

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.


Next: , Previous: , Up: Internals   [Contents][Index]

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.


Next: , Previous: , Up: Internals   [Contents][Index]

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.


Previous: , Up: Internals   [Contents][Index]

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


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

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

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