Declared unused "expecting" variables in ps-special-form definitions ignorable.

Thanks to: Kevin Layer <layer@known.net>

diff --git a/src/js-macrology.lisp b/src/js-macrology.lisp
index cfa01e2..39c84bc 100644 (file)
--- a/src/js-macrology.lisp
+++ b/src/js-macrology.lisp
@@ -4,7 +4,9 @@
 
 ;;; literals
 (defmacro defpsliteral (name string)
-  `(define-ps-special-form ,name (expecting) (list 'js-literal ,string)))
+  `(define-ps-special-form ,name (expecting)
+    (declare (ignore expecting))
+    (list 'js-literal ,string)))
 
 (defpsliteral this      "this")
 (defpsliteral t         "true")
@@ -15,45 +17,54 @@
 (defpsliteral undefined "undefined")
 
 (defmacro defpskeyword (name string)
-  `(define-ps-special-form ,name (expecting) (list 'js-keyword ,string)))
+  `(define-ps-special-form ,name (expecting)
+    (declare (ignore expecting))
+    (list 'js-keyword ,string)))
 
 (defpskeyword break    "break")
 (defpskeyword continue "continue")
 
 (define-ps-special-form array (expecting &rest values)
+  (declare (ignore expecting))
   (cons 'array-literal (mapcar (lambda (form) (compile-parenscript-form form :expecting :expression))
                                values)))
 
 (define-ps-special-form aref (expecting array &rest coords)
+  (declare (ignore expecting))
   (list 'js-aref (compile-parenscript-form array :expecting :expression)
         (mapcar (lambda (form)
                   (compile-parenscript-form form :expecting :expression))
                 coords)))
 
 (define-ps-special-form {} (expecting &rest arrows)
+  (declare (ignore expecting))
   (cons 'object-literal (loop for (key value) on arrows by #'cddr
                               collect (cons key (compile-parenscript-form value :expecting :expression)))))
 
 ;;; operators
 (define-ps-special-form incf (expecting x &optional (delta 1))
+  (declare (ignore expecting))
   (if (equal delta 1)
       (list 'unary-operator "++" (compile-parenscript-form x :expecting :expression) :prefix t)
       (list 'operator '+= (list (compile-parenscript-form x :expecting :expression)
                                 (compile-parenscript-form delta :expecting :expression)))))
 
 (define-ps-special-form decf (expecting x &optional (delta 1))
+  (declare (ignore expecting))
   (if (equal delta 1)
       (list 'unary-operator "--" (compile-parenscript-form x :expecting :expression) :prefix t)
       (list 'operator '-= (list (compile-parenscript-form x :expecting :expression)
                                 (compile-parenscript-form delta :expecting :expression)))))
 
 (define-ps-special-form - (expecting first &rest rest)
+  (declare (ignore expecting))
   (if (null rest)
       (list 'unary-operator "-" (compile-parenscript-form first :expecting :expression) :prefix t)
       (list 'operator '- (mapcar (lambda (val) (compile-parenscript-form val :expecting :expression))
                                  (cons first rest)))))
 
 (define-ps-special-form not (expecting x)
+  (declare (ignore expecting))
   (let ((form (compile-parenscript-form x :expecting :expression))
         (not-op nil))
     (if (and (eql (first form) 'operator)
@@ -72,6 +83,7 @@
         (list 'unary-operator "!" form :prefix t))))
 
 (define-ps-special-form ~ (expecting x)
+  (declare (ignore expecting))
   (list 'unary-operator "~" (compile-parenscript-form x :expecting :expressin) :prefix t))
 
 (defun flatten-blocks (body)
@@ -97,18 +109,21 @@
 
 ;;; function definition
 (define-ps-special-form %js-lambda (expecting args &rest body)
+  (declare (ignore expecting))
   (list 'js-lambda (mapcar (lambda (arg)
                              (compile-parenscript-form arg :expecting :symbol))
                            args)
         (compile-parenscript-form `(progn ,@body))))
 
 (define-ps-special-form %js-defun (expecting name args &rest body)
+  (declare (ignore expecting))
   (list 'js-defun name
         (mapcar (lambda (val) (compile-parenscript-form val :expecting :symbol)) args)
        (compile-parenscript-form `(progn ,@body))))
 
 ;;; object creation
 (define-ps-special-form create (expecting &rest args)
+  (declare (ignore expecting))
   (list 'js-object (loop for (name val) on args by #'cddr collecting
                          (let ((name-expr (compile-parenscript-form name :expecting :expression)))
                            (assert (or (stringp name-expr)
@@ -121,6 +136,7 @@
                            (list name-expr (compile-parenscript-form val :expecting :expression))))))
 
 (define-ps-special-form %js-slot-value (expecting obj slot)
+  (declare (ignore expecting))
   (if (ps::ps-macroexpand slot)
       (list 'js-slot-value (compile-parenscript-form obj :expecting :expression) (compile-parenscript-form slot))
       (compile-parenscript-form obj :expecting :expression)))
@@ -157,6 +173,7 @@
                        (compile-parenscript-form else :expecting :expression)))))
 
 (define-ps-special-form switch (expecting test-expr &rest clauses)
+  (declare (ignore expecting))
   (let ((clauses (mapcar (lambda (clause)
                             (let ((val (car clause))
                                   (body (cdr clause)))
@@ -207,9 +224,11 @@
       (list 'js-assign lhs rhs)))
 
 (define-ps-special-form setf1% (expecting lhs rhs)
+  (declare (ignore expecting))
   (smart-setf (compile-parenscript-form lhs :expecting :expression) (compile-parenscript-form rhs :expecting :expression)))
 
 (define-ps-special-form defvar (expecting name &rest value)
+  (declare (ignore expecting))
   (append (list 'js-defvar name)
           (when value
             (assert (= (length value) 1) () "Wrong number of arguments to defvar: ~s" `(defvar ,name ,@value))
@@ -228,6 +247,7 @@
        collect (compile-parenscript-form (third decl) :expecting :expression)))
 
 (define-ps-special-form do (expecting decls termination-test &rest body)
+  (declare (ignore expecting))
   (let ((vars (make-for-vars decls))
        (steps (make-for-steps decls))
        (test (compile-parenscript-form `(not ,(first termination-test)) :expecting :expression))
@@ -235,20 +255,24 @@
     (list 'js-for vars steps test body)))
 
 (define-ps-special-form doeach (expecting decl &rest body)
+  (declare (ignore expecting))
   (list 'js-for-each
         (first decl)
         (compile-parenscript-form (second decl) :expecting :expression)
        (compile-parenscript-form `(progn ,@body))))
 
 (define-ps-special-form while (expecting test &rest body)
+  (declare (ignore expecting))
   (list 'js-while (compile-parenscript-form test :expecting :expression)
                   (compile-parenscript-form `(progn ,@body))))
 
 (define-ps-special-form with (expecting expression &rest body)
+  (declare (ignore expecting))
   (list 'js-with (compile-parenscript-form expression :expecting :expression)
                 (compile-parenscript-form `(progn ,@body))))
 
 (define-ps-special-form try (expecting form &rest clauses)
+  (declare (ignore expecting))
   (let ((catch (cdr (assoc :catch clauses)))
         (finally (cdr (assoc :finally clauses))))
     (assert (not (cdar catch)) nil "Sorry, currently only simple catch forms are supported.")
@@ -260,23 +284,28 @@
           :finally (when finally (compile-parenscript-form `(progn ,@finally))))))
 
 (define-ps-special-form regex (expecting regex)
+  (declare (ignore expecting))
   (list 'js-regex (string regex)))
 
 ;;; TODO instanceof
 (define-ps-special-form instanceof (expecting value type)
+  (declare (ignore expecting))
   (list 'js-instanceof (compile-parenscript-form value :expecting :expression)
         (compile-parenscript-form type :expecting :expression)))
 
 ;;; single operations
 (mapcar (lambda (op) (eval `(define-ps-special-form ,op (expecting value)
+                             (declare (ignore expecting))
                              (list 'js-named-operator ',op (compile-parenscript-form value)))))
         '(throw delete void typeof new))
 
 (define-ps-special-form return (expecting &optional value)
+  (declare (ignore expecting))
   (list 'js-return (compile-parenscript-form value :expecting :expression)))
 
 ;;; conditional compilation
 (define-ps-special-form cc-if (expecting test &rest body)
+  (declare (ignore expecting))
   (list 'cc-if test (mapcar #'compile-parenscript-form body)))
 
 ;;; standard macros

diff --git a/src/js-translation.lisp b/src/js-translation.lisp
index 2058dfe..42b8fc9 100644 (file)
--- a/src/js-translation.lisp
+++ b/src/js-translation.lisp
@@ -1,6 +1,7 @@
 (in-package :parenscript)
 
 (defvar *ps-output-stream*)
+(defparameter *indent-level* 0)
 
 (defmethod parenscript-print (ps-form &optional *ps-output-stream*)
   (setf *indent-level* 0)
@@ -41,7 +42,6 @@ indent position."
 
 ;;; indenter
 
-(defparameter *indent-level* 0)
 (defparameter *indent-num-space* 4)
 
 (defun newline-and-indent ()
@@ -351,7 +351,7 @@ vice-versa.")
   (write-string "; ")
   (ps-print test)
   (write-string "; ")
-  (loop for ((var-name . var-init) . rest) on vars
+  (loop for ((var-name . nil) . rest) on vars
         for step in steps
         with after = ", "
         unless rest do (setf after "")

diff --git a/src/ps-macrology.lisp b/src/ps-macrology.lisp
index 8a7246c..5062de9 100644 (file)
--- a/src/ps-macrology.lisp
+++ b/src/ps-macrology.lisp
@@ -71,6 +71,7 @@ gensym-prefix-string)."
                               clauses))))
 
 (define-ps-special-form let (expecting bindings &rest body)
+  (declare (ignore expecting))
   (let ((defvars (mapcar (lambda (binding) (if (atom binding)
                                                `(defvar ,binding)
                                                `(defvar ,@binding)))
@@ -103,6 +104,7 @@ gensym-prefix-string)."
     ,@body))
 
 (define-ps-special-form macrolet (expecting macros &body body)
+  (declare (ignore expecting))
   (with-temp-macro-environment (macro-env-dict)
     (dolist (macro macros)
       (destructuring-bind (name arglist &body body)
@@ -112,6 +114,7 @@ gensym-prefix-string)."
     (compile-parenscript-form `(progn ,@body))))
 
 (define-ps-special-form symbol-macrolet (expecting symbol-macros &body body)
+  (declare (ignore expecting))
   (with-temp-macro-environment (macro-env-dict)
     (dolist (macro symbol-macros)
       (destructuring-bind (name expansion)
@@ -121,10 +124,12 @@ gensym-prefix-string)."
     (compile-parenscript-form `(progn ,@body))))
 
 (define-ps-special-form defmacro (expecting name args &body body)
+  (declare (ignore expecting))
   (define-script-macro% name args body :symbol-macro-p nil)
   nil)
 
 (define-ps-special-form define-symbol-macro (expecting name &body body)
+  (declare (ignore expecting))
   (define-script-macro% name () body :symbol-macro-p t)
   nil)