parenscript-devel

parenscript-devel@common-lisp.net

373 discussions

[parenscript-devel] Reimplementing (.method object ...) syntax
by Clinton Ebadi 07 Oct '09

07 Oct '09

Greetings, I recently upgraded parenscript after a few months and was disheartened to see that (.method ...) syntax was removed (and to a lesser extent foo.bar and foo[bar] syntax). I read the mailing list threads pertaining to the new lexical let implementation and compiler improvements, but after skimming the source code I don't see why (.method ...) could not be supported. As such I have started a symbol-syntax branch at [0]. In particular I have done a first stab at reimplementing the (.method ...) syntax in the patch viewable at [1]. I do not yet have a grasp of the subtleties in the new compiler, but I think the patch looks basically correct. I figured you guys could tell me if I missed anything. Are there any objections to the patch? I've found that (funcall (@ foo bar) ...) and (chain foo bar (baz ...)) syntax to be fairly unwieldy for something as common as a method call, and don't see why (.method ...) should not be considered a fundamental syntax of parenscript (parenscript is parenscript and not lisp; enforcing consistency with lisp syntax at the expense of conciseness is not desirable in my opinion). I'll probably reimplement foo.bar.baz syntax properly (by splitting the symbol apart and translating to nested (js:slot-value ...) nodes?). I'm not convinced that it is worth having foo[bar] syntax however (but drewc disagrees so I may reimplement it anyway for our use in ucw/lisp-on-lines). Is there anything fundamentally preventing this from working properly (in the face of symbol renaming and such)? [0] git://git.hcoop.net/git/clinton/parenscript.git [1] http://git.hcoop.net/?p=clinton/parenscript.git;a=commitdiff;h=18eb19984154… -- Jessie: but today i was a nerd Jessie: i even read slashdot.

2 2

[parenscript-devel] Parenscript release candidate.
by Vladimir Sedach 18 Sep '09

18 Sep '09

Hi everybody, I just pushed a bunch of patches greatly improving Parenscript compilation performance, and adding the ability to print Parenscript output directly to a stream. I think it's time to make a release. Please check out the latest version from the git repository and see if everything works as expected. If there aren't any bug reports by Sept. 18, I am going to make a new release. Thank you, Vladimir

2 5

[parenscript-devel] [PATCH] Extend CHAIN to support slot-values
by Daniel White 13 Sep '09

13 Sep '09

