macro_name: DEFEXPRESSION

library: c-mera

call_form: (defexpression)

status: expansion-error

error:
Error while parsing arguments to DEFMACRO DEFEXPRESSION:
  too few elements in
    ()
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 0


call_form: (defexpression nil)

error:
Error while parsing arguments to DEFMACRO DEFEXPRESSION:
  too few elements in
    (NIL)
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 1


call_form: (defexpression nil nil)

error:
Error while parsing arguments to DEFMACRO DEFEXPRESSION:
  too few elements in
    (NIL NIL)
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 2


call_form: (defexpression nil (progn))

error:
Error while parsing arguments to DEFMACRO DEFEXPRESSION:
  too few elements in
    (NIL (PROGN))
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 2


call_form: (defexpression nil :key nil)

error:
The value
  :KEY
is not of type
  LIST
when binding SB-IMPL::X


call_form: (defexpression 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO DEFEXPRESSION:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 1


macro_name: DEFPRETTYMETHOD

call_form: (defprettymethod)

error:
Error while parsing arguments to DEFMACRO DEFPRETTYMETHOD:
  too few elements in
    ()
  to satisfy lambda list
    (QUALIFIER NODE &BODY BODY):
  at least 2 expected, but got 0


call_form: (defprettymethod nil)

error:
Error while parsing arguments to DEFMACRO DEFPRETTYMETHOD:
  too few elements in
    (NIL)
  to satisfy lambda list
    (QUALIFIER NODE &BODY BODY):
  at least 2 expected, but got 1


call_form:
(defprettymethod nil
    nil)

expanded:
(defmethod traverser nil ((pp pretty-printer) (item nil) level)
  (declare (ignorable level))
  (with-slots (values subnodes)
      item))

status: verified


call_form:
(defprettymethod nil
    (progn))

expanded:
(defmethod traverser nil ((pp pretty-printer) (item (progn)) level)
  (declare (ignorable level))
  (with-slots (values subnodes)
      item))


call_form:
(defprettymethod nil
    :key
  nil)

expanded:
(defmethod traverser nil ((pp pretty-printer) (item :key) level)
  (declare (ignorable level))
  (with-slots (values subnodes)
      item
    nil))


call_form: (defprettymethod 'lol-gen::some-name)

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


macro_name: QUOTY

call_form: (quoty)

error:
Error while parsing arguments to DEFMACRO QUOTY:
  too few elements in
    ()
  to satisfy lambda list
    (ITEM):
  exactly 1 expected, but got 0


call_form: (quoty nil nil)

error:
Error while parsing arguments to DEFMACRO QUOTY:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (ITEM):
  exactly 1 expected, but got 2


call_form: (quoty nil (progn))

error:
Error while parsing arguments to DEFMACRO QUOTY:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (ITEM):
  exactly 1 expected, but got 2


call_form: (quoty nil :key nil)

error:
Error while parsing arguments to DEFMACRO QUOTY:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (ITEM):
  exactly 1 expected, but got 3


call_form: (quoty 'lol-gen::some-name)


macro_name: DEL-PROXY

call_form: (del-proxy)

error:
Error while parsing arguments to DEFMACRO DEL-PROXY:
  too few elements in
    ()
  to satisfy lambda list
    (SLOT &KEY (NODE-NAME)):
  at least 1 expected, but got 0


call_form: (del-proxy nil)

expanded:
(let ((#:g300 (slot-value item 'nil)))
  (if (eql (find-class 'nodelist) (class-of (slot-value item 'nil)))
      (let ((#:g301 (slot-value (slot-value item 'nil) 'nodes)))
        (setf (slot-value (slot-value item 'nil) 'nodes)
                (loop for i in #:g301
                      collect (slot-value i 'proxy-subnode))))
      (if #:g300
          (setf (slot-value item 'nil) (slot-value #:g300 'proxy-subnode)))))


call_form: (del-proxy nil nil)

error:
Error while parsing arguments to DEL-PROXY DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


call_form: (del-proxy nil (progn))

error:
Error while parsing arguments to DEL-PROXY DEFMACRO:
  odd number of elements in keyword/value list: ((PROGN))


call_form: (del-proxy nil :key nil)

error:
Error while parsing arguments to DEL-PROXY DEFMACRO:
  unknown keyword: :KEY; expected one of :NODE-NAME


call_form: (del-proxy 'lol-gen::some-name)

expanded:
(let ((#:g302 (slot-value item ''lol-gen::some-name)))
  (if (eql (find-class 'nodelist)
           (class-of (slot-value item ''lol-gen::some-name)))
      (let ((#:g303 (slot-value (slot-value item ''lol-gen::some-name) 'nodes)))
        (setf (slot-value (slot-value item ''lol-gen::some-name) 'nodes)
                (loop for i in #:g303
                      collect (slot-value i 'proxy-subnode))))
      (if #:g302
          (setf (slot-value item ''lol-gen::some-name)
                  (slot-value #:g302 'proxy-subnode)))))


macro_name: DEFINE-PROCESSOR

call_form: (define-processor)

expanded:
(defun nil (args)
  (multiple-value-bind (input output debug)
      (parse-cmdline args nil)
    (when input
      (let ((tree nil) (pprint (make-instance 'pretty-printer)))
        (setf tree (nil input))
        (if output
            (with-open-file
                (stream output :direction :output :if-exists :supersede
                 :if-does-not-exist :create)
              (setf (slot-value pprint 'stream) stream)
              (traverser pprint tree 0))
            (progn
             (setf (slot-value pprint 'stream) *standard-output*)
             (traverser pprint tree 0)
             (format t "~&")))))))


call_form: (define-processor nil)

error:
Error while parsing arguments to DEFINE-PROCESSOR DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


call_form: (define-processor nil nil)

error:
Error while parsing arguments to DEFINE-PROCESSOR DEFMACRO:
  unknown keyword: NIL; expected one of :NAME, :FILE-READER, :STRING-READER, :EXTRA-TRAVERSER


call_form: (define-processor nil (progn))


call_form: (define-processor nil :key nil)

error:
Error while parsing arguments to DEFINE-PROCESSOR DEFMACRO:
  odd number of elements in keyword/value list: (NIL :KEY NIL)


call_form: (define-processor 'lol-gen::some-name)

error:
Error while parsing arguments to DEFINE-PROCESSOR DEFMACRO:
  odd number of elements in keyword/value list: ('LOL-GEN::SOME-NAME)


macro_name: DELPRETTYMETHOD

call_form: (delprettymethod)

error:
Error while parsing arguments to DEFMACRO DELPRETTYMETHOD:
  too few elements in
    ()
  to satisfy lambda list
    (QUALIFIER NODE):
  exactly 2 expected, but got 0


call_form: (delprettymethod nil)

error:
Error while parsing arguments to DEFMACRO DELPRETTYMETHOD:
  too few elements in
    (NIL)
  to satisfy lambda list
    (QUALIFIER NODE):
  exactly 2 expected, but got 1


call_form: (delprettymethod nil nil)

error: #<STANDARD-CLASS C-MERA:PRETTY-PRINTER> cannot be printed readably.


call_form: (delprettymethod nil (progn))


call_form: (delprettymethod nil :key nil)

error:
Error while parsing arguments to DEFMACRO DELPRETTYMETHOD:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (QUALIFIER NODE):
  exactly 2 expected, but got 3


call_form: (delprettymethod 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO DELPRETTYMETHOD:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (QUALIFIER NODE):
  exactly 2 expected, but got 1


macro_name: DEFPROXYPRINT

call_form: (defproxyprint)

error:
Error while parsing arguments to DEFMACRO DEFPROXYPRINT:
  too few elements in
    ()
  to satisfy lambda list
    (QUALIFIER NODE &BODY BODY):
  at least 2 expected, but got 0


call_form: (defproxyprint nil)

error:
Error while parsing arguments to DEFMACRO DEFPROXYPRINT:
  too few elements in
    (NIL)
  to satisfy lambda list
    (QUALIFIER NODE &BODY BODY):
  at least 2 expected, but got 1


call_form:
(defproxyprint nil
    nil)

expanded:
(defproxymethod nil
    (pp pretty-printer)
    nil)


call_form:
(defproxyprint nil
    (progn))

expanded:
(defproxymethod nil
    (pp pretty-printer)
    (progn))


call_form:
(defproxyprint nil
    :key
  nil)

expanded:
(defproxymethod nil
    (pp pretty-printer)
    :key
  nil)


call_form: (defproxyprint 'lol-gen::some-name)

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


macro_name: DEFINE-SWITCHES

call_form: (define-switches)

expanded:
(progn
 (defun nil ()
   (setf *c-mera-reader* 'cl)
   (setf *readtable* *readtable-backup*))
 (defun nil ()
   (setf *c-mera-reader* 'cm)
   (setf (readtable-case *readtable*) :invert)))


call_form: (define-switches nil)

error:
Error while parsing arguments to DEFINE-SWITCHES DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


call_form: (define-switches nil nil)

error:
Error while parsing arguments to DEFINE-SWITCHES DEFMACRO:
  unknown keyword: NIL; expected one of :CL-READER, :CM-READER, :MACRO-CHARACTER


call_form: (define-switches nil (progn))


call_form: (define-switches nil :key nil)

error:
Error while parsing arguments to DEFINE-SWITCHES DEFMACRO:
  odd number of elements in keyword/value list: (NIL :KEY NIL)


call_form: (define-switches 'lol-gen::some-name)

error:
Error while parsing arguments to DEFINE-SWITCHES DEFMACRO:
  odd number of elements in keyword/value list: ('LOL-GEN::SOME-NAME)


macro_name: WITH-PROXYNODES

call_form: (with-proxynodes)

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


call_form: (with-proxynodes nil)

expanded: (progn)


call_form:
(with-proxynodes nil
  nil)

expanded: (progn nil)


call_form:
(with-proxynodes nil
  (progn))

expanded: (progn (progn))


call_form:
(with-proxynodes nil
  :key
  nil)

expanded: (progn :key nil)


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

expanded:
(let ((quote '#:proxy-quote-304))
  (defproxy #:proxy-quote-304)
  (with-proxynodes (lol-gen::some-name)))


macro_name: FUNCTION-CALL

call_form: (function-call)

error:
Error while parsing arguments to DEFMACRO FUNCTION-CALL:
  too few elements in
    ()
  to satisfy lambda list
    (FUNCTION ARGUMENTS):
  exactly 2 expected, but got 0


call_form: (function-call nil)

error:
Error while parsing arguments to DEFMACRO FUNCTION-CALL:
  too few elements in
    (NIL)
  to satisfy lambda list
    (FUNCTION ARGUMENTS):
  exactly 2 expected, but got 1


call_form: (function-call nil nil)

expanded:
(make-instance 'function-call :function nil :arguments nil :values 'nil
               :subnodes '#'arguments)


call_form: (function-call nil (progn))

expanded:
(make-instance 'function-call :function nil :arguments (progn) :values 'nil
               :subnodes '#'arguments)


call_form: (function-call nil :key nil)

error:
Error while parsing arguments to DEFMACRO FUNCTION-CALL:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (FUNCTION ARGUMENTS):
  exactly 2 expected, but got 3


call_form: (function-call 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO FUNCTION-CALL:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (FUNCTION ARGUMENTS):
  exactly 2 expected, but got 1


macro_name: SOURCE-POSITION

call_form: (source-position)

error:
Error while parsing arguments to DEFMACRO SOURCE-POSITION:
  too few elements in
    ()
  to satisfy lambda list
    (LINE FILE SUBNODE):
  exactly 3 expected, but got 0


call_form: (source-position nil)

error:
Error while parsing arguments to DEFMACRO SOURCE-POSITION:
  too few elements in
    (NIL)
  to satisfy lambda list
    (LINE FILE SUBNODE):
  exactly 3 expected, but got 1


call_form: (source-position nil nil)

error:
Error while parsing arguments to DEFMACRO SOURCE-POSITION:
  too few elements in
    (NIL NIL)
  to satisfy lambda list
    (LINE FILE SUBNODE):
  exactly 3 expected, but got 2


call_form: (source-position nil (progn))

error:
Error while parsing arguments to DEFMACRO SOURCE-POSITION:
  too few elements in
    (NIL (PROGN))
  to satisfy lambda list
    (LINE FILE SUBNODE):
  exactly 3 expected, but got 2


call_form: (source-position nil :key nil)

expanded:
(make-instance 'source-position :line nil :file :key :subnode nil :values
               '(line file) :subnodes '(subnode))


call_form: (source-position 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO SOURCE-POSITION:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (LINE FILE SUBNODE):
  exactly 3 expected, but got 1


macro_name: IDENTIFIER

call_form: (identifier)

error:
Error while parsing arguments to DEFMACRO IDENTIFIER:
  too few elements in
    ()
  to satisfy lambda list
    (IDENTIFIER):
  exactly 1 expected, but got 0


call_form: (identifier nil)

expanded: (make-instance 'identifier :identifier nil :values '(identifier) :subnodes 'nil)


call_form: (identifier nil nil)

error:
Error while parsing arguments to DEFMACRO IDENTIFIER:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (IDENTIFIER):
  exactly 1 expected, but got 2


call_form: (identifier nil (progn))

error:
Error while parsing arguments to DEFMACRO IDENTIFIER:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (IDENTIFIER):
  exactly 1 expected, but got 2


call_form: (identifier nil :key nil)

error:
Error while parsing arguments to DEFMACRO IDENTIFIER:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (IDENTIFIER):
  exactly 1 expected, but got 3


call_form: (identifier 'lol-gen::some-name)

expanded:
(make-instance 'identifier :identifier 'lol-gen::some-name :values
               '(identifier) :subnodes 'nil)


macro_name: MAKE-PROXY

call_form: (make-proxy)

error:
Error while parsing arguments to DEFMACRO MAKE-PROXY:
  too few elements in
    ()
  to satisfy lambda list
    (SLOT NODE-TYPE &KEY (NODE-NAME) (PARENT)):
  at least 2 expected, but got 0


call_form: (make-proxy nil)

error:
Error while parsing arguments to DEFMACRO MAKE-PROXY:
  too few elements in
    (NIL)
  to satisfy lambda list
    (SLOT NODE-TYPE &KEY (NODE-NAME) (PARENT)):
  at least 2 expected, but got 1


call_form: (make-proxy nil nil)

expanded:
(if (or (eql (find-class 'nodelist) (class-of (slot-value item 'nil))))
    (let ((#:g305 (slot-value (slot-value item 'nil) 'nodes)))
      (setf (slot-value (slot-value item 'nil) 'nodes)
              (loop for i in #:g305
                    collect (make-instance nil :parent item :proxy-subnode i
                                           :values 'nil :subnodes
                                           '(proxy-subnode)))))
    (let ((#:g305 (slot-value item 'nil)))
      (if #:g305
          (setf (slot-value item 'nil)
                  (make-instance nil :parent item :proxy-subnode #:g305 :values
                                 'nil :subnodes '(proxy-subnode)))
          (setf (slot-value item 'nil)
                  (make-instance nil :parent item :proxy-subnode nil :values
                                 'nil :subnodes '(proxy-subnode))))))


call_form: (make-proxy nil (progn))

expanded:
(if (or (eql (find-class 'nodelist) (class-of (slot-value item 'nil))))
    (let ((#:g306 (slot-value (slot-value item 'nil) 'nodes)))
      (setf (slot-value (slot-value item 'nil) 'nodes)
              (loop for i in #:g306
                    collect (make-instance (progn) :parent item :proxy-subnode
                                           i :values 'nil :subnodes
                                           '(proxy-subnode)))))
    (let ((#:g306 (slot-value item 'nil)))
      (if #:g306
          (setf (slot-value item 'nil)
                  (make-instance (progn) :parent item :proxy-subnode #:g306
                                 :values 'nil :subnodes '(proxy-subnode)))
          (setf (slot-value item 'nil)
                  (make-instance (progn) :parent item :proxy-subnode nil
                                 :values 'nil :subnodes '(proxy-subnode))))))


call_form: (make-proxy nil :key nil)

error:
Error while parsing arguments to MAKE-PROXY DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


call_form: (make-proxy 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO MAKE-PROXY:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (SLOT NODE-TYPE &KEY (NODE-NAME) (PARENT)):
  at least 2 expected, but got 1


macro_name: DEFNODE

call_form: (defnode)

error:
Error while parsing arguments to DEFMACRO DEFNODE:
  too few elements in
    ()
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 0


call_form: (defnode nil)

error:
Error while parsing arguments to DEFMACRO DEFNODE:
  too few elements in
    (NIL)
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 1


call_form: (defnode nil nil)

error:
Error while parsing arguments to DEFMACRO DEFNODE:
  too few elements in
    (NIL NIL)
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 2


call_form: (defnode nil (progn))

error:
Error while parsing arguments to DEFMACRO DEFNODE:
  too few elements in
    (NIL (PROGN))
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 2


call_form: (defnode nil :key nil)

error:
The value
  :KEY
is not of type
  LIST
when binding SB-IMPL::X


call_form: (defnode 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO DEFNODE:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 1


macro_name: DEFINE-READER

call_form: (define-reader)

expanded:
(progn
 (defun nil (file &key (debug nil))
   "Read c-mera source file and return AST"
   (let ((asts nil) (*readtable* (copy-readtable nil)))
     (setf (readtable-case *readtable*) :invert)
     (with-open-file (in file)
       (loop for s-expr = (read in nil nil nil)
             while s-expr
             do (let* ((s-expr (eval s-expr))
                       (evaluated
                        (if (listp s-expr)
                            s-expr
                            (list s-expr))))
                  (when (typep (car evaluated) 'node)
                    (setf asts (append asts evaluated))))))
     (nodelist asts)))
 (defun nil (str)
   "Rread c-mera source string and return AST"
   (let ((asts nil) (*readtable* (copy-readtable nil)))
     (setf (readtable-case *readtable*) :invert)
     (let* ((s-expr (eval (read-from-string str)))
            (evaluated
             (if (listp s-expr)
                 s-expr
                 (list s-expr))))
       (when (typep (car evaluated) 'node) (setf asts evaluated)))
     (nodelist asts))))


call_form: (define-reader nil)

error:
Error while parsing arguments to DEFINE-READER DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


call_form: (define-reader nil nil)

error:
Error while parsing arguments to DEFINE-READER DEFMACRO:
  unknown keyword: NIL; expected one of :FILE-READER, :STRING-READER, :MACRO-CHARACTER


call_form: (define-reader nil (progn))


call_form: (define-reader nil :key nil)

error:
Error while parsing arguments to DEFINE-READER DEFMACRO:
  odd number of elements in keyword/value list: (NIL :KEY NIL)


call_form: (define-reader 'lol-gen::some-name)

error:
Error while parsing arguments to DEFINE-READER DEFMACRO:
  odd number of elements in keyword/value list: ('LOL-GEN::SOME-NAME)


macro_name: CHARACTER-LITERAL

call_form: (character-literal)

error:
Error while parsing arguments to DEFMACRO CHARACTER-LITERAL:
  too few elements in
    ()
  to satisfy lambda list
    (CHARACTER):
  exactly 1 expected, but got 0


call_form: (character-literal nil)

expanded:
(make-instance 'character-literal :character nil :values '(character) :subnodes
               'nil)


call_form: (character-literal nil nil)

error:
Error while parsing arguments to DEFMACRO CHARACTER-LITERAL:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (CHARACTER):
  exactly 1 expected, but got 2


call_form: (character-literal nil (progn))

error:
Error while parsing arguments to DEFMACRO CHARACTER-LITERAL:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (CHARACTER):
  exactly 1 expected, but got 2


call_form: (character-literal nil :key nil)

error:
Error while parsing arguments to DEFMACRO CHARACTER-LITERAL:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (CHARACTER):
  exactly 1 expected, but got 3


call_form: (character-literal 'lol-gen::some-name)

expanded:
(make-instance 'character-literal :character 'lol-gen::some-name :values
               '(character) :subnodes 'nil)


macro_name: DEFSTATEMENT

call_form: (defstatement)

error:
Error while parsing arguments to DEFMACRO DEFSTATEMENT:
  too few elements in
    ()
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 0


call_form: (defstatement nil)

error:
Error while parsing arguments to DEFMACRO DEFSTATEMENT:
  too few elements in
    (NIL)
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 1


call_form: (defstatement nil nil)

error:
Error while parsing arguments to DEFMACRO DEFSTATEMENT:
  too few elements in
    (NIL NIL)
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 2


call_form: (defstatement nil (progn))

error:
Error while parsing arguments to DEFMACRO DEFSTATEMENT:
  too few elements in
    (NIL (PROGN))
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 2


call_form: (defstatement nil :key nil)


call_form: (defstatement 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO DEFSTATEMENT:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (NAME VALUES SUBNODES):
  exactly 3 expected, but got 1


macro_name: PROXY

call_form: (proxy)

error:
Error while parsing arguments to DEFMACRO PROXY:
  too few elements in
    ()
  to satisfy lambda list
    (INFO PROXY-SUBNODE):
  exactly 2 expected, but got 0


call_form: (proxy nil)

error:
Error while parsing arguments to DEFMACRO PROXY:
  too few elements in
    (NIL)
  to satisfy lambda list
    (INFO PROXY-SUBNODE):
  exactly 2 expected, but got 1


call_form: (proxy nil nil)

expanded:
(make-instance 'proxy :info nil :proxy-subnode nil :values '(info) :subnodes
               '(proxy-subnode))


call_form: (proxy nil (progn))

expanded:
(make-instance 'proxy :info nil :proxy-subnode (progn) :values '(info)
               :subnodes '(proxy-subnode))


call_form: (proxy nil :key nil)

error:
Error while parsing arguments to DEFMACRO PROXY:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (INFO PROXY-SUBNODE):
  exactly 2 expected, but got 3


call_form: (proxy 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO PROXY:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (INFO PROXY-SUBNODE):
  exactly 2 expected, but got 1


macro_name: DEFINE-SWITCH

call_form: (define-switch)

expanded:
(defun nil (&key (debug nil))
  (cond
   ((eql *c-mera-reader* 'cl) (setf *c-mera-reader* 'cm)
    (setf (readtable-case *readtable*) :invert))
   ((eql *c-mera-reader* 'cm) (setf *c-mera-reader* 'cl)
    (setf *readtable* *readtable-backup*))
   (t (error "Unknown c-mera reader status: ~a" *c-mera-reader*))))


call_form: (define-switch nil)

error:
Error while parsing arguments to DEFINE-SWITCH DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


call_form: (define-switch nil nil)

error:
Error while parsing arguments to DEFINE-SWITCH DEFMACRO:
  unknown keyword: NIL; expected one of :NAME, :MACRO-CHARACTER


call_form: (define-switch nil (progn))


call_form: (define-switch nil :key nil)

error:
Error while parsing arguments to DEFINE-SWITCH DEFMACRO:
  odd number of elements in keyword/value list: (NIL :KEY NIL)


call_form: (define-switch 'lol-gen::some-name)

error:
Error while parsing arguments to DEFINE-SWITCH DEFMACRO:
  odd number of elements in keyword/value list: ('LOL-GEN::SOME-NAME)


macro_name: MAKE-NODE

call_form: (make-node)

error:
Error while parsing arguments to DEFMACRO MAKE-NODE:
  too few elements in
    ()
  to satisfy lambda list
    (ITEM):
  exactly 1 expected, but got 0


call_form: (make-node nil)

expanded: (make-node-function (quoty nil))


call_form: (make-node nil nil)

error:
Error while parsing arguments to DEFMACRO MAKE-NODE:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (ITEM):
  exactly 1 expected, but got 2


call_form: (make-node nil (progn))

error:
Error while parsing arguments to DEFMACRO MAKE-NODE:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (ITEM):
  exactly 1 expected, but got 2


call_form: (make-node nil :key nil)

error:
Error while parsing arguments to DEFMACRO MAKE-NODE:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (ITEM):
  exactly 1 expected, but got 3


call_form: (make-node 'lol-gen::some-name)


macro_name: STRING-LITERAL

call_form: (string-literal)

error:
Error while parsing arguments to DEFMACRO STRING-LITERAL:
  too few elements in
    ()
  to satisfy lambda list
    (STRING):
  exactly 1 expected, but got 0


call_form: (string-literal nil)

expanded: (make-instance 'string-literal :string nil :values '(string) :subnodes 'nil)


call_form: (string-literal nil nil)

error:
Error while parsing arguments to DEFMACRO STRING-LITERAL:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (STRING):
  exactly 1 expected, but got 2


call_form: (string-literal nil (progn))

error:
Error while parsing arguments to DEFMACRO STRING-LITERAL:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (STRING):
  exactly 1 expected, but got 2


call_form: (string-literal nil :key nil)

error:
Error while parsing arguments to DEFMACRO STRING-LITERAL:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (STRING):
  exactly 1 expected, but got 3


call_form: (string-literal 'lol-gen::some-name)

expanded:
(make-instance 'string-literal :string 'lol-gen::some-name :values '(string)
               :subnodes 'nil)


macro_name: DEFPROXY

call_form: (defproxy)

error:
Error while parsing arguments to DEFMACRO DEFPROXY:
  too few elements in
    ()
  to satisfy lambda list
    (NAME):
  exactly 1 expected, but got 0


call_form: (defproxy nil)

expanded:
(progn
 (|DEFCLASS#| nil (proxy) (values subnodes parent))
 (|MAKE-INSTANCE#| nil nil nil))


call_form: (defproxy nil nil)

error:
Error while parsing arguments to DEFMACRO DEFPROXY:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (NAME):
  exactly 1 expected, but got 2


call_form: (defproxy nil (progn))

error:
Error while parsing arguments to DEFMACRO DEFPROXY:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (NAME):
  exactly 1 expected, but got 2


call_form: (defproxy nil :key nil)

error:
Error while parsing arguments to DEFMACRO DEFPROXY:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (NAME):
  exactly 1 expected, but got 3


call_form: (defproxy 'lol-gen::some-name)

expanded:
(progn
 (|DEFCLASS#| 'lol-gen::some-name (proxy) (values subnodes parent))
 (|MAKE-INSTANCE#| 'lol-gen::some-name nil nil))


macro_name: DEFPROXYMETHOD

call_form: (defproxymethod)

error:
Error while parsing arguments to DEFMACRO DEFPROXYMETHOD:
  too few elements in
    ()
  to satisfy lambda list
    (QUALIFIER CLASS PROXY-NODE &BODY BODY):
  at least 3 expected, but got 0


call_form: (defproxymethod nil)

error:
Error while parsing arguments to DEFMACRO DEFPROXYMETHOD:
  too few elements in
    (NIL)
  to satisfy lambda list
    (QUALIFIER CLASS PROXY-NODE &BODY BODY):
  at least 3 expected, but got 1


call_form:
(defproxymethod nil
    nil)

error:
Error while parsing arguments to DEFMACRO DEFPROXYMETHOD:
  too few elements in
    (NIL NIL)
  to satisfy lambda list
    (QUALIFIER CLASS PROXY-NODE &BODY BODY):
  at least 3 expected, but got 2


call_form:
(defproxymethod nil
    (progn))

error:
Error while parsing arguments to DEFMACRO DEFPROXYMETHOD:
  too few elements in
    (NIL (PROGN))
  to satisfy lambda list
    (QUALIFIER CLASS PROXY-NODE &BODY BODY):
  at least 3 expected, but got 2


call_form:
(defproxymethod nil
    :key
    nil)

expanded:
(defmethod traverser nil (:key (item nil) level)
  (declare (ignorable level))
  (with-slots (values subnodes parent)
      item))


call_form: (defproxymethod 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO DEFPROXYMETHOD:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (QUALIFIER CLASS PROXY-NODE &BODY BODY):
  at least 3 expected, but got 1


macro_name: EMPTY

call_form: (empty)

expanded: (make-instance 'empty :values 'nil :subnodes 'nil)


call_form: (empty nil)

error:
Error while parsing arguments to DEFMACRO EMPTY:
  too many elements in
    (NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


call_form: (empty nil nil)

error:
Error while parsing arguments to DEFMACRO EMPTY:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


call_form: (empty nil (progn))

error:
Error while parsing arguments to DEFMACRO EMPTY:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


call_form: (empty nil :key nil)

error:
Error while parsing arguments to DEFMACRO EMPTY:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 3


call_form: (empty 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO EMPTY:
  too many elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


macro_name: WITH-PP

call_form: (with-pp)

expanded:
(symbol-macrolet ((stream (get-stream-generic pp))
                  (indent (get-indent-generic pp))
                  (--indent (dec-indent-generic pp))
                  (++indent (inc-indent-generic pp)))
  (macrolet ((push-sign (x) `(push-sign-generic pp ,x))
             (pop-sign nil `(pop-sign-generic pp))
             (top-sign nil `(top-sign-generic pp))
             (find-sign (x) `(find-sign-generic pp ,x))
             (push-info (x) `(push-info-generic pp ,x))
             (pop-info nil `(pop-info-generic pp))
             (top-info nil `(top-info-generic pp))
             (find-info (x) `(find-info-generic pp ,x))
             (info-size nil `(info-size-generic pp))
             (node-slot (x) `(slot-value item ',x)))))


call_form:
(with-pp
  nil)

expanded:
(symbol-macrolet ((stream (get-stream-generic pp))
                  (indent (get-indent-generic pp))
                  (--indent (dec-indent-generic pp))
                  (++indent (inc-indent-generic pp)))
  (macrolet ((push-sign (x)
               `(push-sign-generic pp ,x))
             (pop-sign ()
               `(pop-sign-generic pp))
             (top-sign ()
               `(top-sign-generic pp))
             (find-sign (x)
               `(find-sign-generic pp ,x))
             (push-info (x)
               `(push-info-generic pp ,x))
             (pop-info ()
               `(pop-info-generic pp))
             (top-info ()
               `(top-info-generic pp))
             (find-info (x)
               `(find-info-generic pp ,x))
             (info-size ()
               `(info-size-generic pp))
             (node-slot (x)
               `(slot-value item ',x)))
    nil))


call_form:
(with-pp
  nil
  nil)

expanded:
(symbol-macrolet ((stream (get-stream-generic pp))
                  (indent (get-indent-generic pp))
                  (--indent (dec-indent-generic pp))
                  (++indent (inc-indent-generic pp)))
  (macrolet ((push-sign (x)
               `(push-sign-generic pp ,x))
             (pop-sign ()
               `(pop-sign-generic pp))
             (top-sign ()
               `(top-sign-generic pp))
             (find-sign (x)
               `(find-sign-generic pp ,x))
             (push-info (x)
               `(push-info-generic pp ,x))
             (pop-info ()
               `(pop-info-generic pp))
             (top-info ()
               `(top-info-generic pp))
             (find-info (x)
               `(find-info-generic pp ,x))
             (info-size ()
               `(info-size-generic pp))
             (node-slot (x)
               `(slot-value item ',x)))
    nil
    nil))


call_form:
(with-pp
  nil
  (progn))

expanded:
(symbol-macrolet ((stream (get-stream-generic pp))
                  (indent (get-indent-generic pp))
                  (--indent (dec-indent-generic pp))
                  (++indent (inc-indent-generic pp)))
  (macrolet ((push-sign (x)
               `(push-sign-generic pp ,x))
             (pop-sign ()
               `(pop-sign-generic pp))
             (top-sign ()
               `(top-sign-generic pp))
             (find-sign (x)
               `(find-sign-generic pp ,x))
             (push-info (x)
               `(push-info-generic pp ,x))
             (pop-info ()
               `(pop-info-generic pp))
             (top-info ()
               `(top-info-generic pp))
             (find-info (x)
               `(find-info-generic pp ,x))
             (info-size ()
               `(info-size-generic pp))
             (node-slot (x)
               `(slot-value item ',x)))
    nil
    (progn)))


call_form:
(with-pp
  nil
  :key
  nil)

expanded:
(symbol-macrolet ((stream (get-stream-generic pp))
                  (indent (get-indent-generic pp))
                  (--indent (dec-indent-generic pp))
                  (++indent (inc-indent-generic pp)))
  (macrolet ((push-sign (x)
               `(push-sign-generic pp ,x))
             (pop-sign ()
               `(pop-sign-generic pp))
             (top-sign ()
               `(top-sign-generic pp))
             (find-sign (x)
               `(find-sign-generic pp ,x))
             (push-info (x)
               `(push-info-generic pp ,x))
             (pop-info ()
               `(pop-info-generic pp))
             (top-info ()
               `(top-info-generic pp))
             (find-info (x)
               `(find-info-generic pp ,x))
             (info-size ()
               `(info-size-generic pp))
             (node-slot (x)
               `(slot-value item ',x)))
    nil
    :key
    nil))


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

expanded:
(symbol-macrolet ((stream (get-stream-generic pp))
                  (indent (get-indent-generic pp))
                  (--indent (dec-indent-generic pp))
                  (++indent (inc-indent-generic pp)))
  (macrolet ((push-sign (x)
               `(push-sign-generic pp ,x))
             (pop-sign ()
               `(pop-sign-generic pp))
             (top-sign ()
               `(top-sign-generic pp))
             (find-sign (x)
               `(find-sign-generic pp ,x))
             (push-info (x)
               `(push-info-generic pp ,x))
             (pop-info ()
               `(pop-info-generic pp))
             (top-info ()
               `(top-info-generic pp))
             (find-info (x)
               `(find-info-generic pp ,x))
             (info-size ()
               `(info-size-generic pp))
             (node-slot (x)
               `(slot-value item ',x)))
    'lol-gen::some-name))


macro_name: NUMBER-LITERAL

call_form: (number-literal)

error:
Error while parsing arguments to DEFMACRO NUMBER-LITERAL:
  too few elements in
    ()
  to satisfy lambda list
    (NUMBER):
  exactly 1 expected, but got 0


call_form: (number-literal nil)

expanded: (make-instance 'number-literal :number nil :values '(number) :subnodes 'nil)


call_form: (number-literal nil nil)

error:
Error while parsing arguments to DEFMACRO NUMBER-LITERAL:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (NUMBER):
  exactly 1 expected, but got 2


call_form: (number-literal nil (progn))

error:
Error while parsing arguments to DEFMACRO NUMBER-LITERAL:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (NUMBER):
  exactly 1 expected, but got 2


call_form: (number-literal nil :key nil)

error:
Error while parsing arguments to DEFMACRO NUMBER-LITERAL:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (NUMBER):
  exactly 1 expected, but got 3


call_form: (number-literal 'lol-gen::some-name)

expanded:
(make-instance 'number-literal :number 'lol-gen::some-name :values '(number)
               :subnodes 'nil)


macro_name: MAKE-NODELIST

call_form: (make-nodelist)

error:
Error while parsing arguments to DEFMACRO MAKE-NODELIST:
  too few elements in
    ()
  to satisfy lambda list
    (ITEMS &KEY (PREPEND) (QUOTY)):
  at least 1 expected, but got 0


call_form: (make-nodelist nil)

expanded: (nodelist (list))


call_form: (make-nodelist nil nil)

error:
Error while parsing arguments to MAKE-NODELIST DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


call_form: (make-nodelist nil (progn))

error:
Error while parsing arguments to MAKE-NODELIST DEFMACRO:
  odd number of elements in keyword/value list: ((PROGN))


call_form: (make-nodelist nil :key nil)

error:
Error while parsing arguments to MAKE-NODELIST DEFMACRO:
  unknown keyword: :KEY; expected one of :PREPEND, :QUOTY


call_form: (make-nodelist 'lol-gen::some-name)

expanded:
(nodelist
 (list (make-node-function (quoty quote))
       (make-node-function (quoty lol-gen::some-name))))


macro_name: SAVE-GENERATOR

call_form: (save-generator)

expanded:
(defun nil (name)
  (labels ((dump-start ()
             (in-package nil)
             (setf (readtable-case *readtable*) :invert)
             (nil sb-ext:*posix-argv*)))
    (net.didierverna.clon:dump name dump-start)))


call_form: (save-generator nil)

error:
Error while parsing arguments to SAVE-GENERATOR DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


call_form: (save-generator nil nil)

error:
Error while parsing arguments to SAVE-GENERATOR DEFMACRO:
  unknown keyword: NIL; expected one of :NAME, :START-FUNCTION, :IN-PACKAGE


call_form: (save-generator nil (progn))


call_form: (save-generator nil :key nil)

error:
Error while parsing arguments to SAVE-GENERATOR DEFMACRO:
  odd number of elements in keyword/value list: (NIL :KEY NIL)


call_form: (save-generator 'lol-gen::some-name)

error:
Error while parsing arguments to SAVE-GENERATOR DEFMACRO:
  odd number of elements in keyword/value list: ('LOL-GEN::SOME-NAME)


macro_name: ENSURE-LIST

call_form: (ensure-list)

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


call_form: (ensure-list nil)

expanded:
(let ((nil
       (if (listp nil)
           nil
           '(nil)))))


call_form:
(ensure-list nil
  nil)

expanded:
(let ((nil
       (if (listp nil)
           nil
           '(nil))))
  nil)


call_form:
(ensure-list nil
  (progn))

expanded:
(let ((nil
       (if (listp nil)
           nil
           '(nil))))
  (progn))


call_form:
(ensure-list nil
  :key
  nil)

expanded:
(let ((nil
       (if (listp nil)
           nil
           '(nil))))
  :key
  nil)


call_form: (ensure-list 'lol-gen::some-name)

expanded:
(let (('lol-gen::some-name
       (if (listp 'lol-gen::some-name)
           'lol-gen::some-name
           '('lol-gen::some-name)))))


macro_name: DEFSYNTAX

call_form: (defsyntax)

error:
Error while parsing arguments to DEFMACRO DEFSYNTAX:
  too few elements in
    ()
  to satisfy lambda list
    (TAGS PACKAGES LAMBDA-LIST &BODY BODY):
  at least 3 expected, but got 0


call_form: (defsyntax nil)

error:
Error while parsing arguments to DEFMACRO DEFSYNTAX:
  too few elements in
    (NIL)
  to satisfy lambda list
    (TAGS PACKAGES LAMBDA-LIST &BODY BODY):
  at least 3 expected, but got 1


call_form:
(defsyntax nil
    nil)

error:
Error while parsing arguments to DEFMACRO DEFSYNTAX:
  too few elements in
    (NIL NIL)
  to satisfy lambda list
    (TAGS PACKAGES LAMBDA-LIST &BODY BODY):
  at least 3 expected, but got 2


call_form:
(defsyntax nil
    (progn))

error:
Error while parsing arguments to DEFMACRO DEFSYNTAX:
  too few elements in
    (NIL (PROGN))
  to satisfy lambda list
    (TAGS PACKAGES LAMBDA-LIST &BODY BODY):
  at least 3 expected, but got 2


call_form:
(defsyntax nil
    :key
    nil)

expanded: (progn)


call_form: (defsyntax 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO DEFSYNTAX:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (TAGS PACKAGES LAMBDA-LIST &BODY BODY):
  at least 3 expected, but got 1


macro_name: NODELIST

call_form: (nodelist)

error:
Error while parsing arguments to DEFMACRO NODELIST:
  too few elements in
    ()
  to satisfy lambda list
    (NODES):
  exactly 1 expected, but got 0


call_form: (nodelist nil)

expanded: (make-instance 'nodelist :nodes nil :values 'nil :subnodes '(nodes))


call_form: (nodelist nil nil)

error:
Error while parsing arguments to DEFMACRO NODELIST:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (NODES):
  exactly 1 expected, but got 2


call_form: (nodelist nil (progn))

error:
Error while parsing arguments to DEFMACRO NODELIST:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (NODES):
  exactly 1 expected, but got 2


call_form: (nodelist nil :key nil)

error:
Error while parsing arguments to DEFMACRO NODELIST:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (NODES):
  exactly 1 expected, but got 3


call_form: (nodelist 'lol-gen::some-name)

expanded:
(make-instance 'nodelist :nodes 'lol-gen::some-name :values 'nil :subnodes
               '(nodes))