Made lambda/flet/labels/defun share code for compiling their bodies, which should eliminate a lot of bugs.

Added support for case-sensitive symbols via readtable-case :invert (thanks to Matthias Benkard for the idea)

Moved PS-specific exported macros and special forms to their own file (easier to keep track of them to provide CL equivalent implementations, and for future deprecation)

Ripoll's recommendations (see
http://tream.dreamhosters.com/tream/musings/49-lisp/76-analysis-of-existing-asdf-files)

macro-expansion take place. This gives control of macroexpansion to
special forms, and lets Parenscript do things like fake being a Lisp2
(different function and variable namespaces), and overall makes
Parenscript compilation look a lot more like CL compilation.

correct scoping semantics, and simplifies both the producing and the
produced code.

Removed the "." and "[]" name-mangling conventions from
symbol-to-js-string. Any code that uses symbols such as "foo.bar[baz]"
will now issue a warning, and needs to be rewritten to use standard
Lisp accessors. This is needed for variable renaming to work, and is
an extension of the patch that eliminated the ".method" method-calling
convention.

Thanks to Daniel Gackle and Dough Hoyte for opening my eyes to this
technique, which was right in front of me all along.

to control which version of JavaScript Parenscript is emitting code
for. This can be used to emit shorter code for certain constructs
(this patch uses this facility to generate shorter keyword-handling
code for JS version 1.6 and later).

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

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

Moved code from js/ps-macrology.lisp to special-forms.lisp; straightened out parenscript.asd to use serial file dependencies; unexported defaultf; rewrote rebind as lexical-let and exported it.

Thanks to: Kevin Layer <layer@known.net>

see the new paren-asdf.lisp and updated compilation-interface.lisp
files for implementation details.  The function COMPILE-SCRIPT-SYSTEM
compiles all the system's files and outputs them to a single stream.
Currently it compiles each file separately; in the future we will
probably need to compile the whole program and then translate it.

The package system is now fairly usable.  package.lisp and
builtin-packages.lisp now intelligently share symbols.  It is also
possible to completely ignore any package system functionality.

Changed the names of many functions and macros to get rid of the
symbols with "js" in them--its not Javascript, it's Parenscript!  Most
of those symbols were renamed with "script" replacing "js".

Also changed the main compilation interfaces to use the function
COMPILE-SCRIPT and the macro SCRIPT from JS-COMPILE and JS
respectively.

Additionally, the first steps of the package system are included (with
the addition of a the SCRIPT-PACKAGE and COMPILATION-ENVIRONMENT
classes).  These are integrated into the current compiler, though they
probably break a few "traditional" serialization methods, specifically
because macro and special form names are stored as symbols rather than
strings and EQL comparisons are used rather than STRING-EQUAL
comparisons of the strings.

I have also split parser.lisp into parser.lisp and macrology.lisp.
Parser.lisp contains mechanisms for parsing Parenscript given an input
s-expression while macrology.lisp contains language definitions that
make use of the parsing mechanisms.

All tests now pass, though the documentation has gone slightly out of
date with the symbol renaming.  This will be fixed shortly.  More
tests and functionality need to be added to make the current
Parenscript compatable with the older semantics (as dicussed,
comparing macro/special form names based on their string values is the
main thing).

Signed-off-by: Vladimir Sedach <vsedach@gmail.com>

Broke the js.lisp file up into several three files: source-model.lisp,
js-translation.lisp, and parser.lisp.

source-model.lisp: class definitions that correspond to the Javascript
AST.  (defjsclass forms for the most part)

js-translation.lisp: functions for converting AST objects to
Javascript source code

parser.lisp: macro definitions and the mechanisms for processing
Parenscript forms into AST objects.

See also: http://common-lisp.net/pipermail/parenscript-devel/2007-June/000035.html