For example: (chain ($ "foo") (bar x z) frob (baz 5) => $('foo').bar(x, z).frob.baz(5); --- src/lib/ps-macro-lib.lisp | 4 +++- 1 files changed, 3 insertions(+), 1 deletions(-) diff --git a/src/lib/ps-macro-lib.lisp b/src/lib/ps-macro-lib.lisp index be90b79..2ef7d82 100644 --- a/src/lib/ps-macro-lib.lisp +++ b/src/lib/ps-macro-lib.lisp @@ -84,7 +84,9 @@ (defpsmacro chain (&rest method-calls) (labels ((do-chain (method-calls) (if (cdr method-calls) - `((@ ,(do-chain (cdr method-calls)) ,(caar method-calls)) ,@(cdar method-calls)) + (if (listp (car method-calls)) + `((@ ,(do-chain (cdr method-calls)) ,(caar method-calls)) ,@(cdar method-calls)) + `(@ ,(do-chain (cdr method-calls)) ,(car method-calls))) (car method-calls)))) (do-chain (reverse method-calls)))) -- 1.6.4.2

2 1

[parenscript-devel] Updates to PS LOOP
by Daniel Gackle 16 Aug '09

16 Aug '09

Javascript's FOR and CL's LOOP disagree about how to interpret end-tests and step-forms. In JS, all of the step forms are evaluated before any of the end tests are, while in LOOP, the end-test for one :FOR clause is evaluated (and, if it fails, the loop terminates) before the step-form for the next :FOR clause is processed. The syntax of LOOP strongly implies the latter behavior. This was leading to unwanted surprises, since the generated JS FOR loop wasn't always terminating when expected. After a dozen or more experiences of JS code crashing because of this contradiction, I bit the bullet and made LOOP generate different JS code when multiple :FOR clauses are specified. This makes the generated code more verbose, because end-tests and step-forms can't be inlined into the FOR block anymore. But now the code does what LOOP implies. This patch has been pushed (along with a couple of very minor tweaks to special-forms.lisp). Daniel

1 0

[parenscript-devel] Bug#540704: RFA: parenscript -- JavaScript embedded in a Common Lisp host
by Luca Capello 09 Aug '09

09 Aug '09

Package: wnpp Severity: normal Hi there! As I explained on the pkg-common-lisp-devel@ mailing list, I have no more interest in maintaining Parenscript: http://lists.alioth.debian.org/pipermail/pkg-common-lisp-devel/2009-July/00… The package is outdated mostly because of a bug with the Debian Darcs repositories, as explained at: http://lists.alioth.debian.org/pipermail/pkg-common-lisp-devel/2008-October… If no one will step in and adopt Parenscript, I will ask for its removal in two weeks. Package description is below. Thx, bye, Gismo / Luca ===== Homepage: http://www.cliki.net/Parenscript Description: JavaScript embedded in a Common Lisp host Parenscript is a small lispy language that can be compiled to JavaScript. . It also comes with an embedded CSS representation in Common Lisp. This simplifies the development of web applications in Common Lisp by allowing the Common Lisp programmer to write all the documents in Common Lisp syntax. . HTML pages, CSS files and JavaScript code can be generated with the full power of Common Lisp and its macros. . The recommended packages add extra features: test suite with cl-ppcre and cl-fiveam. . Single file documentation is provided via the texlive-latex-base, texlive-latex-recommended, texlive-fonts-recommended and python packages.

1 0

[parenscript-devel] Bug: incorrect JS emitted for binary operators with more than 2 operands
by Daniel Gackle 07 Aug '09

07 Aug '09

PS generates code for expressions like (> x y z) as if the operators worked the same way in JS and Lisp, but they don't. For example, (ps (> 3 2 1)) => "3 > 2 > 1;" ... is an expression that is true in Lisp but false in JS. Daniel

2 3

[parenscript-devel] Added REPEAT clauses to PS loop
by Daniel Gackle 01 Aug '09

01 Aug '09

I added the simple REPEAT clause that's supported by CL's LOOP to PS's pseudo-LOOP: (ps (loop repeat 3 do (alert "hi"))) => "for (var _js3691 = 0; _js3691 < 3; _js3691 += 1) { alert('hi'); };" Daniel >From 043a85a1f155068af509e05fd32ae2adcfb0f30f Mon Sep 17 00:00:00 2001 From: Daniel Gackle <danielgackle(a)gmail.com> Date: Fri, 31 Jul 2009 14:20:15 -0600 Subject: [PATCH] Added :REPEAT clauses to PS's LOOP. --- src/lib/ps-loop.lisp | 7 ++++++- 1 files changed, 6 insertions(+), 1 deletions(-) diff --git a/src/lib/ps-loop.lisp b/src/lib/ps-loop.lisp index c7334fa..38ea78c 100644 --- a/src/lib/ps-loop.lisp +++ b/src/lib/ps-loop.lisp @@ -9,7 +9,7 @@ (defvar *loop-keywords* '(:for :do :when :unless :initially :finally :first-time :last-time :while :until :from :to :below :downto :above :by :in :across :on :index := :then :sum :collect - :count :minimize :maximize :into)) + :count :minimize :maximize :into :repeat)) (defun normalize-loop-keywords (args) (mapcar @@ -146,10 +146,15 @@ ((:in :across) (for-in var)) (:on (for-on var)) (otherwise (error "FOR ~s ~s is not valid in PS-LOOP." var term))))) + (repeat-clause () + (let ((index (ps-gensym))) + (setf terms (append `(:for ,index :from 0 :below ,(consume)) terms)) + (clause))) (clause () (let ((term (consume-atom))) (case term (:for (for-clause)) + (:repeat (repeat-clause)) (:while (push `(unless ,(consume) break) body)) (:until (push `(when ,(consume) break) body)) (:initially (push (consume-progn) initially)) -- 1.6.1

2 1

[parenscript-devel] patch to export chain macro
by Kelly McDonald 01 Aug '09

01 Aug '09

The chain macro was defined @ d9d9a9705bdfd0559ee1bbf9ca, but wasn't exported Kelly diff --git a/src/package.lisp b/src/package.lisp index dee537f..a41ce1e 100644 --- a/src/package.lisp +++ b/src/package.lisp @@ -185,6 +185,7 @@ #:defined #:undefined #:@ + #:chain #:with-lambda #:stringp #:numberp

2 1

[parenscript-devel] Inconsistency between (slot-value obj :keyword-symbol) and :keyword-symbol. Patch attached
by Red Daly 27 Jul '09

27 Jul '09

Dear Parenscripters, I found an inconsistency in how symbols are translated into Javascript. The issue is similar to an earlier issue: CL-USER> (ps:ps (let ((sym :my-function)) (slot-value object sym) (slot-value object :my-function))) "var sym = 'my-function'; object[sym]; object.myFunction;" One would expect object[sym] and object.myFunction to evaluate to the same value, but right now they do not. This bug only affects keywords: CL-USER> (ps:ps (let ((sym 'my-function)) (slot-value object sym) (slot-value object 'my-function))) "var sym = 'myFunction'; object[sym]; object.myFunction;" The above output is sensible. A patch is attached to fix this issue. A few test cases have also been added to prevent future breakage. The old DEFUN-KEYWORD4 test function failed with this patch because it expected a keyword to translate to 'my-name-key'. I patched it to expect 'myNameKey' Best, Red >From 904be1cc2eee598491557132e8ed1569a90f27a3 Mon Sep 17 00:00:00 2001 From: Red Daly <reddaly(a)gmail.com> Date: Sun, 26 Jul 2009 20:22:54 +0000 Subject: [PATCH] Fixed eval-when special form and added tests to prevent future breakage. --- src/compiler.lisp | 50 ++++++++++++++++++++++++++++---------------------- t/ps-tests.lisp | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 68 insertions(+), 22 deletions(-) diff --git a/src/compiler.lisp b/src/compiler.lisp index 4fed094..e72fb4e 100644 --- a/src/compiler.lisp +++ b/src/compiler.lisp @@ -162,17 +162,20 @@ compiled to an :expression (the default), a :statement, or a :symbol.")) (defun adjust-ps-compilation-level (form level) - (cond ((or (and (consp form) (eq 'progn (car form))) - (and (symbolp form) (eq :toplevel level))) - level) - ((eq :toplevel level) :inside-toplevel-form))) + "Given the current *ps-compilation-level*, LEVEL, and the fully macroexpanded +form, FORM, returns the new value for *ps-compilation-level*." + (cond ((or (and (consp form) (member (car form) + '(progn locally macrolet symbol-macrolet compile-file))) + (and (symbolp form) (eq :toplevel level))) + level) + ((eq :toplevel level) :inside-toplevel-form))) + (defmethod compile-parenscript-form :around (form &key expecting) (assert (if expecting (member expecting '(:expression :statement :symbol)) t)) (if (eq expecting :symbol) (compile-to-symbol form) - (let ((*ps-compilation-level* (adjust-ps-compilation-level form *ps-compilation-level*))) - (call-next-method)))) + (call-next-method))) (defun compile-to-symbol (form) "Compiles the given Parenscript form and guarantees that the @@ -226,22 +229,25 @@ the form cannot be compiled to a symbol." (defmethod compile-parenscript-form ((form cons) &key (expecting :statement)) (multiple-value-bind (form expanded-p) (ps-macroexpand form) - (cond (expanded-p (compile-parenscript-form form :expecting expecting)) - ((ps-special-form-p form) (apply (get-ps-special-form (car form)) (cons expecting (cdr form)))) - ((op-form-p form) - `(js:operator ,(ps-convert-op-name (compile-parenscript-form (car form) :expecting :symbol)) - ,@(mapcar (lambda (form) - (compile-parenscript-form (ps-macroexpand form) :expecting :expression)) - (cdr form)))) - ((funcall-form-p form) - `(js:funcall ,(compile-parenscript-form (if (symbolp (car form)) - (maybe-rename-local-function (car form)) - (ps-macroexpand (car form))) - :expecting :expression) - ,@(mapcar (lambda (arg) - (compile-parenscript-form (ps-macroexpand arg) :expecting :expression)) - (cdr form)))) - (t (error "Cannot compile ~S to a ParenScript form." form))))) + (let ((*ps-compilation-level* (if expanded-p + *ps-compilation-level* + (adjust-ps-compilation-level form *ps-compilation-level*)))) + (cond (expanded-p (compile-parenscript-form form :expecting expecting)) + ((ps-special-form-p form) (apply (get-ps-special-form (car form)) (cons expecting (cdr form)))) + ((op-form-p form) + `(js:operator ,(ps-convert-op-name (compile-parenscript-form (car form) :expecting :symbol)) + ,@(mapcar (lambda (form) + (compile-parenscript-form (ps-macroexpand form) :expecting :expression)) + (cdr form)))) + ((funcall-form-p form) + `(js:funcall ,(compile-parenscript-form (if (symbolp (car form)) + (maybe-rename-local-function (car form)) + (ps-macroexpand (car form))) + :expecting :expression) + ,@(mapcar (lambda (arg) + (compile-parenscript-form (ps-macroexpand arg) :expecting :expression)) + (cdr form)))) + (t (error "Cannot compile ~S to a ParenScript form." form)))))) (defvar *ps-gensym-counter* 0) diff --git a/t/ps-tests.lisp b/t/ps-tests.lisp index cd9d4f2..0324c09 100644 --- a/t/ps-tests.lisp +++ b/t/ps-tests.lisp @@ -1129,3 +1129,43 @@ x1 - x1; --x1; ++x1;") +(test-ps-js eval-when-ps-side + (eval-when (:execute) + 5) + "5;") + +(defvar *lisp-output* nil) + +(test eval-when-lisp-side () + (setf *lisp-output* 'original-value) + (let ((js-output (normalize-js-code + (ps-doc* `(eval-when (:compile-toplevel) + (setf *lisp-output* 'it-works)))))) + (is (eql 'it-works *lisp-output*)) + (is (string= "" js-output)))) + +(defpsmacro my-in-package (package-name) + `(eval-when (:compile-toplevel) + (setf *lisp-output* ,package-name))) + +(test eval-when-macro-expansion () + (setf *lisp-output* 'original-value) + (let ((js-output (normalize-js-code + (ps-doc* `(progn + (my-in-package :cl-user) + 3))))) + (declare (ignore js-output)) + (is (eql :cl-user *lisp-output*)))) + ;(is (string= "" js-output)))) + +(test eval-when-macrolet-expansion () + (setf *lisp-output* 'original-value) + (let ((js-output (normalize-js-code + (ps-doc* `(macrolet ((my-in-package2 (package-name) + `(eval-when (:compile-toplevel) + (setf *lisp-output* ,package-name)))) + (my-in-package2 :cl-user) + 3))))) + (declare (ignore js-output)) + (is (eql :cl-user *lisp-output*)))) + ;(is (string= "" js-output)))) -- 1.5.4.3 >From d6748a5cfc8c4b9300884e9e5061db19cb0407cd Mon Sep 17 00:00:00 2001 From: Red Daly <reddaly(a)gmail.com> Date: Sun, 26 Jul 2009 20:49:59 +0000 Subject: [PATCH] Fixed keyword translation inconsistency between (slot-value object :key-thing) and :key-thing. --- src/printer.lisp | 2 +- src/special-forms.lisp | 2 +- t/ps-tests.lisp | 18 +++++++++++++++++- 3 files changed, 19 insertions(+), 3 deletions(-) diff --git a/src/printer.lisp b/src/printer.lisp index b649dae..edf74b2 100644 --- a/src/printer.lisp +++ b/src/printer.lisp @@ -43,7 +43,7 @@ arguments, defines a printer for that form using the given body." (defmethod ps-print ((s symbol)) (assert (keywordp s)) - (ps-print (string-downcase s))) + (ps-print (symbol-to-js-string s))) (defmethod ps-print ((compiled-form cons)) (ps-print% (car compiled-form) (cdr compiled-form))) diff --git a/src/special-forms.lisp b/src/special-forms.lisp index 802dc28..e96a6d4 100644 --- a/src/special-forms.lisp +++ b/src/special-forms.lisp @@ -34,7 +34,7 @@ (typecase x (cons `(array ,@(mapcar (lambda (x) (when x `',x)) x))) (null '(array)) - (keyword x) + (keyword (symbol-to-js-string x)) (symbol (symbol-to-js-string x)) (number x) (string x)) diff --git a/t/ps-tests.lisp b/t/ps-tests.lisp index 0324c09..540d1a6 100644 --- a/t/ps-tests.lisp +++ b/t/ps-tests.lisp @@ -455,7 +455,7 @@ __setf_someThing(_js1, _js2, _js3);") var _js2 = arguments.length; for (var n1 = 0; n1 < _js2; n1 += 2) { switch (arguments[n1]) { - case 'my-name-key': + case 'myNameKey': { myName = arguments[n1 + 1]; }; @@ -1169,3 +1169,19 @@ x1 - x1; (declare (ignore js-output)) (is (eql :cl-user *lisp-output*)))) ;(is (string= "" js-output)))) + +(test-ps-js keyword-conversion1 + :alpha-omega + "'alphaOmega';") + +(test-ps-js keyword-conversion2 + (slot-value object :alpha-omega) + "object.alphaOmega;") + +(test keyword-conversion2 () + (let ((js-output1 (normalize-js-code + (ps-doc* '(slot-value object :alpha-omega)))) + (js-output2 (normalize-js-code + (ps-doc* :alpha-omega))) + (declare (ignore js-output)) + (is (eql :cl-user *lisp-output*)))) -- 1.5.4.3

3 5

[parenscript-devel] eval-when bug fix patch
by Red Daly 27 Jul '09

27 Jul '09

The parenscript form EVAL-WHEN was broken due to macroexpansion issues. I have attached a patch that should fix this issue: >From 904be1cc2eee598491557132e8ed1569a90f27a3 Mon Sep 17 00:00:00 2001 From: Red Daly <reddaly(a)gmail.com> Date: Sun, 26 Jul 2009 20:22:54 +0000 Subject: [PATCH] Fixed eval-when special form and added tests to prevent future breakage. --- src/compiler.lisp | 50 ++++++++++++++++++++++++++++---------------------- t/ps-tests.lisp | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 68 insertions(+), 22 deletions(-) diff --git a/src/compiler.lisp b/src/compiler.lisp index 4fed094..e72fb4e 100644 --- a/src/compiler.lisp +++ b/src/compiler.lisp @@ -162,17 +162,20 @@ compiled to an :expression (the default), a :statement, or a :symbol.")) (defun adjust-ps-compilation-level (form level) - (cond ((or (and (consp form) (eq 'progn (car form))) - (and (symbolp form) (eq :toplevel level))) - level) - ((eq :toplevel level) :inside-toplevel-form))) + "Given the current *ps-compilation-level*, LEVEL, and the fully macroexpanded +form, FORM, returns the new value for *ps-compilation-level*." + (cond ((or (and (consp form) (member (car form) + '(progn locally macrolet symbol-macrolet compile-file))) + (and (symbolp form) (eq :toplevel level))) + level) + ((eq :toplevel level) :inside-toplevel-form))) + (defmethod compile-parenscript-form :around (form &key expecting) (assert (if expecting (member expecting '(:expression :statement :symbol)) t)) (if (eq expecting :symbol) (compile-to-symbol form) - (let ((*ps-compilation-level* (adjust-ps-compilation-level form *ps-compilation-level*))) - (call-next-method)))) + (call-next-method))) (defun compile-to-symbol (form) "Compiles the given Parenscript form and guarantees that the @@ -226,22 +229,25 @@ the form cannot be compiled to a symbol." (defmethod compile-parenscript-form ((form cons) &key (expecting :statement)) (multiple-value-bind (form expanded-p) (ps-macroexpand form) - (cond (expanded-p (compile-parenscript-form form :expecting expecting)) - ((ps-special-form-p form) (apply (get-ps-special-form (car form)) (cons expecting (cdr form)))) - ((op-form-p form) - `(js:operator ,(ps-convert-op-name (compile-parenscript-form (car form) :expecting :symbol)) - ,@(mapcar (lambda (form) - (compile-parenscript-form (ps-macroexpand form) :expecting :expression)) - (cdr form)))) - ((funcall-form-p form) - `(js:funcall ,(compile-parenscript-form (if (symbolp (car form)) - (maybe-rename-local-function (car form)) - (ps-macroexpand (car form))) - :expecting :expression) - ,@(mapcar (lambda (arg) - (compile-parenscript-form (ps-macroexpand arg) :expecting :expression)) - (cdr form)))) - (t (error "Cannot compile ~S to a ParenScript form." form))))) + (let ((*ps-compilation-level* (if expanded-p + *ps-compilation-level* + (adjust-ps-compilation-level form *ps-compilation-level*)))) + (cond (expanded-p (compile-parenscript-form form :expecting expecting)) + ((ps-special-form-p form) (apply (get-ps-special-form (car form)) (cons expecting (cdr form)))) + ((op-form-p form) + `(js:operator ,(ps-convert-op-name (compile-parenscript-form (car form) :expecting :symbol)) + ,@(mapcar (lambda (form) + (compile-parenscript-form (ps-macroexpand form) :expecting :expression)) + (cdr form)))) + ((funcall-form-p form) + `(js:funcall ,(compile-parenscript-form (if (symbolp (car form)) + (maybe-rename-local-function (car form)) + (ps-macroexpand (car form))) + :expecting :expression) + ,@(mapcar (lambda (arg) + (compile-parenscript-form (ps-macroexpand arg) :expecting :expression)) + (cdr form)))) + (t (error "Cannot compile ~S to a ParenScript form." form)))))) (defvar *ps-gensym-counter* 0) diff --git a/t/ps-tests.lisp b/t/ps-tests.lisp index cd9d4f2..0324c09 100644 --- a/t/ps-tests.lisp +++ b/t/ps-tests.lisp @@ -1129,3 +1129,43 @@ x1 - x1; --x1; ++x1;") +(test-ps-js eval-when-ps-side + (eval-when (:execute) + 5) + "5;") + +(defvar *lisp-output* nil) + +(test eval-when-lisp-side () + (setf *lisp-output* 'original-value) + (let ((js-output (normalize-js-code + (ps-doc* `(eval-when (:compile-toplevel) + (setf *lisp-output* 'it-works)))))) + (is (eql 'it-works *lisp-output*)) + (is (string= "" js-output)))) + +(defpsmacro my-in-package (package-name) + `(eval-when (:compile-toplevel) + (setf *lisp-output* ,package-name))) + +(test eval-when-macro-expansion () + (setf *lisp-output* 'original-value) + (let ((js-output (normalize-js-code + (ps-doc* `(progn + (my-in-package :cl-user) + 3))))) + (declare (ignore js-output)) + (is (eql :cl-user *lisp-output*)))) + ;(is (string= "" js-output)))) + +(test eval-when-macrolet-expansion () + (setf *lisp-output* 'original-value) + (let ((js-output (normalize-js-code + (ps-doc* `(macrolet ((my-in-package2 (package-name) + `(eval-when (:compile-toplevel) + (setf *lisp-output* ,package-name)))) + (my-in-package2 :cl-user) + 3))))) + (declare (ignore js-output)) + (is (eql :cl-user *lisp-output*)))) + ;(is (string= "" js-output)))) -- 1.5.4.3

2 1

← Newer
1
...
21
22
23
24
25
26
27
...
38
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

parenscript-devel