macro_name: BIND-CUSTOM-VARS

library: cl-json

call_form: (bind-custom-vars)

status: expansion-error

error:
Error while parsing arguments to DEFMACRO BIND-CUSTOM-VARS:
  too few elements in
    ()
  to satisfy lambda list
    ((&REST CUSTOMIZATIONS) &BODY BODY):
  at least 1 expected, but got 0


call_form: (bind-custom-vars nil)

status: verified


call_form:
(bind-custom-vars nil
  nil)

expanded:
(let ()
  nil)


call_form:
(bind-custom-vars nil
  (progn))

expanded:
(let ()
  (progn))


call_form:
(bind-custom-vars nil
  :key
  nil)

expanded:
(let ()
  :key
  nil)


call_form: (bind-custom-vars 'lol-gen::some-name)


macro_name: WITH-DECODER-SIMPLE-LIST-SEMANTICS

call_form: (with-decoder-simple-list-semantics)

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-list-semantics))


call_form:
(with-decoder-simple-list-semantics
  nil)

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-list-semantics)
  nil)


call_form:
(with-decoder-simple-list-semantics
  nil
  nil)

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-list-semantics)
  nil
  nil)


call_form:
(with-decoder-simple-list-semantics
  nil
  (progn))

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-list-semantics)
  nil
  (progn))


call_form:
(with-decoder-simple-list-semantics
  nil
  :key
  nil)

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-list-semantics)
  nil
  :key
  nil)


call_form:
(with-decoder-simple-list-semantics
  'lol-gen::some-name)

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-list-semantics)
  'lol-gen::some-name)


macro_name: WITH-LOCAL-CLASS-REGISTRY

call_form: (with-local-class-registry)

error:
Error while parsing arguments to DEFMACRO WITH-LOCAL-CLASS-REGISTRY:
  too few elements in
    ()
  to satisfy lambda list
    ((&KEY INHERIT) &BODY BODY):
  at least 1 expected, but got 0


call_form: (with-local-class-registry nil)

expanded: (let ((*class-registry* nil)))


call_form:
(with-local-class-registry nil
  nil)

expanded:
(let ((*class-registry* nil))
  nil)


call_form:
(with-local-class-registry nil
  (progn))

expanded:
(let ((*class-registry* nil))
  (progn))


call_form:
(with-local-class-registry nil
  :key
  nil)

expanded:
(let ((*class-registry* nil))
  :key
  nil)


error:
Error while parsing arguments to WITH-LOCAL-CLASS-REGISTRY DEFMACRO:
  unknown keyword: QUOTE; expected one of :INHERIT


macro_name: WITH-CUSTOM-DECODER-LEVEL

call_form: (with-custom-decoder-level)

error:
Error while parsing arguments to DEFMACRO WITH-CUSTOM-DECODER-LEVEL:
  too few elements in
    ()
  to satisfy lambda list
    ((&REST CUSTOMIZATIONS) &BODY BODY):
  at least 1 expected, but got 0


call_form: (with-custom-decoder-level nil)

expanded:
(let ((current-decoder (current-decoder)))
  (bind-custom-vars (:internal-decoder current-decoder)))


call_form:
(with-custom-decoder-level nil
  nil)

expanded:
(let ((current-decoder (current-decoder)))
  (bind-custom-vars (:internal-decoder current-decoder)
    nil))


call_form:
(with-custom-decoder-level nil
  (progn))

expanded:
(let ((current-decoder (current-decoder)))
  (bind-custom-vars (:internal-decoder current-decoder)
    (progn)))


call_form:
(with-custom-decoder-level nil
  :key
  nil)

expanded:
(let ((current-decoder (current-decoder)))
  (bind-custom-vars (:internal-decoder current-decoder)
    :key
    nil))


expanded:
(let ((current-decoder (current-decoder quote)))
  (bind-custom-vars (:internal-decoder current-decoder quote
                     lol-gen::some-name)))


macro_name: WITH-DECODER-SIMPLE-CLOS-SEMANTICS

call_form: (with-decoder-simple-clos-semantics)

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-clos-semantics))


