X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler.lisp;h=3dc2f1ca2ff155b96342f6a5e74154747e70e5e4;hb=68cd2db6542fa3442d46b0331ecf8be8f86c09c2;hp=4d1cdbd92b5363b5e04a12ed62f66af57beb8534;hpb=6786ccd0852ef92bb195b387ad9e434da3353c3b;p=jscl.git
diff --git a/src/compiler.lisp b/src/compiler.lisp
index 4d1cdbd..3dc2f1c 100644
--- a/src/compiler.lisp
+++ b/src/compiler.lisp
@@ -3,18 +3,18 @@
;; copyright (C) 2012, 2013 David Vazquez
;; Copyright (C) 2012 Raimon Grau
-;; This program is free software: you can redistribute it and/or
+;; JSCL is free software: you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation, either version 3 of the
;; License, or (at your option) any later version.
;;
-;; This program is distributed in the hope that it will be useful, but
+;; JSCL is distributed in the hope that it will be useful, but
;; WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;; General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
-;; along with this program. If not, see .
+;; along with JSCL. If not, see .
;;;; Compiler
@@ -30,7 +30,7 @@
((integerp arg) (integer-to-string arg))
((floatp arg) (float-to-string arg))
((stringp arg) arg)
- (t (error "Unknown argument."))))
+ (t (error "Unknown argument `~S'." arg))))
args))
;;; Wrap X with a Javascript code to convert the result from
@@ -87,62 +87,6 @@
;;; function call.
(defvar *multiple-value-p* nil)
-;; A very simple defstruct built on lists. It supports just slot with
-;; an optional default initform, and it will create a constructor,
-;; predicate and accessors for you.
-(defmacro def!struct (name &rest slots)
- (unless (symbolp name)
- (error "It is not a full defstruct implementation."))
- (let* ((name-string (symbol-name name))
- (slot-descriptions
- (mapcar (lambda (sd)
- (cond
- ((symbolp sd)
- (list sd))
- ((and (listp sd) (car sd) (cddr sd))
- sd)
- (t
- (error "Bad slot accessor."))))
- slots))
- (predicate (intern (concat name-string "-P"))))
- `(progn
- ;; Constructor
- (defun ,(intern (concat "MAKE-" name-string)) (&key ,@slot-descriptions)
- (list ',name ,@(mapcar #'car slot-descriptions)))
- ;; Predicate
- (defun ,predicate (x)
- (and (consp x) (eq (car x) ',name)))
- ;; Copier
- (defun ,(intern (concat "COPY-" name-string)) (x)
- (copy-list x))
- ;; Slot accessors
- ,@(with-collect
- (let ((index 1))
- (dolist (slot slot-descriptions)
- (let* ((name (car slot))
- (accessor-name (intern (concat name-string "-" (string name)))))
- (collect
- `(defun ,accessor-name (x)
- (unless (,predicate x)
- (error ,(concat "The object is not a type " name-string)))
- (nth ,index x)))
- ;; TODO: Implement this with a higher level
- ;; abstraction like defsetf or (defun (setf ..))
- (collect
- `(define-setf-expander ,accessor-name (x)
- (let ((object (gensym))
- (new-value (gensym)))
- (values (list object)
- (list x)
- (list new-value)
- `(progn
- (rplaca (nthcdr ,',index ,object) ,new-value)
- ,new-value)
- `(,',accessor-name ,object)))))
- (incf index)))))
- ',name)))
-
-
;;; Environment
(def!struct binding
@@ -183,6 +127,7 @@
(defvar *variable-counter* 0)
(defun gvarname (symbol)
+ (declare (ignore symbol))
(code "v" (incf *variable-counter*)))
(defun translate-variable (symbol)
@@ -290,7 +235,7 @@
(defun ll-rest-argument (ll)
(let ((rest (ll-section '&rest ll)))
(when (cdr rest)
- (error "Bad lambda-list"))
+ (error "Bad lambda-list `~S'." ll))
(car rest)))
(defun ll-keyword-arguments-canonical (ll)
@@ -316,11 +261,14 @@
(ll-optional-arguments-canonical lambda-list))))
(remove nil (mapcar #'third args))))
-(defun lambda-docstring-wrapper (docstring &rest strs)
- (if docstring
+(defun lambda-name/docstring-wrapper (name docstring &rest strs)
+ (if (or name docstring)
(js!selfcall
"var func = " (join strs) ";" *newline*
- "func.docstring = '" docstring "';" *newline*
+ (when name
+ (code "func.fname = '" (escape-string name) "';" *newline*))
+ (when docstring
+ (code "func.docstring = '" (escape-string docstring) "';" *newline*))
"return func;" *newline*)
(apply #'code strs)))
@@ -328,32 +276,25 @@
(n-required-arguments n-optional-arguments rest-p)
;; Note: Remember that we assume that the number of arguments of a
;; call is at least 1 (the values argument).
- (let ((min (1+ n-required-arguments))
- (max (if rest-p 'n/a (+ 1 n-required-arguments n-optional-arguments))))
+ (let ((min n-required-arguments)
+ (max (if rest-p 'n/a (+ n-required-arguments n-optional-arguments))))
(block nil
;; Special case: a positive exact number of arguments.
- (when (and (< 1 min) (eql min max))
- (return (code "checkArgs(arguments, " min ");" *newline*)))
+ (when (and (< 0 min) (eql min max))
+ (return (code "checkArgs(nargs, " min ");" *newline*)))
;; General case:
(code
- (when (< 1 min)
- (code "checkArgsAtLeast(arguments, " min ");" *newline*))
+ (when (< 0 min)
+ (code "checkArgsAtLeast(nargs, " min ");" *newline*))
(when (numberp max)
- (code "checkArgsAtMost(arguments, " max ");" *newline*))))))
+ (code "checkArgsAtMost(nargs, " max ");" *newline*))))))
(defun compile-lambda-optional (ll)
(let* ((optional-arguments (ll-optional-arguments-canonical ll))
(n-required-arguments (length (ll-required-arguments ll)))
(n-optional-arguments (length optional-arguments)))
(when optional-arguments
- (code (mapconcat (lambda (arg)
- (code "var " (translate-variable (first arg)) "; " *newline*
- (when (third arg)
- (code "var " (translate-variable (third arg))
- " = " (ls-compile t)
- "; " *newline*))))
- optional-arguments)
- "switch(arguments.length-1){" *newline*
+ (code "switch(nargs){" *newline*
(let ((cases nil)
(idx 0))
(progn
@@ -381,11 +322,9 @@
(when rest-argument
(let ((js!rest (translate-variable rest-argument)))
(code "var " js!rest "= " (ls-compile nil) ";" *newline*
- "for (var i = arguments.length-1; i>="
- (+ 1 n-required-arguments n-optional-arguments)
+ "for (var i = nargs-1; i>=" (+ n-required-arguments n-optional-arguments)
"; i--)" *newline*
- (indent js!rest " = {car: arguments[i], cdr: ") js!rest "};"
- *newline*)))))
+ (indent js!rest " = {car: arguments[i+2], cdr: " js!rest "};" *newline*))))))
(defun compile-lambda-parse-keywords (ll)
(let ((n-required-arguments
@@ -407,12 +346,12 @@
;; Parse keywords
(flet ((parse-keyword (keyarg)
;; ((keyword-name var) init-form)
- (code "for (i=" (+ 1 n-required-arguments n-optional-arguments)
- "; i