`(eval-when-compile
,@(mapcar (lambda (decl) `(!proclaim ',decl)) decls)))
- (declaim (constant nil t) (special t nil))
- (setq nil 'nil)
+ (defmacro defconstant (name value &optional docstring)
+ `(progn
+ (declaim (special ,name))
+ (declaim (constant ,name))
+ (setq ,name ,value)
+ ,@(when (stringp docstring) `((oset ',name "vardoc" ,docstring)))
+ ',name))
+
+ (defconstant t 't)
+ (defconstant nil 'nil)
(js-vset "nil" nil)
- (setq t 't)
(defmacro lambda (args &body body)
`(function (lambda ,args ,@body)))
" : " (ls-compile false *multiple-value-p*)
")"))
-(defvar *lambda-list-keywords* '(&optional &rest))
+(defvar *lambda-list-keywords* '(&optional &rest &key))
(defun list-until-keyword (list)
(if (or (null list) (member (car list) *lambda-list-keywords*))
nil
(cons (car list) (list-until-keyword (cdr list)))))
+(defun lambda-list-section (keyword lambda-list)
+ (list-until-keyword (cdr (member keyword lambda-list))))
+
(defun lambda-list-required-arguments (lambda-list)
(list-until-keyword lambda-list))
(defun lambda-list-optional-arguments-with-default (lambda-list)
- (mapcar #'ensure-list (list-until-keyword (cdr (member '&optional lambda-list)))))
+ (mapcar #'ensure-list (lambda-list-section '&optional lambda-list)))
(defun lambda-list-optional-arguments (lambda-list)
(mapcar #'car (lambda-list-optional-arguments-with-default lambda-list)))
(defun lambda-list-rest-argument (lambda-list)
- (let ((rest (list-until-keyword (cdr (member '&rest lambda-list)))))
+ (let ((rest (lambda-list-section '&rest lambda-list)))
(when (cdr rest)
(error "Bad lambda-list"))
(car rest)))
+(defun lambda-list-keyword-arguments-canonical (lambda-list)
+ (flet ((canonalize (keyarg)
+ ;; Build a canonical keyword argument descriptor, filling
+ ;; the optional fields. The result is a list of the form
+ ;; ((keyword-name var) init-form).
+ (let* ((arg (ensure-list keyarg))
+ (init-form (cadr arg))
+ var
+ keyword-name)
+ (if (listp (car arg))
+ (setq var (cadr (car arg))
+ keyword-name (car (car arg)))
+ (setq var (car arg)
+ keyword-name (intern (symbol-name (car arg)) "KEYWORD")))
+ `((,keyword-name ,var) ,init-form))))
+ (mapcar #'canonalize (lambda-list-section '&key lambda-list))))
+
+(defun lambda-list-keyword-arguments (lambda-list)
+ (mapcar (lambda (keyarg) (second (first keyarg)))
+ (lambda-list-keyword-arguments-canonical lambda-list)))
+
(defun lambda-docstring-wrapper (docstring &rest strs)
(if docstring
(js!selfcall
(concat "checkArgsAtMost(arguments, " (integer-to-string max) ");" *newline*)
"")))))
+(defun compile-lambda-optional (lambda-list)
+ (let* ((optional-arguments (lambda-list-optional-arguments lambda-list))
+ (n-required-arguments (length (lambda-list-required-arguments lambda-list)))
+ (n-optional-arguments (length optional-arguments)))
+ (if optional-arguments
+ (concat "switch(arguments.length-1){" *newline*
+ (let ((optional-and-defaults
+ (lambda-list-optional-arguments-with-default lambda-list))
+ (cases nil)
+ (idx 0))
+ (progn
+ (while (< idx n-optional-arguments)
+ (let ((arg (nth idx optional-and-defaults)))
+ (push (concat "case "
+ (integer-to-string (+ idx n-required-arguments)) ":" *newline*
+ (translate-variable (car arg))
+ "="
+ (ls-compile (cadr arg))
+ ";" *newline*)
+ cases)
+ (incf idx)))
+ (push (concat "default: break;" *newline*) cases)
+ (join (reverse cases))))
+ "}" *newline*)
+ "")))
+
+(defun compile-lambda-rest (lambda-list)
+ (let ((n-required-arguments (length (lambda-list-required-arguments lambda-list)))
+ (n-optional-arguments (length (lambda-list-optional-arguments lambda-list)))
+ (rest-argument (lambda-list-rest-argument lambda-list)))
+ (if rest-argument
+ (let ((js!rest (translate-variable rest-argument)))
+ (concat "var " js!rest "= " (ls-compile nil) ";" *newline*
+ "for (var i = arguments.length-1; i>="
+ (integer-to-string (+ 1 n-required-arguments n-optional-arguments))
+ "; i--)" *newline*
+ (indent js!rest " = "
+ "{car: arguments[i], cdr: ") js!rest "};"
+ *newline*))
+ "")))
+
+(defun compile-lambda-parse-keywords (lambda-list)
+ (let ((n-required-arguments
+ (length (lambda-list-required-arguments lambda-list)))
+ (n-optional-arguments
+ (length (lambda-list-optional-arguments lambda-list)))
+ (keyword-arguments
+ (lambda-list-keyword-arguments-canonical lambda-list)))
+ (concat
+ "var i;" *newline*
+ ;; Declare variables
+ (mapconcat (lambda (arg)
+ (let ((var (second (car arg))))
+ (concat "var " (translate-variable var) "; " *newline*)))
+ keyword-arguments)
+ ;; Parse keywords
+ (flet ((parse-keyword (keyarg)
+ ;; ((keyword-name var) init-form)
+ (concat "for (i="
+ (integer-to-string (+ 1 n-required-arguments n-optional-arguments))
+ "; i<arguments.length; i+=2){" *newline*
+ (indent
+ "if (arguments[i] === " (ls-compile (caar keyarg)) "){" *newline*
+ (indent (translate-variable (cadr (car keyarg)))
+ " = arguments[i+1];"
+ *newline*
+ "break;" *newline*)
+ "}" *newline*)
+ "}" *newline*
+ ;; Default value
+ "if (i == arguments.length){" *newline*
+ (indent
+ (translate-variable (cadr (car keyarg)))
+ " = "
+ (ls-compile (cadr keyarg))
+ ";" *newline*)
+ "}" *newline*)))
+ (mapconcat #'parse-keyword keyword-arguments))
+ ;; Check for unknown keywords
+ (if (null keyword-arguments)
+ ""
+ (concat "for (i="
+ (integer-to-string (+ 1 n-required-arguments n-optional-arguments))
+ "; i<arguments.length; i+=2){" *newline*
+ (indent "if ("
+ (join (mapcar (lambda (x)
+ (concat "arguments[i] !== " (ls-compile (caar x))))
+ keyword-arguments)
+ " && ")
+ ")" *newline*
+ (indent
+ "throw 'Unknown keyword argument ' + arguments[i].name;" *newline*))
+ "}" *newline*)))))
+
(defun compile-lambda (lambda-list body)
(let ((required-arguments (lambda-list-required-arguments lambda-list))
(optional-arguments (lambda-list-optional-arguments lambda-list))
- (rest-argument (lambda-list-rest-argument lambda-list))
+ (keyword-arguments (lambda-list-keyword-arguments lambda-list))
+ (rest-argument (lambda-list-rest-argument lambda-list))
documentation)
;; Get the documentation string for the lambda function
(when (and (stringp (car body))
(*environment* (extend-local-env
(append (ensure-list rest-argument)
required-arguments
- optional-arguments))))
+ optional-arguments
+ keyword-arguments))))
(lambda-docstring-wrapper
documentation
"(function ("
;; Check number of arguments
(lambda-check-argument-count n-required-arguments
n-optional-arguments
- rest-argument)
- ;; Optional arguments
- (if optional-arguments
- (concat "switch(arguments.length-1){" *newline*
- (let ((optional-and-defaults
- (lambda-list-optional-arguments-with-default lambda-list))
- (cases nil)
- (idx 0))
- (progn
- (while (< idx n-optional-arguments)
- (let ((arg (nth idx optional-and-defaults)))
- (push (concat "case "
- (integer-to-string (+ idx n-required-arguments)) ":" *newline*
- (translate-variable (car arg))
- "="
- (ls-compile (cadr arg))
- ";" *newline*)
- cases)
- (incf idx)))
- (push (concat "default: break;" *newline*) cases)
- (join (reverse cases))))
- "}" *newline*)
- "")
- ;; &rest/&body argument
- (if rest-argument
- (let ((js!rest (translate-variable rest-argument)))
- (concat "var " js!rest "= " (ls-compile nil) ";" *newline*
- "for (var i = arguments.length-1; i>="
- (integer-to-string (+ 1 n-required-arguments n-optional-arguments))
- "; i--)" *newline*
- (indent js!rest " = "
- "{car: arguments[i], cdr: ") js!rest "};"
- *newline*))
- "")
- ;; Body
- (let ((*multiple-value-p* t)) (ls-compile-block body t)))
+ (or rest-argument keyword-arguments))
+ (compile-lambda-optional lambda-list)
+ (compile-lambda-rest lambda-list)
+ (compile-lambda-parse-keywords lambda-list)
+ (let ((*multiple-value-p* t))
+ (ls-compile-block body t)))
"})"))))
+
(defun setq-pair (var val)
(let ((b (lookup-in-lexenv var *environment* 'variable)))
(if (and (eq (binding-type b) 'variable)
(defun eval (x)
(js-eval (ls-compile-toplevel x t)))
- (export '(&rest &optional &body * *gensym-counter* *package* + - /
- 1+ 1- < <= = = > >= and append apply aref arrayp aset
- assoc atom block boundp boundp butlast caar cadddr caddr
- cadr car car case catch cdar cdddr cddr cdr cdr char
- char-code char= code-char cond cons consp constantly
- copy-list decf declaim defparameter defun defmacro defvar
- digit-char digit-char-p disassemble do do* documentation
- dolist dotimes ecase eq eql equal error eval every export
- fdefinition find-package find-symbol first flet fourth
- fset funcall function functionp gensym get-universal-time
- go identity if in-package incf integerp integerp intern
- keywordp labels lambda last length let let*
- list-all-packages list listp make-array make-package
- make-symbol mapcar member minusp mod multiple-value-bind
- multiple-value-call multiple-value-list
- multiple-value-prog1 nil not nth nthcdr null numberp or
- package-name package-use-list packagep parse-integer plusp
- prin1-to-string print proclaim prog1 prog2 progn psetq
- push quote remove remove-if remove-if-not return
- return-from revappend reverse rplaca rplacd second set
- setq some string-upcase string string= stringp subseq
- symbol-function symbol-name symbol-package symbol-plist
- symbol-value symbolp t tagbody third throw truncate unless
- unwind-protect values values-list variable warn when
- write-line write-string zerop))
+ (export '(&rest &key &optional &body * *gensym-counter* *package* +
+ - / 1+ 1- < <= = = > >= and append apply aref arrayp assoc
+ atom block boundp boundp butlast caar cadddr caddr cadr
+ car car case catch cdar cdddr cddr cdr cdr char char-code
+ char= code-char cond cons consp constantly copy-list decf
+ declaim defconstant defparameter defun defmacro defvar
+ digit-char digit-char-p disassemble do do* documentation
+ dolist dotimes ecase eq eql equal error eval every export
+ fdefinition find-package find-symbol first flet fourth
+ fset funcall function functionp gensym get-universal-time
+ go identity if in-package incf integerp integerp intern
+ keywordp labels lambda last length let let*
+ list-all-packages list listp make-array make-package
+ make-symbol mapcar member minusp mod multiple-value-bind
+ multiple-value-call multiple-value-list
+ multiple-value-prog1 nil not nth nthcdr null numberp or
+ package-name package-use-list packagep parse-integer plusp
+ prin1-to-string print proclaim prog1 prog2 progn psetq
+ push quote remove remove-if remove-if-not return
+ return-from revappend reverse rplaca rplacd second set
+ setq some string-upcase string string= stringp subseq
+ symbol-function symbol-name symbol-package symbol-plist
+ symbol-value symbolp t tagbody third throw truncate unless
+ unwind-protect values values-list variable warn when
+ write-line write-string zeropt))
(setq *package* *user-package*)