call_form:
(with-decoder-simple-clos-semantics
  nil)

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-clos-semantics)
  nil)


call_form:
(with-decoder-simple-clos-semantics
  nil
  nil)

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-clos-semantics)
  nil
  nil)


call_form:
(with-decoder-simple-clos-semantics
  nil
  (progn))

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-clos-semantics)
  nil
  (progn))


call_form:
(with-decoder-simple-clos-semantics
  nil
  :key
  nil)

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-clos-semantics)
  nil
  :key
  nil)


call_form:
(with-decoder-simple-clos-semantics
  'lol-gen::some-name)

expanded:
(with-shadowed-custom-vars
  (set-decoder-simple-clos-semantics)
  'lol-gen::some-name)


macro_name: WITH-GUESSING-ENCODER

call_form: (with-guessing-encoder)

expanded:
(with-local-encoder
  (use-guessing-encoder))


call_form:
(with-guessing-encoder
  nil)

expanded:
(with-local-encoder
  (use-guessing-encoder)
  nil)


call_form:
(with-guessing-encoder
  nil
  nil)

expanded:
(with-local-encoder
  (use-guessing-encoder)
  nil
  nil)


call_form:
(with-guessing-encoder
  nil
  (progn))

expanded:
(with-local-encoder
  (use-guessing-encoder)
  nil
  (progn))


call_form:
(with-guessing-encoder
  nil
  :key
  nil)

expanded:
(with-local-encoder
  (use-guessing-encoder)
  nil
  :key
  nil)


call_form:
(with-guessing-encoder
  'lol-gen::some-name)

expanded:
(with-local-encoder
  (use-guessing-encoder)
  'lol-gen::some-name)


error:
Error while parsing arguments to DEFMACRO WITH-SUBSTITUTE-PRINTED-REPRESENTATION-RESTART:
  too few elements in
    ()
  to satisfy lambda list
    ((OBJECT STREAM) &BODY BODY):
  at least 1 expected, but got 0


error:
Error while parsing arguments to DEFMACRO WITH-SUBSTITUTE-PRINTED-REPRESENTATION-RESTART:
  too few elements in
    ()
  to satisfy lambda list
    (OBJECT STREAM):
  exactly 2 expected, but got 0


call_form:
(with-substitute-printed-representation-restart nil
  nil)


call_form:
(with-substitute-printed-representation-restart nil
  (progn))


call_form:
(with-substitute-printed-representation-restart nil
  :key
  nil)


expanded:
(restart-case (progn)
  (substitute-printed-representation nil
   (let ((repr
          (with-output-to-string (s) (write quote :stream s :escape nil) nil)))
     (write-json-string repr lol-gen::some-name))))


macro_name: WITH-ARRAY

call_form: (with-array)

error:
Error while parsing arguments to DEFMACRO WITH-ARRAY:
  too few elements in
    ()
  to satisfy lambda list
    ((&OPTIONAL (STREAM)) &BODY BODY):
  at least 1 expected, but got 0


call_form: (with-array nil)

expanded:
(with-aggregate (array #\LEFT_SQUARE_BRACKET #\RIGHT_SQUARE_BRACKET
                 *json-output*))


call_form:
(with-array nil
  nil)

expanded:
(with-aggregate (array #\LEFT_SQUARE_BRACKET #\RIGHT_SQUARE_BRACKET
                 *json-output*)
  nil)


call_form:
(with-array nil
  (progn))

expanded:
(with-aggregate (array #\LEFT_SQUARE_BRACKET #\RIGHT_SQUARE_BRACKET
                 *json-output*)
  (progn))


call_form:
(with-array nil
  :key
  nil)

expanded:
(with-aggregate (array #\LEFT_SQUARE_BRACKET #\RIGHT_SQUARE_BRACKET
                 *json-output*)
  :key
  nil)


call_form: (with-array 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO WITH-ARRAY:
  too many elements in
    'LOL-GEN::SOME-NAME
  to satisfy lambda list
    (&OPTIONAL (STREAM)):
  between 0 and 1 expected, but got 2


macro_name: AS-OBJECT-MEMBER

call_form: (as-object-member)

error:
Error while parsing arguments to DEFMACRO AS-OBJECT-MEMBER:
  too few elements in
    ()
  to satisfy lambda list
    ((KEY &OPTIONAL (STREAM)) &BODY BODY):
  at least 1 expected, but got 0


call_form: (as-object-member nil)

error:
Error while parsing arguments to DEFMACRO AS-OBJECT-MEMBER:
  too few elements in
    ()
  to satisfy lambda list
    (KEY &OPTIONAL (STREAM)):
  between 1 and 2 expected, but got 0


call_form:
(as-object-member nil
  nil)


call_form:
(as-object-member nil
  (progn))


call_form:
(as-object-member nil
  :key
  nil)


call_form: (as-object-member 'lol-gen::some-name)

expanded:
(progn
 (next-aggregate-member 'object lol-gen::some-name)
 (let ((key (encode-json-to-string quote)))
   (if (char= (aref key 0) #\QUOTATION_MARK)
       (progn (write-string key lol-gen::some-name) nil)
       (encode-json key lol-gen::some-name)))
 (write-char #\COLON lol-gen::some-name))


macro_name: JSON-BIND

call_form: (json-bind)

error:
Error while parsing arguments to DEFMACRO JSON-BIND:
  too few elements in
    ()
  to satisfy lambda list
    ((&REST VARS) JSON-SOURCE &BODY BODY):
  at least 2 expected, but got 0


call_form: (json-bind nil)

error:
Error while parsing arguments to DEFMACRO JSON-BIND:
  too few elements in
    (NIL)
  to satisfy lambda list
    ((&REST VARS) JSON-SOURCE &BODY BODY):
  at least 2 expected, but got 1


call_form:
(json-bind nil
    nil)

expanded:
(let ((#:g134 (constantly t)))
  (let ((#:g131
         (custom-decoder :beginning-of-object #:g134 :object-key #:g134
                         :object-value #:g134 :end-of-object #:g134
                         :beginning-of-array #:g134 :array-member #:g134
                         :end-of-array #:g134 :beginning-of-string #:g134
                         :string-char #:g134 :end-of-string #:g134
                         :internal-decoder 'decode-json))
        (#:g130 (current-decoder))
        (#:g133 *object-key-handler*)
        (#:g132 *object-value-handler*))
    (declare (ignorable #:g130 #:g133 #:g132))
    (decode-json-from-source nil #:g131))
  (let ()))


call_form:
(json-bind nil
    (progn))

expanded:
(let ((#:g139 (constantly t)))
  (let ((#:g136
         (custom-decoder :beginning-of-object #:g139 :object-key #:g139
                         :object-value #:g139 :end-of-object #:g139
                         :beginning-of-array #:g139 :array-member #:g139
                         :end-of-array #:g139 :beginning-of-string #:g139
                         :string-char #:g139 :end-of-string #:g139
                         :internal-decoder 'decode-json))
        (#:g135 (current-decoder))
        (#:g138 *object-key-handler*)
        (#:g137 *object-value-handler*))
    (declare (ignorable #:g135 #:g138 #:g137))
    (decode-json-from-source (progn) #:g136))
  (let ()))


call_form:
(json-bind nil
    :key
  nil)

expanded:
(let ((#:g144 (constantly t)))
  (let ((#:g141
         (custom-decoder :beginning-of-object #:g144 :object-key #:g144
                         :object-value #:g144 :end-of-object #:g144
                         :beginning-of-array #:g144 :array-member #:g144
                         :end-of-array #:g144 :beginning-of-string #:g144
                         :string-char #:g144 :end-of-string #:g144
                         :internal-decoder 'decode-json))
        (#:g140 (current-decoder))
        (#:g143 *object-key-handler*)
        (#:g142 *object-value-handler*))
    (declare (ignorable #:g140 #:g143 #:g142))
    (decode-json-from-source :key #:g141))
  (let ()
    nil))


call_form: (json-bind 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO JSON-BIND:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    ((&REST VARS) JSON-SOURCE &BODY BODY):
  at least 2 expected, but got 1


macro_name: CUSTOM-DECODER

call_form: (custom-decoder)

expanded:
(lambda (&optional (stream *json-input*))
  (bind-custom-vars nil
    (decode-json stream)))


call_form: (custom-decoder nil)

expanded:
(lambda (&optional (stream *json-input*))
  (bind-custom-vars (nil)
    (decode-json stream)))


call_form: (custom-decoder nil nil)

expanded:
(lambda (&optional (stream *json-input*))
  (bind-custom-vars (nil nil)
    (decode-json stream)))


call_form: (custom-decoder nil (progn))

expanded:
(lambda (&optional (stream *json-input*))
  (bind-custom-vars (nil (progn))
    (decode-json stream)))


call_form: (custom-decoder nil :key nil)

expanded:
(lambda (&optional (stream *json-input*))
  (bind-custom-vars (nil :key nil)
    (decode-json stream)))


call_form: (custom-decoder 'lol-gen::some-name)

expanded:
(lambda (&optional (stream *json-input*))
  (bind-custom-vars ('lol-gen::some-name)
    (decode-json stream)))


macro_name: SET-CUSTOM-VARS

call_form: (set-custom-vars)

expanded: (setq)


call_form: (set-custom-vars nil)


call_form: (set-custom-vars nil nil)


call_form: (set-custom-vars nil (progn))


call_form: (set-custom-vars nil :key nil)


call_form: (set-custom-vars 'lol-gen::some-name)


macro_name: WITH-EXPLICIT-ENCODER

call_form: (with-explicit-encoder)

expanded:
(with-local-encoder
  (use-explicit-encoder))


call_form:
(with-explicit-encoder
  nil)

expanded:
(with-local-encoder
  (use-explicit-encoder)
  nil)


call_form:
(with-explicit-encoder
  nil
  nil)

expanded:
(with-local-encoder
  (use-explicit-encoder)
  nil
  nil)


call_form:
(with-explicit-encoder
  nil
  (progn))

expanded:
(with-local-encoder
  (use-explicit-encoder)
  nil
  (progn))


call_form:
(with-explicit-encoder
  nil
  :key
  nil)

expanded:
(with-local-encoder
  (use-explicit-encoder)
  nil
  :key
  nil)


call_form:
(with-explicit-encoder
  'lol-gen::some-name)

expanded:
(with-local-encoder
  (use-explicit-encoder)
  'lol-gen::some-name)


macro_name: WITH-SHADOWED-CUSTOM-VARS

call_form: (with-shadowed-custom-vars)

expanded:
(let ((*aggregate-scope-variables*
       (if (boundp '*aggregate-scope-variables*)
           *aggregate-scope-variables*))
      (*string-scope-variables*
       (if (boundp '*string-scope-variables*)
           *string-scope-variables*))
      (*array-scope-variables*
       (if (boundp '*array-scope-variables*)
           *array-scope-variables*))
      (*object-scope-variables*
       (if (boundp '*object-scope-variables*)
           *object-scope-variables*))
      (*internal-decoder*
       (if (boundp '*internal-decoder*)
           *internal-decoder*))
      (*end-of-object-handler*
       (if (boundp '*end-of-object-handler*)
           *end-of-object-handler*))
      (*object-value-handler*
       (if (boundp '*object-value-handler*)
           *object-value-handler*))
      (*object-key-handler*
       (if (boundp '*object-key-handler*)
           *object-key-handler*))
      (*beginning-of-object-handler*
       (if (boundp '*beginning-of-object-handler*)
           *beginning-of-object-handler*))
      (*json-array-type*
       (if (boundp '*json-array-type*)
           *json-array-type*))
      (*end-of-array-handler*
       (if (boundp '*end-of-array-handler*)
           *end-of-array-handler*))
      (*array-member-handler*
       (if (boundp '*array-member-handler*)
           *array-member-handler*))
      (*beginning-of-array-handler*
       (if (boundp '*beginning-of-array-handler*)
           *beginning-of-array-handler*))
      (*end-of-string-handler*
       (if (boundp '*end-of-string-handler*)
           *end-of-string-handler*))
      (*string-char-handler*
       (if (boundp '*string-char-handler*)
           *string-char-handler*))
      (*beginning-of-string-handler*
       (if (boundp '*beginning-of-string-handler*)
           *beginning-of-string-handler*))
      (*boolean-handler*
       (if (boundp '*boolean-handler*)
           *boolean-handler*))
      (*real-handler*
       (if (boundp '*real-handler*)
           *real-handler*))
      (*integer-handler*
       (if (boundp '*integer-handler*)
           *integer-handler*))))


call_form:
(with-shadowed-custom-vars
  nil)

expanded:
(let ((*aggregate-scope-variables*
       (if (boundp '*aggregate-scope-variables*)
           *aggregate-scope-variables*))
      (*string-scope-variables*
       (if (boundp '*string-scope-variables*)
           *string-scope-variables*))
      (*array-scope-variables*
       (if (boundp '*array-scope-variables*)
           *array-scope-variables*))
      (*object-scope-variables*
       (if (boundp '*object-scope-variables*)
           *object-scope-variables*))
      (*internal-decoder*
       (if (boundp '*internal-decoder*)
           *internal-decoder*))
      (*end-of-object-handler*
       (if (boundp '*end-of-object-handler*)
           *end-of-object-handler*))
      (*object-value-handler*
       (if (boundp '*object-value-handler*)
           *object-value-handler*))
      (*object-key-handler*
       (if (boundp '*object-key-handler*)
           *object-key-handler*))
      (*beginning-of-object-handler*
       (if (boundp '*beginning-of-object-handler*)
           *beginning-of-object-handler*))
      (*json-array-type*
       (if (boundp '*json-array-type*)
           *json-array-type*))
      (*end-of-array-handler*
       (if (boundp '*end-of-array-handler*)
           *end-of-array-handler*))
      (*array-member-handler*
       (if (boundp '*array-member-handler*)
           *array-member-handler*))
      (*beginning-of-array-handler*
       (if (boundp '*beginning-of-array-handler*)
           *beginning-of-array-handler*))
      (*end-of-string-handler*
       (if (boundp '*end-of-string-handler*)
           *end-of-string-handler*))
      (*string-char-handler*
       (if (boundp '*string-char-handler*)
           *string-char-handler*))
      (*beginning-of-string-handler*
       (if (boundp '*beginning-of-string-handler*)
           *beginning-of-string-handler*))
      (*boolean-handler*
       (if (boundp '*boolean-handler*)
           *boolean-handler*))
      (*real-handler*
       (if (boundp '*real-handler*)
           *real-handler*))
      (*integer-handler*
       (if (boundp '*integer-handler*)
           *integer-handler*)))
  nil)


call_form:
(with-shadowed-custom-vars
  nil
  nil)

expanded:
(let ((*aggregate-scope-variables*
       (if (boundp '*aggregate-scope-variables*)
           *aggregate-scope-variables*))
      (*string-scope-variables*
       (if (boundp '*string-scope-variables*)
           *string-scope-variables*))
      (*array-scope-variables*
       (if (boundp '*array-scope-variables*)
           *array-scope-variables*))
      (*object-scope-variables*
       (if (boundp '*object-scope-variables*)
           *object-scope-variables*))
      (*internal-decoder*
       (if (boundp '*internal-decoder*)
           *internal-decoder*))
      (*end-of-object-handler*
       (if (boundp '*end-of-object-handler*)
           *end-of-object-handler*))
      (*object-value-handler*
       (if (boundp '*object-value-handler*)
           *object-value-handler*))
      (*object-key-handler*
       (if (boundp '*object-key-handler*)
           *object-key-handler*))
      (*beginning-of-object-handler*
       (if (boundp '*beginning-of-object-handler*)
           *beginning-of-object-handler*))
      (*json-array-type*
       (if (boundp '*json-array-type*)
           *json-array-type*))
      (*end-of-array-handler*
       (if (boundp '*end-of-array-handler*)
           *end-of-array-handler*))
      (*array-member-handler*
       (if (boundp '*array-member-handler*)
           *array-member-handler*))
      (*beginning-of-array-handler*
       (if (boundp '*beginning-of-array-handler*)
           *beginning-of-array-handler*))
      (*end-of-string-handler*
       (if (boundp '*end-of-string-handler*)
           *end-of-string-handler*))
      (*string-char-handler*
       (if (boundp '*string-char-handler*)
           *string-char-handler*))
      (*beginning-of-string-handler*
       (if (boundp '*beginning-of-string-handler*)
           *beginning-of-string-handler*))
      (*boolean-handler*
       (if (boundp '*boolean-handler*)
           *boolean-handler*))
      (*real-handler*
       (if (boundp '*real-handler*)
           *real-handler*))
      (*integer-handler*
       (if (boundp '*integer-handler*)
           *integer-handler*)))
  nil
  nil)


call_form:
(with-shadowed-custom-vars
  nil
  (progn))

expanded:
(let ((*aggregate-scope-variables*
       (if (boundp '*aggregate-scope-variables*)
           *aggregate-scope-variables*))
      (*string-scope-variables*
       (if (boundp '*string-scope-variables*)
           *string-scope-variables*))
      (*array-scope-variables*
       (if (boundp '*array-scope-variables*)
           *array-scope-variables*))
      (*object-scope-variables*
       (if (boundp '*object-scope-variables*)
           *object-scope-variables*))
      (*internal-decoder*
       (if (boundp '*internal-decoder*)
           *internal-decoder*))
      (*end-of-object-handler*
       (if (boundp '*end-of-object-handler*)
           *end-of-object-handler*))
      (*object-value-handler*
       (if (boundp '*object-value-handler*)
           *object-value-handler*))
      (*object-key-handler*
       (if (boundp '*object-key-handler*)
           *object-key-handler*))
      (*beginning-of-object-handler*
       (if (boundp '*beginning-of-object-handler*)
           *beginning-of-object-handler*))
      (*json-array-type*
       (if (boundp '*json-array-type*)
           *json-array-type*))
      (*end-of-array-handler*
       (if (boundp '*end-of-array-handler*)
           *end-of-array-handler*))
      (*array-member-handler*
       (if (boundp '*array-member-handler*)
           *array-member-handler*))
      (*beginning-of-array-handler*
       (if (boundp '*beginning-of-array-handler*)
           *beginning-of-array-handler*))
      (*end-of-string-handler*
       (if (boundp '*end-of-string-handler*)
           *end-of-string-handler*))
      (*string-char-handler*
       (if (boundp '*string-char-handler*)
           *string-char-handler*))
      (*beginning-of-string-handler*
       (if (boundp '*beginning-of-string-handler*)
           *beginning-of-string-handler*))
      (*boolean-handler*
       (if (boundp '*boolean-handler*)
           *boolean-handler*))
      (*real-handler*
       (if (boundp '*real-handler*)
           *real-handler*))
      (*integer-handler*
       (if (boundp '*integer-handler*)
           *integer-handler*)))
  nil
  (progn))


call_form:
(with-shadowed-custom-vars
  nil
  :key
  nil)

expanded:
(let ((*aggregate-scope-variables*
       (if (boundp '*aggregate-scope-variables*)
           *aggregate-scope-variables*))
      (*string-scope-variables*
       (if (boundp '*string-scope-variables*)
           *string-scope-variables*))
      (*array-scope-variables*
       (if (boundp '*array-scope-variables*)
           *array-scope-variables*))
      (*object-scope-variables*
       (if (boundp '*object-scope-variables*)
           *object-scope-variables*))
      (*internal-decoder*
       (if (boundp '*internal-decoder*)
           *internal-decoder*))
      (*end-of-object-handler*
       (if (boundp '*end-of-object-handler*)
           *end-of-object-handler*))
      (*object-value-handler*
       (if (boundp '*object-value-handler*)
           *object-value-handler*))
      (*object-key-handler*
       (if (boundp '*object-key-handler*)
           *object-key-handler*))
      (*beginning-of-object-handler*
       (if (boundp '*beginning-of-object-handler*)
           *beginning-of-object-handler*))
      (*json-array-type*
       (if (boundp '*json-array-type*)
           *json-array-type*))
      (*end-of-array-handler*
       (if (boundp '*end-of-array-handler*)
           *end-of-array-handler*))
      (*array-member-handler*
       (if (boundp '*array-member-handler*)
           *array-member-handler*))
      (*beginning-of-array-handler*
       (if (boundp '*beginning-of-array-handler*)
           *beginning-of-array-handler*))
      (*end-of-string-handler*
       (if (boundp '*end-of-string-handler*)
           *end-of-string-handler*))
      (*string-char-handler*
       (if (boundp '*string-char-handler*)
           *string-char-handler*))
      (*beginning-of-string-handler*
       (if (boundp '*beginning-of-string-handler*)
           *beginning-of-string-handler*))
      (*boolean-handler*
       (if (boundp '*boolean-handler*)
           *boolean-handler*))
      (*real-handler*
       (if (boundp '*real-handler*)
           *real-handler*))
      (*integer-handler*
       (if (boundp '*integer-handler*)
           *integer-handler*)))
  nil
  :key
  nil)


call_form:
(with-shadowed-custom-vars
  'lol-gen::some-name)

expanded:
(let ((*aggregate-scope-variables*
       (if (boundp '*aggregate-scope-variables*)
           *aggregate-scope-variables*))
      (*string-scope-variables*
       (if (boundp '*string-scope-variables*)
           *string-scope-variables*))
      (*array-scope-variables*
       (if (boundp '*array-scope-variables*)
           *array-scope-variables*))
      (*object-scope-variables*
       (if (boundp '*object-scope-variables*)
           *object-scope-variables*))
      (*internal-decoder*
       (if (boundp '*internal-decoder*)
           *internal-decoder*))
      (*end-of-object-handler*
       (if (boundp '*end-of-object-handler*)
           *end-of-object-handler*))
      (*object-value-handler*
       (if (boundp '*object-value-handler*)
           *object-value-handler*))
      (*object-key-handler*
       (if (boundp '*object-key-handler*)
           *object-key-handler*))
      (*beginning-of-object-handler*
       (if (boundp '*beginning-of-object-handler*)
           *beginning-of-object-handler*))
      (*json-array-type*
       (if (boundp '*json-array-type*)
           *json-array-type*))
      (*end-of-array-handler*
       (if (boundp '*end-of-array-handler*)
           *end-of-array-handler*))
      (*array-member-handler*
       (if (boundp '*array-member-handler*)
           *array-member-handler*))
      (*beginning-of-array-handler*
       (if (boundp '*beginning-of-array-handler*)
           *beginning-of-array-handler*))
      (*end-of-string-handler*
       (if (boundp '*end-of-string-handler*)
           *end-of-string-handler*))
      (*string-char-handler*
       (if (boundp '*string-char-handler*)
           *string-char-handler*))
      (*beginning-of-string-handler*
       (if (boundp '*beginning-of-string-handler*)
           *beginning-of-string-handler*))
      (*boolean-handler*
       (if (boundp '*boolean-handler*)
           *boolean-handler*))
      (*real-handler*
       (if (boundp '*real-handler*)
           *real-handler*))
      (*integer-handler*
       (if (boundp '*integer-handler*)
           *integer-handler*)))
  'lol-gen::some-name)


macro_name: AS-ARRAY-MEMBER

call_form: (as-array-member)

error:
Error while parsing arguments to DEFMACRO AS-ARRAY-MEMBER:
  too few elements in
    ()
  to satisfy lambda list
    ((&OPTIONAL (STREAM)) &BODY BODY):
  at least 1 expected, but got 0


call_form: (as-array-member nil)

expanded: (progn (next-aggregate-member 'array *json-output*))


call_form:
(as-array-member nil
  nil)

expanded: (progn (next-aggregate-member 'array *json-output*) nil)


call_form:
(as-array-member nil
  (progn))

expanded: (progn (next-aggregate-member 'array *json-output*) (progn))


call_form:
(as-array-member nil
  :key
  nil)

expanded: (progn (next-aggregate-member 'array *json-output*) :key nil)


call_form: (as-array-member 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO AS-ARRAY-MEMBER:
  too many elements in
    'LOL-GEN::SOME-NAME
  to satisfy lambda list
    (&OPTIONAL (STREAM)):
  between 0 and 1 expected, but got 2


macro_name: WITH-OBJECT

call_form: (with-object)

error:
Error while parsing arguments to DEFMACRO WITH-OBJECT:
  too few elements in
    ()
  to satisfy lambda list
    ((&OPTIONAL (STREAM)) &BODY BODY):
  at least 1 expected, but got 0


call_form: (with-object nil)

expanded:
(with-aggregate (object #\LEFT_CURLY_BRACKET #\RIGHT_CURLY_BRACKET
                 *json-output*))


call_form:
(with-object nil
  nil)

expanded:
(with-aggregate (object #\LEFT_CURLY_BRACKET #\RIGHT_CURLY_BRACKET
                 *json-output*)
  nil)


call_form:
(with-object nil
  (progn))

expanded:
(with-aggregate (object #\LEFT_CURLY_BRACKET #\RIGHT_CURLY_BRACKET
                 *json-output*)
  (progn))


call_form:
(with-object nil
  :key
  nil)

expanded:
(with-aggregate (object #\LEFT_CURLY_BRACKET #\RIGHT_CURLY_BRACKET
                 *json-output*)
  :key
  nil)


call_form: (with-object 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO WITH-OBJECT:
  too many elements in
    'LOL-GEN::SOME-NAME
  to satisfy lambda list
    (&OPTIONAL (STREAM)):
  between 0 and 1 expected, but got 2


macro_name: CURRENT-DECODER

call_form: (current-decoder)

expanded:
(let ((#:g163 *integer-handler*)
      (#:g162 *real-handler*)
      (#:g161 *boolean-handler*)
      (#:g160 *beginning-of-string-handler*)
      (#:g159 *string-char-handler*)
      (#:g158 *end-of-string-handler*)
      (#:g157 *beginning-of-array-handler*)
      (#:g156 *array-member-handler*)
      (#:g155 *end-of-array-handler*)
      (#:g154 *json-array-type*)
      (#:g153 *beginning-of-object-handler*)
      (#:g152 *object-key-handler*)
      (#:g151 *object-value-handler*)
      (#:g150 *end-of-object-handler*)
      (#:g149 *internal-decoder*)
      (#:g148 *object-scope-variables*)
      (#:g147 *array-scope-variables*)
      (#:g146 *string-scope-variables*)
      (#:g145 *aggregate-scope-variables*))
  (custom-decoder :integer #:g163 :real #:g162 :boolean #:g161
                  :beginning-of-string #:g160 :string-char #:g159
                  :end-of-string #:g158 :beginning-of-array #:g157
                  :array-member #:g156 :end-of-array #:g155 :array-type #:g154
                  :beginning-of-object #:g153 :object-key #:g152 :object-value
                  #:g151 :end-of-object #:g150 :internal-decoder #:g149
                  :object-scope #:g148 :array-scope #:g147 :string-scope #:g146
                  :aggregate-scope #:g145))


call_form: (current-decoder nil)

expanded:
(let ((#:g164 nil))
  (custom-decoder nil #:g164))


call_form: (current-decoder nil nil)

expanded:
(let ((#:g166 nil) (#:g165 nil))
  (custom-decoder nil #:g166 nil #:g165))


call_form: (current-decoder nil (progn))

expanded:
(let ((#:g168 nil) (#:g167 nil))
  (custom-decoder (progn) #:g168 nil #:g167))


call_form: (current-decoder nil :key nil)


call_form: (current-decoder 'lol-gen::some-name)

expanded:
(let ((#:g172 nil))
  (custom-decoder 'lol-gen::some-name #:g172))