Added destructuring lists to PS-LOOP.

Removed some unnecessary code that ignored an anaphor in define-ps-special-form (declare (ignorable sufficed.

Changed representation of expression blocks and 'if' to look more like JS in intermediate code.

Merge branch 'master' of ssh://vsedach@common-lisp.net/project/parenscript/public_html/git/parenscript

Removed 'append' from runtime lib since Daniel Gackle provided a more concise macro version in 83a26b36c.

Added a file PS-DOM with handy utility macros for DOM functionality, e.g. Lispy ways of accessing offsetWidth, offsetHeight, etc.

Added several new utility macros, including a primitive DESTRUCTURING-BIND.

Modified the way the PS-LOOP does SUM (it now gensyms an accumulation var rather than accepting INTO) and added COLLECT to work the same way.

Added a macro WITH-LAMBDA that's useful for wrapping one or more statements up into an expression.

Updated tests to reflect changes in latest patches from Daniel Gackle.

Fixed 'lisp' form to produce code that captures enclosing lexical scope correctly in 'ps' macro (broke it in my previous patch 0ce67a33), added unit tests to check for expansion in correct environment.

Exported 'loop' from Parenscript package, moved utility functions to src/utils.lisp.

Updated tests to reflect changes in latest patches from Daniel Gackle.

Fixed 'lisp' form to produce code that captures enclosing lexical scope correctly in 'ps' macro (broke it in my previous patch 0ce67a33), added unit tests to check for expansion in correct environment.

Exported 'loop' from Parenscript package, moved utility functions to src/utils.lisp.

Restored the old psmacro for LISP evaluation, because the new special form wasn't working.

When turning a quoted list into a JS array, compile elements that are NIL as "null", not "[]". There is no way to make JS completely consistent with Lisp here, because NIL means two different things in JS (null or an empty list) where it means only one thing in Lisp. We have to pick one thing in this context, and "[null]" is more common than "[[]]".

Quoted symbols should be emitted as literal strings, not converted first to JS symbols, otherwise symbols with characters like * and ? will be emitted as "star" and "what", which makes sense only if you're trying to define a function or variable name, but not if you're generating arbitrary strings.

Generate "[]" rather than "new Array()" for concision.

Changed PS-LOOP to emit DO* (i.e. normal JS for-loop code) rather than DO. It was originally written when DO meant DO* (in today's terms). Using DO here makes the generated code slower and breaks a bunch of our existing cases. Also, DO* produces more idiomatic JS code and should be the default case (there is unfortunately no single default here that gives all the desired behavior, but this is a better tradeoff).

Use WITH-OUTPUT-TO-STRING instead of CONCATENATE, because the latter fails when there are too many arguments (this happens in Clozure more often than SBCL).

Modified the PS compiler to produce an intermediate representation that looks like raw JavaScript in s-exp notation.

Removed the doeach macro.

Changed tests to reflect Daniel Gackle's keyword arguments patch.

Initialize keyword arguments from js ARGUMENTS, allowing keywords to also be passed as normal function arguments without an error being thrown.

Added a partial implementation of LOOP to PS.

Made the ignore declaration in define-ps-special-form be generated on the condition that 'expecting is used in the body. While it's not an error to use variables previously declared ignored, it does raise annoying compiler warnings in some Lisps.

Removed compile-time constant string concatenation from the Parenscript printer, which was significantly slowing down compilation.

Changed the definition of define-ps-special-form to make "expecting" an anaphor.

Changed the implementation of quote from being special cased in several Parenscript internal functions to a Parenscript macro. This makes the code simpler and allows for extensibility of how quoted forms are translated. One example is quoted strings being translated to JavaScript array literals.

Renamed *html-empty-tag-aware-p* to *ps-html-empty-tag-aware-p* and *html-mode* to *ps-html-mode* to not clash with CL-WHO symbols, but still follow the same naming convention.

Removed tutorial.lisp from repository (it is now updated and placed online in HTML format: common-lisp.net/project/parenscript/tutorial.html)

Changed ps-html generators to behave more like CL-WHO when it comes to XML/SGML, self-closing/empty tags. Changed the name of *self-closing-tags-p* flag to *html-empty-tag-aware-p*, added *html-mode* parameter.

Regenerated reference-tests.lisp from reference doc with latest changes.

Rewrote some unit tests to simplify code.

Added ps-doc* function to PS compilation interface.

Added example of closure symbol-map usage for obfuscate-package in reference doc.

Removed literal backspace character from the JS escape sequence part of the reference doc since it caused an error when generating PDFs.

Added note about printing special characters to escape sequences to the reference.

Added all symbols from DOM levels 1 and 2, Window working draft to the
DOM symbol export convenience packages (used with obfuscation). Moved
non-standard DOM symbols to their own package. Removed the Prototype
symbol export convenience package.

Fixed the 'pi' symbol-macro.

Introduced the "funcall" macro (which really doesn't do anything - only CL needs it because of the weird way it treats form evaluation).

Updated js-expander to work with the latest CVS version of SLIME.

Added 'reduce' function to runtime lib.

Fixed a bug where variable initializations inside for loops were being compiled as statements instead of expressions.

Implemented 'flet' and 'labels' as PS macros.

Made who-ps-html handle multiple html forms correctly (ie - things like (:ul (:li) (:li))).

Changed let to not introduce any extra variables (for parallel
binding) when only one variable is being bound.

Got rid of the "(.method-name object args)" method-calling
convention. It breaks package prefixing/obfuscation, and while
sometimes a handy shortcut it obscures how method calls are really
done, and introduces a redundant way of doing them which complicates
code-walkers and (future) attempts at Parenscript compiler
open-implementation facilities.

Changed the @ (slot-value composition macro) not to do the dollar sign
thing if the first argument is a string ('$' is a Prototype library
function), and not to do spurious macroexpansion.

Defined ps-inline as a PS macro in addition to a CL macro.

Fixed bug where expressions could not be applied correctly (ex - ((or a b) c) did not compile to "(a||b)(c)").

Modified the Parenscript macro facilities so that defpsmacro and
define-ps-symbol-macro define their macros in their lexical
environment (previously they were always defining in the null lexical
environment).

This cleared up the implementation of the macro facilities, and now
defmacro and define-symbol-macro explicitly define macros in the null
lexical environment inside Parenscript code (the behavior is unchanged
and the only one that makes sense since Parenscript code is translated
and not evaluated, but previously this was not obvious from looking at
the implementation).

Added Daniel Gackle and William Halliburton to the list of contributors.

Added symbol-to-js to the deprecated interface since it was used in several 3rd party libraries (despite not being exported).

Made the ps-html macros generate self-closing tags.

Made the package symbol obfuscator be able to take closures, for more interesting obfuscation possibilities (ex: using various Unicode characters).

Added convenience packages that export JS and browser DOM symbols, to be used to make package obfuscation work.

Changed the capitalization of "ParenScript" to "Parenscript" in the reference.

Modified the printer so that PS and PS-INLINE compile and print
Parenscript code at macro-expansion time. Renamed COMPILE-SCRIPT to
PS1* and got rid of its output-stream argument.

Added an implementation of 'elt' to ps-macro-lib.

Added a "runtime" directory for runtime libs and moved ps-runtime-lib there.

Fixed content handling in ps-who-html.

Added Daniel Gackle <danielgackle@gmail.com>'s contributed [] (nested) array literal macro to the macro library.

Changed extras/js-expander.el to work with the latest CVS snapshot of SLIME.

Added William Halliburton <whalliburton@gmail.com>'s tracing macro to extras folder.

Made operator precedence handling not throw away symbol package information.

This fixed a bug where for example (ps (#:new)) => ";" instead of "new();".

Added a few more unit tests related to fixes in previous patches.

Fixed compilation of caller argument lists. Changed the handling of keyword symbols in the process. Now they are no longer output as JavaScript variables, but as strings. The former behavior was a hack introduced to get around some (in hindsight) deficient macrology in an application that used Parenscript, while the latter behavior is more CL-like in that it compiles a self-evaluating object to a self-evaluating object. Thanks to Daniel Gackle for the suggestion on the treatment of keywords.

Got rid of parenscript-symbol object; special forms and macros are now
regular Common Lisp symbols so that the package system works as
expected.

Exported concat-string CL/PS utility function/macro.

Fixed unterminating recursion in who-ps-html when element has attributes but no content.

Renamed symbol-to-js to symbol-to-js-string and exported it.

Corrected reference doc to explain 'var' special form as 'global variable' instead of 'function variable.'

Implemented who-ps-html, which is like the ps-html macro but taking CL-WHO like syntax. Changed the behavior of ps-html to preserve the case of tag and attribute symbols when printing.

Added a bunch of unit tests from recent bug reports.

Overhauled operator precedence handling.

In particular the changes here cleaned up unary operator handling,
which was badly broken.

Corrected the defaultf psmacro for cases where the rhs value is false in JS.

This affected &optional and &key default parameters in lambda lists.

Thanks to Daniel Gackle for the bug report.

Revise slot-value fix to not print useless parens.

Now prints: "foo.bar.baz" rather than "(foo.bar).baz"

js-slot-value printer now handles generic operators passed as the object.

(slot-value (or a b c) 'd) now works correctly.

Updated js-aref for expression-precedence fixes.

Updated operator-precedence to handle more cases.

It now correctly deals with aref, slot-value and unary operators.

Reordered expression-precedence clauses to match precedence.

Fixed AREF when an expression is passed as the array.

(aref (or a b c) 0) now works.

Thanks to Daniel Gackle for the bug report.

Compile anything that follows a unary JS operator as an expression.

Thanks to: Daniel Gackle <danielgackle@gmail.com>

Improved handling of quoted symbols in CASE.

(case val ('a (b)))      ; now produces an error, just like:
(case val (('a 'b) (c))) ; did before.

Thanks to: Daniel Gackle <danielgackle@gmail.com>

Corrected the definition of ps:length.

Thanks to Daniel Gackle for pointing out the problem and the most
obvious solution.

Added a test for correct output of the JS:in operator.

Output JS operators in lowercase.

Updated so as to ps-intern fewer extraneous symbols.

Deprecated define-script-symbol-macro since it was part of the public interface.

Updated the define-script-symbol-macro export to define-ps-symbol-macro.

Reorganized the package exports.

Corrected parameter docstring.

Moved the definition of ps-convert-op-name since we compile compile.lisp before printer.lisp.

Added some symbol mangling fixes.

Fixed one remaining define-script-symbol-macro.

Introduced ps-symbols and removed use of :parenscript-special-forms package.

The idea here is to stop abusing the CL package system while still
allowing the user control of the PS environment.

Whitespace fix.

Changed script-* to ps-* across the board for consistency.

Quoted parens in a docstring to make Emacs happy.