src/compilation-interface.lisp

   1 (in-package "PARENSCRIPT")
   2
   3 (defparameter *js-target-version* 1.3)
   4
   5 (defmacro ps (&body body)
   6   "Given Parenscript forms (an implicit progn), compiles those forms
   7 to a JavaScript string at macro-expansion time."
   8   (let ((s (gensym)))
   9     `(with-output-to-string (,s)
  10        ,@(mapcar (lambda (x)
  11                    `(write-string ,x ,s))
  12                  (parenscript-print
  13                   (ps-compile-statement `(progn ,@body)))))))
  14 (defun ps* (&rest body)
  15   "Compiles BODY to a JavaScript string.
  16 Body is evaluated."
  17   (compiled-form-to-string (ps-compile-statement `(progn ,@body))))
  18
  19 (defmacro ps-doc (&body body)
  20   "Expands Parenscript forms in a clean environment."
  21   (let ((*ps-gensym-counter* 0)
  22         (*ps-special-variables* nil))
  23      (macroexpand-1 `(ps ,@body))))
  24
  25 (defun ps-doc* (ps-form)
  26   (let ((*ps-gensym-counter* 0)
  27         (*ps-special-variables* nil))
  28     (ps* ps-form)))
  29
  30 (defun compiled-form-to-string (ps-compiled-form)
  31   (with-output-to-string (s)
  32     (dolist (x (parenscript-print ps-compiled-form))
  33       (write-string (if (stringp x) x (eval x)) s))))
  34
  35 (defvar *js-inline-string-delimiter* #\"
  36   "Controls the string delimiter char used when compiling Parenscript in ps-inline.")
  37
  38 (defun ps-inline* (form &optional (*js-string-delimiter* *js-inline-string-delimiter*))
  39   (concatenate 'string "javascript:" (ps* form)))
  40
  41 (defmacro/ps ps-inline (form &optional (string-delimiter *js-inline-string-delimiter*))
  42   `(concatenate 'string "javascript:"
  43                 ,@(let ((*js-string-delimiter* string-delimiter))
  44                     (parenscript-print (ps-compile form)))))
  45
  46 (defvar *ps-read-function* #'read
  47   "This should be a function that takes the same inputs and returns the same
  48 outputs as the common lisp read function.  We declare it as a variable to allow
  49 a user-supplied reader instead of the default lisp reader.")
  50
  51 (defun ps-compile-stream (stream)
  52   "Compiles a source stream as if it were a file.  Outputs a Javascript string."
  53   (let ((*ps-compilation-level* :toplevel)
  54         (*package* *package*)
  55         (end-read-form '#:unique))
  56     (flet ((read-form () (funcall *ps-read-function* stream nil end-read-form)))
  57       (let* ((js-string
  58               ;; cons up the forms, compiling as we go, and print the result
  59               (do ((form (read-form) (read-form))
  60                    (compiled-forms nil))
  61                   ((eql form end-read-form)
  62                      (format nil "~{~A~^;~%~}"
  63                              (remove-if
  64                               #'(lambda (x) (or (null x) (= 0 (length x))))
  65                               (mapcar 'compiled-form-to-string (nreverse compiled-forms)))))
  66                 (push (ps-compile-statement form) compiled-forms))))
  67         js-string))))
  68
  69 (defun ps-compile-file (source-file)
  70   "Compiles the given Parenscript source file and returns a Javascript string."
  71   (with-open-file (stream source-file :direction :input)
  72     (ps-compile-stream stream)))