[changed CASE to SWITCH and made CASE more like Lisp.
henrik.hjelte@poboxes.com**20051227190529] {
hunk ./src/js.lisp 1117
-(defjsclass js-case (statement)
+(defjsclass js-switch (statement)
hunk ./src/js.lisp 1121
-(define-js-compiler-macro case (value &rest clauses)
+(define-js-compiler-macro switch (value &rest clauses)
hunk ./src/js.lisp 1131
-    (make-instance 'js-case :value check
+    (make-instance 'js-switch :value check
hunk ./src/js.lisp 1134
-(defmethod js-to-statement-strings ((case js-case) start-pos)
+(defmethod js-to-statement-strings ((case js-switch) start-pos)
hunk ./src/js.lisp 1154
+
+(defjsmacro case (value &rest clauses)
+  (labels ((make-clause (val body more)
+             (cond ((listp val)
+                    (append (mapcar #'list (butlast val))
+                            (make-clause (first (last val)) body more)))
+                   ((member val '(t otherwise))
+                    (make-clause 'default body more))
+                   (more `((,val ,@body break)))
+                   (t `((,val ,@body))))))
+    `(switch ,value ,@(mapcon #'(lambda (x)
+                                  (make-clause (car (first x))
+                                               (cdr (first x))
+                                               (rest x)))
+                              clauses))))
hunk ./t/reference-tests.lisp 403
-  (1 (alert "one"))
+  ((1 "one") (alert "one"))
merger 0.0 (
hunk ./t/reference-tests.lisp 405
-  (default (alert "default clause"))) 
+  (default (alert "default clause")))
hunk ./t/reference-tests.lisp 405
-  (default (alert "default clause"))) 
+  (t (alert "default clause"))) 
)
hunk ./t/reference-tests.lisp 407
-  case 1:   alert('one');
-  case 2:   alert('two');
+  case 1:   ;
+  case 'one':
+            alert('one');
+            break;
+  case 2:
+            alert('two');
+            break;
hunk ./t/reference-tests.lisp 415
+}")
+
+(test-ps-js the-case-statement-2 
+  (switch (aref blorg i)
+  (1 (alert "If I get here"))
+  (2 (alert "I also get here"))
+  (default (alert "I always get here"))) 
+  "switch (blorg[i]) {
+  case 1:   alert('If I get here');
+  case 2:   alert('I also get here');
+  default:   alert('I always get here');
hunk ./docs/reference.lisp 761
+;;;t \index{SWITCH}
hunk ./docs/reference.lisp 766
-; clause     ::= (value body)
+; clause     ::= (value body) | ((value*) body) | t-clause
hunk ./docs/reference.lisp 769
+; t-clause   ::= {t | otherwise | default} body
hunk ./docs/reference.lisp 774
-;;; ParenScript. The default case is not named `T' in ParenScript, but
-;;; `DEFAULT' instead.
+;;; ParenScript. 
hunk ./docs/reference.lisp 777
-  (1 (alert "one"))
+  ((1 "one") (alert "one"))
hunk ./docs/reference.lisp 779
-  (default (alert "default clause")))
+  (t (alert "default clause")))
hunk ./docs/reference.lisp 781
-         case 1:   alert('one');
-         case 2:   alert('two');
+         case 1:   ;
+         case 'one':
+                   alert('one');
+                   break;
+         case 2:
+                   alert('two');
+                   break;
hunk ./docs/reference.lisp 790
+
+; (SWITCH case-value clause*)
+; clause     ::= (value body) | (default body)
+
+;;; The `SWITCH' form is the equivalent to a javascript switch statement.
+;;; No break statements are inserted, and the default case is named `DEFAULT'.
+;;; The `CASE' form should be prefered in most cases.
+
+(switch (aref blorg i)
+  (1 (alert "If I get here"))
+  (2 (alert "I also get here"))
+  (default (alert "I always get here")))
+    => switch (blorg[i]) {
+         case 1:   alert('If I get here');
+         case 2:   alert('I also get here');
+         default:   alert('I always get here');
+       }
+
hunk ./t/test.lisp 77
+(test-ps-js old-case-is-now-switch
+  ;; Switch was "case" before, but that was very non-lispish.
+  ;; For example, this code makes three messages and not one
+  ;; which may have been expected. This is because a switch
+  ;; statment must have a break statement for it to return
+  ;; after the alert. Otherwise it continues on the next
+  ;; clause.
+  (switch (aref blorg i)
+     (1 (alert "one"))
+     (2 (alert "two"))
+     (default (alert "default clause")))
+     "switch (blorg[i]) {
+         case 1:   alert('one');
+         case 2:   alert('two');
+         default:   alert('default clause');
+         }")
+
+(test-ps-js lisp-like-case
+   (case (aref blorg i)
+     (1 (alert "one"))
+     (2 (alert "two"))
+     (default (alert "default clause")))    
+     "switch (blorg[i]) {
+         case 1:
+                   alert('one');
+                   break;
+         case 2:
+                   alert('two');
+                   break;
+         default:   alert('default clause');
+         }")
+
+
+(test-ps-js even-lispier-case
+  (case (aref blorg i)
+      ((1 2) (alert "Below three"))
+      (3 (alert "Three"))
+      (t (alert "Something else")))
+   "switch (blorg[i]) {
+         case 1:   ;
+         case 2:
+                   alert('Below three');
+                   break;
+         case 3:
+                   alert('Three');
+                   break;
+         default:   alert('Something else');
+    }")
+
+(test-ps-js otherwise-case
+   (case (aref blorg i)
+     (1 (alert "one"))
+     (otherwise (alert "default clause")))    
+     "switch (blorg[i]) {
+         case 1:
+                   alert('one');
+                   break;
+         default:   alert('default clause');
+         }")
+
}