Common Lisp Package: PARENSCRIPT

README:

FUNCTION

Public

* (&REST NUMBERS)

Return the product of its arguments. With no args, returns 1.

+ (&REST NUMBERS)

Return the sum of its arguments. With no args, returns 0.

- (NUMBER &REST MORE-NUMBERS)

Subtract the second and all subsequent arguments from the first; or with one argument, negate the first argument.

/ (NUMBER &REST MORE-NUMBERS)

Divide the first argument by each of the following arguments, in turn. With one argument, return reciprocal.

1+ (NUMBER)

Return NUMBER + 1.

1- (NUMBER)

Return NUMBER - 1.

< (NUMBER &REST MORE-NUMBERS)

Return T if its arguments are in strictly increasing order, NIL otherwise.

<= (NUMBER &REST MORE-NUMBERS)

Return T if arguments are in strictly non-decreasing order, NIL otherwise.

= (NUMBER &REST MORE-NUMBERS)

Return T if all of its arguments are numerically equal, NIL otherwise.

> (NUMBER &REST MORE-NUMBERS)

Return T if its arguments are in strictly decreasing order, NIL otherwise.

>= (NUMBER &REST MORE-NUMBERS)

Return T if arguments are in strictly non-increasing order, NIL otherwise.

ABS (NUMBER)

Return the absolute value of the number.

ACOS (NUMBER)

Return the arc cosine of NUMBER.

ACOSH (NUMBER)

Return the hyperbolic arc cosine of NUMBER.

APPEND (&REST LISTS)

Construct a new list by concatenating the list arguments

APPLY (FUNCTION ARG &REST ARGUMENTS)

Apply FUNCTION to a list of arguments produced by evaluating ARGUMENTS in the manner of LIST*. That is, a list is made of the values of all but the last argument, appended to the value of the last argument, which must be a list.

AREF (ARRAY &REST SUBSCRIPTS)

Return the element of the ARRAY specified by the SUBSCRIPTS.

ASH (INTEGER COUNT)

Shifts integer left by count places preserving sign. - count shifts right.

ASIN (NUMBER)

Return the arc sine of NUMBER.

ASINH (NUMBER)

Return the hyperbolic arc sine of NUMBER.

ATAN (Y &OPTIONAL (X NIL XP))

Return the arc tangent of Y if X is omitted or Y/X if X is supplied.

ATANH (NUMBER)

Return the hyperbolic arc tangent of NUMBER.

BREAK (&OPTIONAL (DATUM break) &REST ARGUMENTS)

Print a message and invoke the debugger without allowing any possibility of condition handling occurring.

CEILING (NUMBER &OPTIONAL (DIVISOR 1))

Return the smallest integer not less than number, or number/divisor. The second returned value is the remainder.

COMPILE-SCRIPT (PS-FORM &KEY (OUTPUT-STREAM NIL))

Compiles the Parenscript form PS-FORM into Javascript. If OUTPUT-STREAM is NIL, then the result is a string; otherwise code is output to the OUTPUT-STREAM stream.

CONCATENATE (OUTPUT-TYPE-SPEC &REST SEQUENCES)

Return a new sequence of all the argument sequences concatenated together which shares no structure with the original argument sequences of the specified OUTPUT-TYPE-SPEC.

CONTINUE (&OPTIONAL CONDITION)

Transfer control to a restart named CONTINUE, or return NIL if none exists.

COS (NUMBER)

Return the cosine of NUMBER.

COSH (NUMBER)

Return the hyperbolic cosine of NUMBER.

DELETE (ITEM SEQUENCE &REST ARGS &KEY FROM-END (TEST #'EQL) (TEST-NOT NIL) (START 0) (END NIL) (COUNT NIL) (KEY NIL))

Return a sequence formed by destructively removing the specified ITEM from the given SEQUENCE.

ELT (SEQUENCE INDEX)

Return the element of SEQUENCE specified by INDEX.

EQ (OBJ1 OBJ2)

Return T if OBJ1 and OBJ2 are the same object, otherwise NIL.

EQUAL (X Y)

Return T if X and Y are EQL or if they are structured components whose elements are EQUAL. Strings and bit-vectors are EQUAL if they are the same length and have identical components. Other arrays must be EQ to be EQUAL.

EVAL-WHEN (SITUATIONS &REST FORMS)

EVAL-WHEN (situation*) form* Evaluate the FORMS in the specified SITUATIONS (any of :COMPILE-TOPLEVEL, :LOAD-TOPLEVEL, or :EXECUTE, or (deprecated) COMPILE, LOAD, or EVAL).

EVENP (NUMBER)

Is this integer even?

EXP (NUMBER)

Return e raised to the power NUMBER.

EXPT (BASE POWER)

Return BASE raised to the POWER.

FLET (DEFINITIONS &BODY BODY)

FLET ({(name lambda-list declaration* form*)}*) declaration* body-form* Evaluate the BODY-FORMS with local function definitions. The bindings do not enclose the definitions; any use of NAME in the FORMS will refer to the lexically apparent function definition in the enclosing environment.

FLOOR (NUMBER &OPTIONAL (DIVISOR 1))

Return the greatest integer not greater than number, or number/divisor. The second returned value is (mod number divisor).

FUNCTIONP (OBJECT)

Return true if OBJECT is a FUNCTION, and NIL otherwise.

IF (TEST THEN &OPTIONAL ELSE)

IF predicate then [else] If PREDICATE evaluates to true, evaluate THEN and return its values, otherwise evaluate ELSE and return its values. ELSE defaults to NIL.

IMPORT-MACROS-FROM-LISP (&REST NAMES)

Import the named Lisp macros into the Parenscript macro environment. When the imported macro is macroexpanded by Parenscript, it is first fully macroexpanded in the Lisp macro environment, and then that expansion is further expanded by Parenscript.

LABELS (DEFINITIONS &BODY BODY)

LABELS ({(name lambda-list declaration* form*)}*) declaration* body-form* Evaluate the BODY-FORMS with local function definitions. The bindings enclose the new definitions, so the defined functions can call themselves or each other.

LENGTH (SEQUENCE)

Return an integer that is the length of SEQUENCE.

LET (BINDINGS &BODY BODY)

LET ({(var [value]) | var}*) declaration* form* During evaluation of the FORMS, bind the VARS to the result of evaluating the VALUE forms. The variables are bound in parallel after all of the VALUES forms have been evaluated.

LET* (BINDINGS &BODY BODY)

LET* ({(var [value]) | var}*) declaration* form* Similar to LET, but the variables are bound sequentially, allowing each VALUE form to reference any of the previous VARS.

LIST (&REST ARGS)

Return constructs and returns a list of its arguments.

LOG (NUMBER &OPTIONAL (BASE NIL BASE-P))

Return the logarithm of NUMBER in the base BASE, which defaults to e.

LOGAND (&REST INTEGERS)

Return the bit-wise and of its arguments. Args must be integers.

LOGIOR (&REST INTEGERS)

Return the bit-wise or of its arguments. Args must be integers.

LOGNOT (NUMBER)

Return the bit-wise logical not of integer.

LOGXOR (&REST INTEGERS)

Return the bit-wise exclusive or of its arguments. Args must be integers.

MACROLET (DEFINITIONS &REST BODY)

MACROLET ({(name lambda-list form*)}*) body-form* Evaluate the BODY-FORMS in an environment with the specified local macros defined. NAME is the local macro name, LAMBDA-LIST is a DEFMACRO style destructuring lambda list, and the FORMS evaluate to the expansion.

MAPCAR (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive elements of LIST. Return list of FUNCTION return values.

MAX (NUMBER &REST MORE-NUMBERS)

Return the greatest of its arguments; among EQUALP greatest, return the first.

MEMBER (ITEM LIST &KEY KEY (TEST NIL TESTP) (TEST-NOT NIL NOTP))

Return the tail of LIST beginning with first element satisfying EQLity, :TEST, or :TEST-NOT with the given ITEM.

MIN (NUMBER &REST MORE-NUMBERS)

Return the least of its arguments; among EQUALP least, return the first.

NOT (OBJECT)

Return T if X is NIL, otherwise return NIL.

NUMBERP (OBJECT)

Return true if OBJECT is a NUMBER, and NIL otherwise.

ODDP (NUMBER)

Is this integer odd?

PROGN (&REST FORMS)

PROGN form* Evaluates each FORM in order, returning the values of the last form. With no forms, returns NIL.

PS* (&REST BODY)

Compiles body to a JavaScript string. If *parenscript-stream* is bound, writes the output to *parenscript-stream*, otherwise returns a string.

PS-COMPILE-FILE (SOURCE-FILE &KEY (ELEMENT-TYPE 'CHARACTER) (EXTERNAL-FORMAT DEFAULT))

Opens file as input stream and calls ps-compile-stream on it.

PS-COMPILE-STREAM (STREAM)

Reads (using the value of *ps-read-function*, #'read by default, as the read function) Parenscript forms from stream and compiles them as if by ps*. If *parenscript-stream* is bound, writes the output to *parenscript-stream*, otherwise and returns a string.

REM (NUMBER DIVISOR)

Return second result of TRUNCATE.

RETURN-FROM (NAME &OPTIONAL VALUE)

RETURN-FROM block-name value-form Evaluate the VALUE-FORM, returning its values from the lexically enclosing block BLOCK-NAME. This is constrained to be used only within the dynamic extent of the block.

ROUND (NUMBER &OPTIONAL (DIVISOR 1))

Rounds number (or number/divisor) to nearest integer. The second returned value is the remainder.

SET-DIFFERENCE (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Return the elements of LIST1 which are not in LIST2.

SIN (NUMBER)

Return the sine of NUMBER.

SINH (NUMBER)

Return the hyperbolic sine of NUMBER.

SQRT (NUMBER)

Return the square root of NUMBER.

STRINGIFY (&REST THINGS)

Like concatenate but prints all of its arguments.

STRINGP (OBJECT)

Return true if OBJECT is a STRING, and NIL otherwise.

SYMBOL-MACROLET (MACROBINDINGS &BODY BODY)

SYMBOL-MACROLET ({(name expansion)}*) decl* form* Define the NAMES as symbol macros with the given EXPANSIONS. Within the body, references to a NAME will effectively be replaced with the EXPANSION.

TAN (NUMBER)

Return the tangent of NUMBER.

TANH (NUMBER)

Return the hyperbolic tangent of NUMBER.

THROW (TAG RESULT)

THROW tag form Do a non-local exit, return the values of FORM from the CATCH whose tag is EQ to TAG.

USE-PACKAGE (PACKAGES-TO-USE &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Add all the PACKAGES-TO-USE to the use list for PACKAGE so that the external symbols of the used packages are accessible as internal symbols in PACKAGE.

Undocumented

SETFAREF (NEW-VALUE ARRAY &REST SUBSCRIPTS)

CONCAT-STRING (&REST THINGS)

SETFELT (G69 G70 G71)

EQL (X Y)

FOR-IN (PLACE STATE)

GEN-JS-NAME (&OPTIONAL (PREFIX _JS_))

JS* (&REST ARGS)

JS-COMPILE (FORM)

JS-INLINE* (&REST BODY)

LISP (X)

MAKE-ARRAY (DIMENSIONS &KEY (ELEMENT-TYPE T) (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (INITIAL-CONTENTS NIL INITIAL-CONTENTS-P) ADJUSTABLE FILL-POINTER DISPLACED-TO DISPLACED-INDEX-OFFSET)

MAP (RESULT-TYPE FUNCTION FIRST-SEQUENCE &REST MORE-SEQUENCES)

MAP-INTO (RESULT-SEQUENCE FUNCTION &REST SEQUENCES)

OBFUSCATE-PACKAGE (PACKAGE-DESIGNATOR &OPTIONAL (SYMBOL-MAP (LET ((SYMBOL-TABLE (MAKE-HASH-TABLE))) (LAMBDA (SYMBOL) (OR (GETHASH SYMBOL SYMBOL-TABLE) (SETF (GETHASH SYMBOL SYMBOL-TABLE) (PS-GENSYM G)))))))

PS-DOC* (&REST BODY)

PS-GENSYM (&OPTIONAL (PREFIX-OR-COUNTER _JS))

PS-INLINE* (FORM &OPTIONAL (*JS-STRING-DELIMITER* *JS-INLINE-STRING-DELIMITER*))

RANDOM (ARG &OPTIONAL (STATE *RANDOM-STATE*))

SETQ (&WHOLE SOURCE &REST THINGS)

SLOT-VALUE (OBJECT SLOT-NAME)

SYMBOL-TO-JS (SYMBOL)

SYMBOL-TO-JS-STRING (SYMBOL &OPTIONAL (MANGLE-SYMBOL-NAME? T))

UNOBFUSCATE-PACKAGE (PACKAGE-DESIGNATOR)

Private

ADJUST-COMPILATION-LEVEL (FORM LEVEL)

Given the current *compilation-level*, LEVEL, and the fully macroexpanded form, FORM, returns the new value for *compilation-level*.

ENCODE-JS-IDENTIFIER (IDENTIFIER)

Given a string, produces to a valid JavaScript identifier by following transformation heuristics case conversion. For example, paren-script becomes parenScript, *some-global* becomes SOMEGLOBAL.

MAKE-PS-MACRO-FUNCTION (ARGS BODY)

Given the arguments and body to a parenscript macro, returns a function that may be called on the entire parenscript form and outputs some parenscript code. Returns a second value that is the effective lambda list from a Parenscript perspective.

ORDERED-SET-DIFFERENCE (LIST1 LIST2 &KEY (TEST #'EQL))

CL set-difference may not preserve order.

PARSE-EXTENDED-FUNCTION (LAMBDA-LIST BODY)

The lambda list is transformed as follows: * standard and optional variables are the mapped directly into the js-lambda list * keyword variables are not included in the js-lambda list, but instead are obtained from the magic js ARGUMENTS pseudo-array. Code assigning values to keyword vars is prepended to the body of the function.

PARSE-KEY-SPEC (KEY-SPEC)

parses an &key parameter. Returns 5 values: var, init-form, keyword-name, supplied-p-var, init-form-supplied-p. Syntax of key spec: [&key {var | ({var | (keyword-name var)} [init-form [supplied-p-parameter]])}*

PARSE-OPTIONAL-SPEC (SPEC)

Parses an &optional parameter. Returns 3 values: var, init-form, supplied-p-var. [&optional {var | (var [init-form [supplied-p-parameter]])}*]

TRY-EXPRESSIONIZING-IF? (EXP &OPTIONAL (SCORE 0))

Heuristic that tries not to expressionize deeply nested if expressions.

Undocumented

A-WITH-CLAUSE (STATE)

ACCUMULATE (KIND ITEM VAR STATE)

AS-KEYWORD (KEY)

ASSERT-IS-ONE-OF (VAL OPTIONS)

ASSIGNMENT-OP (OP)

ASSOCIATIVE? (OP)

AUGMENTED-LOOP-BODY (BODY CLAUSES FIRSTVAR)

BODY-CLAUSE (TERM STATE)

BUILD-LOOP (ITERATIONS BODY)

CHECK-SETQ-ARGS (ARGS)

CLAUSE (STATE)

COLLAPSE-FUNCTION-RETURN-BLOCKS (BODY)

COLLECT-FUNCTION-NAMES (FN-DEFS)

COLLECT-LIST-EXPANDER (N-VALUE N-TAIL FORMS)

COMPILE-EXPRESSION (FORM)

COMPILE-FUNCTION-BODY (ARGS BODY)

COMPILE-LOCAL-FUNCTION-BODY (FN-DEFS RENAMES)

COMPILE-LOOP-BODY (LOOP-VARS BODY)

COMPILE-NAMED-FUNCTION-BODY (NAME LAMBDA-LIST BODY)

COMPILE-NAMED-LOCAL-FUNCTION (NAME ARGS BODY)

COMPILE-PROGN (BODY)

COMPILE-SPECIAL-FORM (FORM)

COMPILE-STATEMENT (FORM)

COMPLEX-JS-EXPR? (EXPR)

CONCAT-CONSTANT-STRINGS (STR-LIST)

DEFINED-OPERATOR-OVERRIDE-CHECK (NAME &REST BODY)

DESTRUCTURING-WRAP (ARR N BINDINGS BODY)

DO-MAKE-FOR-STEPS (DECLS)

DO-MAKE-FOR-VARS/INIT (DECLS)

DO-MAKE-INIT-VALS (DECLS)

DO-MAKE-INIT-VARS (DECLS)

DO-MAKE-ITER-PSTEPS (DECLS)

DO-MAKE-LET-BINDINGS (DECLS)

DOT->REST (X)

EAT (STATE &OPTIONAL WHAT TAG)

EMPTY-TAG-P (TAG)

ERR (EXPECTED GOT)

EXPRESSIONIZE-RESULT (TAG FORM)

EXTRACT-BINDINGS (X)

FILL-MV-REG (VALUES)

FIX-NARY-COMPARISON (OPERATOR OBJECTS)

FLATTEN (X &OPTIONAL ACC)

FLATTEN-BLOCKS (BODY)

FOLD-TESTS (ITERATIONS)

FOR-= (PLACE STATE)

FOR-CLAUSE (STATE)

FOR-FROM (VAR STATE)

FOR-KEYS-OF (PLACE STATE)

FOR-ON (PLACE STATE)

HOIST-EXPR? (BINDINGS EXPR)

JS-COMPILE-LIST (FORM)

JS-EQUAL (PS-FORM1 PS-FORM2)

LOOKUP-MACRO-DEF (NAME ENV)

MAKE-FOR-VARS/INITS (INIT-FORMS)

MAKE-MACRO-DICTIONARY

MASTER-LOOP (MASTER BODY)

MAYBE-EXTRACT-VAR (EXPR STATE)

MAYBE-OBFUSCATE-SYMBOL (SYMBOL)

MAYBE-RENAME-LEXICAL-VAR (X SYMBOLS-IN-BINDINGS)

MAYBE-RENAME-LOCAL-FUNCTION (FUN-NAME)

NEWLINE-AND-INDENT (&OPTIONAL INDENT-SPACES)

NORMALIZE (ITERATIONS)

PARENSCRIPT-PRINT (FORM IMMEDIATE?)

PARENTHESIZE-AT-TOPLEVEL (X)

PARENTHESIZE-PRINT (X)

PARSE-LAMBDA-LIST (LAMBDA-LIST)

PARSE-LAMBDA-LIST-LIKE-THING (LIST)

PARSE-PS-LOOP (TERMS)

PEEK (STATE)

PRECEDENCE (OP)

PROCESS-HTML-FORMS-CL-WHO (FORMS)

PROCESS-HTML-FORMS-LHTML (FORMS)

PROLOGUE-WRAP (PROLOGUE BODY)

PROPERTY-BINDINGS (BINDINGS EXPR BODY)

PROPERTY-BINDINGS-P (X)

PS-COMPILE (FORM)

PS-MACROEXPAND (FORM)

PS-MACROEXPAND-1 (FORM)

PSW (&REST OBJS)

PUSH-TOKENS (STATE TOKS)

RE-EXPORT-SYMBOLS (FROM-PACKAGE TO-PACKAGE)

REFERENCES? (EXP PLACE)

REPEAT-CLAUSE (STATE)

RESERVED-SYMBOL-P (SYMBOL)

RETURN-EXP (TAG &OPTIONAL (VALUE NIL VALUE?) REST-VALUES)

SPECIAL-FORM? (FORM)

SPECIAL-VARIABLE? (SYM)

STYLE-WARN (&REST ARGS)

UNTIL-CLAUSE (STATE)

WARN-DEPRECATED (OLD-NAME &OPTIONAL NEW-NAME)

WHILE-CLAUSE (STATE)

WITH-LAMBDA-SCOPE (BODY)

WRAP-FOR-DYNAMIC-RETURN (HANDLED-TAGS BODY)

MACRO

Public

CASE (KEYFORM &BODY CASES)

CASE Keyform {({(Key*) | Key} Form*)}* Evaluates the Forms in the first clause with a Key EQL to the value of Keyform. If a singleton key is T then the clause is a default clause.

DECF (PLACE &OPTIONAL (DELTA 1) &ENVIRONMENT ENV)

The first argument is some location holding a number. This number is decremented by the second argument, DELTA, which defaults to 1.

DEFMACRO+PS (NAME ARGS &BODY BODY)

Define a Lisp macro and a Parenscript macro with the same macro function (ie - the same result from macroexpand-1), for cases when the two have different full macroexpansions (for example if the CL macro contains implementation-specific code when macroexpanded fully in the CL environment).

DEFSETF (ACCESS-FN &REST REST)

Associates a SETF update function or macro with the specified access function or macro. The format is complex. See the manual for details.

DEFUN (&ENVIRONMENT ENV NAME ARGS &BODY BODY)

Define a function at top level.

DEFVAR (VAR &OPTIONAL (VAL NIL VALP) (DOC NIL DOCP))

Define a special variable at top level. Declare the variable SPECIAL and, optionally, initialize it. If the variable already has a value, the old value is not clobbered. The third argument is an optional documentation string for the variable.

DESTRUCTURING-BIND (LAMBDA-LIST EXPRESSION &BODY BODY)

Bind the variables in LAMBDA-LIST to the corresponding values in the tree structure resulting from the evaluation of EXPRESSION.

DO (VARLIST ENDLIST &BODY BODY)

DO ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* Iteration construct. Each Var is initialized in parallel to the value of the specified Init form. On subsequent iterations, the Vars are assigned the value of the Step form (if any) in parallel. The Test is evaluated before each evaluation of the body Forms. When the Test is true, the Exit-Forms are evaluated as a PROGN, with the result being the value of the DO. A block named NIL is established around the entire expansion, allowing RETURN to be used as an alternate exit mechanism.

DO* (VARLIST ENDLIST &BODY BODY)

DO* ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* Iteration construct. Each Var is initialized sequentially (like LET*) to the value of the specified Init form. On subsequent iterations, the Vars are sequentially assigned the value of the Step form (if any). The Test is evaluated before each evaluation of the body Forms. When the Test is true, the Exit-Forms are evaluated as a PROGN, with the result being the value of the DO. A block named NIL is established around the entire expansion, allowing RETURN to be used as an laternate exit mechanism.

IGNORE-ERRORS (&REST FORMS)

Execute FORMS handling ERROR conditions, returning the result of the last form, or (VALUES NIL the-ERROR-that-was-caught) if an ERROR was handled.

INCF (PLACE &OPTIONAL (DELTA 1) &ENVIRONMENT ENV)

The first argument is some location holding a number. This number is incremented by the second argument, DELTA, which defaults to 1.

PS (&BODY BODY)

Given Parenscript forms (an implicit progn), compiles those forms to a JavaScript string at macro-expansion time. Expands into a form which evaluates to a string.

PS-DOC (&BODY BODY)

Expands Parenscript forms in a clean environment.

PS-TO-STREAM (STREAM &BODY BODY)

Given Parenscript forms (an implicit progn), compiles those forms to a JavaScript string at macro-expansion time. Expands into a form which writes the resulting code to stream.

PSETF (&REST ARGS &ENVIRONMENT ENV)

This is to SETF as PSETQ is to SETQ. Args are alternating place expressions and values to go into those places. All of the subforms and values are determined, left to right, and only then are the locations updated. Returns NIL.

PSETQ (&REST PAIRS)

PSETQ {var value}* Set the variables to the values, like SETQ, except that assignments happen in parallel, i.e. no assignments take place until all the forms have been evaluated.

SETF (&REST ARGS &ENVIRONMENT ENV)

Takes pairs of arguments like SETQ. The first is a place and the second is the value that is supposed to go into that place. Returns the last value. The place argument may be any of the access forms for which SETF knows a corresponding setting form.

UNLESS (TEST &BODY FORMS)

If the first argument is not true, the rest of the forms are evaluated as a PROGN.

WHEN (TEST &BODY FORMS)

If the first argument is true, the rest of the forms are evaluated as a PROGN.

WITH-PS-GENSYMS (SYMBOLS &BODY BODY)

Each element of SYMBOLS is either a symbol or a list of (symbol gensym-prefix-string).

Undocumented

AND (&REST FORMS)

DEFINE-PS-SYMBOL-MACRO (SYMBOL EXPANSION)

DEFINE-SCRIPT-SYMBOL-MACRO (NAME &BODY BODY)

DEFINE-SYMBOL-MACRO (NAME EXPANSION)

DEFJSMACRO (&REST ARGS)

DEFMACRO (NAME LAMBDA-LIST &REST BODY)

DEFMACRO/PS (NAME ARGS &BODY BODY)

DEFPSMACRO (NAME ARGS &BODY BODY)

DOLIST ((VAR LIST &OPTIONAL (RESULT NIL)) &BODY BODY &ENVIRONMENT ENV)

DOTIMES ((VAR COUNT &OPTIONAL (RESULT NIL)) &BODY BODY)

IN-PACKAGE (STRING-DESIGNATOR)

JS (&REST ARGS)

JS-INLINE (&REST BODY)

LAMBDA (&WHOLE WHOLE ARGS &BODY BODY)

LOOP (&ENVIRONMENT ENV &REST KEYWORDS-AND-FORMS)

OR (&REST FORMS)

PS-HTML (&REST HTML-FORMS)

PS-INLINE (FORM &OPTIONAL (STRING-DELIMITER *JS-INLINE-STRING-DELIMITER*))

PS-ONCE-ONLY ((&REST VARS) &BODY BODY)

PS-PACKAGE-PREFIX (PACKAGE)

RETURN (&OPTIONAL (VALUE NIL))

VAR (NAME &OPTIONAL VALUE DOCSTR)

WHILE (TEST &BODY BODY)

WHO-PS-HTML (&REST HTML-FORMS)

WITH-SLOTS (SLOTS INSTANCE &BODY BODY)

WITH-UNIQUE-JS-NAMES (&REST ARGS)

Private

Undocumented

%DEFINE-SPECIAL-OPERATOR (TYPE NAME LAMBDA-LIST &BODY BODY)

COLLECT (COLLECTIONS &BODY BODY)

DEF-JS-MATHS (&REST MATHDEFS)

DEFINE-EXPRESSION-OPERATOR (NAME LAMBDA-LIST &BODY BODY)

DEFINE-STATEMENT-OPERATOR (NAME LAMBDA-LIST &BODY BODY)

DEFINE-TRIVIAL-SPECIAL-OPS (&REST MAPPINGS)

DEFPRINTER (JS-PRIMITIVE ARGS &BODY BODY)

DEFPSMACRO-DEPRECATED (OLD NEW)

DEFUN-JS (OLD-NAME NEW-NAME ARGS &BODY BODY)

INC-DEC (OP OP1 OP2)

LOCAL-FUNCTIONS (SPECIAL-OP &BODY BINDINGS)

LOOP-CASE (KEY &BODY FORMS)

ONCE-ONLY ((&REST NAMES) &BODY BODY)

WITH-BLANK-COMPILATION-ENVIRONMENT (&BODY BODY)

WITH-DECLARATION-EFFECTS ((VAR BLOCK) &BODY BODY)

WITH-LOCAL-MACRO-ENVIRONMENT ((VAR ENV) &BODY BODY)

GENERIC-FUNCTION

Private

Undocumented

ERROR-FORM (CONDITION)

PS-PRINT (FORM)

PS-PRINT% (JS-PRIMITIVE ARGS)

SLOT-ACCESSOR

Private

Undocumented

BODY (OBJECT)

SETFBODY (NEW-VALUE OBJECT)

FINALLY (OBJECT)

SETFFINALLY (NEW-VALUE OBJECT)

IMPLICIT-ACCUM-KIND (OBJECT)

SETFIMPLICIT-ACCUM-KIND (NEW-VALUE OBJECT)

IMPLICIT-ACCUM-VAR (OBJECT)

SETFIMPLICIT-ACCUM-VAR (NEW-VALUE OBJECT)

ITERATIONS (OBJECT)

SETFITERATIONS (NEW-VALUE OBJECT)

NAME (OBJECT)

SETFNAME (NEW-VALUE OBJECT)

PROLOGUE (OBJECT)

SETFPROLOGUE (NEW-VALUE OBJECT)

TOKENS (OBJECT)

SETFTOKENS (NEW-VALUE OBJECT)

VARIABLE

Public

* (&REST NUMBERS)

the value of the most recent top level EVAL

*DEFINED-OPERATORS*

Special operators and macros defined by Parenscript. Replace at your own risk!

*JS-INLINE-STRING-DELIMITER*

Controls the string delimiter char used when compiling Parenscript in ps-inline.

*JS-STRING-DELIMITER*

Specifies which character should be used for delimiting strings. This variable is used when you want to embed the resulting JavaScript in an html attribute delimited by #\" as opposed to #\', or vice-versa.

*PS-HTML-MODE*

One of :sgml or :xml

*VERSION*

Parenscript compiler version.

+ (&REST NUMBERS)

the value of the most recent top level READ

- (NUMBER &REST MORE-NUMBERS)

the form currently being evaluated

/ (NUMBER &REST MORE-NUMBERS)

a list of all the values returned by the most recent top level EVAL

Undocumented

*INDENT-NUM-SPACES*

*JS-TARGET-VERSION*

*PARENSCRIPT-STREAM*

*PS-GENSYM-COUNTER*

*PS-HTML-EMPTY-TAG-AWARE-P*

*PS-LISP-LIBRARY*

*PS-PRINT-PRETTY*

*PS-READ-FUNCTION*

FALSE

Private

%COMPILING-RESERVED-FORMS-P%

Used to issue warnings when replacing PS special operators or macros.

*COMPILATION-LEVEL*

This value takes on the following values: :toplevel indicates that we are traversing toplevel forms. :inside-toplevel-form indicates that we are inside a call to ps-compile-* nil indicates we are no longer toplevel-related.

*CURRENT-BLOCK-TAG*

Name of the lexically enclosing block, if any.

*DYNAMIC-RETURN-TAGS*

Tags that need to be thrown to to reach.

*ENCLOSING-FUNCTION-ARGUMENTS*

Lexical variables bound in all lexically enclosing function argument lists.

*ENCLOSING-LEXICALS*

All enclosing lexical variables (includes function names).

*FUNCTION-BLOCK-NAMES*

All block names that this function is responsible for catching.

*FUNCTION-LAMBDA-LIST*

Table of lambda lists for defined functions.

*LOCAL-FUNCTION-NAMES*

Functions named by flet and label.

*LOOP-RETURN-SET-VAR*

Variable which is set by RETURN-FROM when it returns a value from inside a loop. The value is the name of a PS variable which dynamically indicates if the return statement indeed has been invoked.

*LOOP-RETURN-VAR*

Variable which is used to return values from inside loop bodies.

*MACRO-ENV*

Current macro environment.

*MACRO-TOPLEVEL*

Toplevel macro environment dictionary.

*MACRO-TOPLEVEL-LAMBDA-LIST*

Table of lambda lists for toplevel macros.

*SETF-EXPANDERS*

Setf expander dictionary. Key is the symbol of the access function of the place, value is an expansion function that takes the arguments of the access functions as a first value and the form to be stored as the second value.

*SPECIAL-VARIABLES*

Special variables declared during any Parenscript run. Re-bind this if you want to clear the list.

*VARS-NEEDING-TO-BE-DECLARED*

This special variable is expected to be bound to a fresh list by special forms that introduce a new JavaScript lexical block (currently function definitions and lambdas). Enclosed special forms are expected to push variable declarations onto the list when the variables declaration cannot be made by the enclosed form (for example, a x,y,z expression progn). It is then the responsibility of the enclosing special form to introduce the variable declarations in its lexical block.

IN-CASE?

Bind to T when compiling CASE branches.

IN-FUNCTION-SCOPE?

Lets the compiler know when lambda wrapping is necessary.

IN-LOOP-SCOPE?

Used for seeing when we're in loops, so that we can introduce proper scoping for lambdas closing over loop-bound variables (otherwise they all share the same binding).

Undocumented

%EQUALITY-OPS

*DEFUN-SETF-NAME-PREFIX*

*HTML-EMPTY-TAGS*

*JS-LISP-ESCAPED-CHARS*

*LAMBDA-LIST-KEYWORDS*

*LAMBDA-WRAPPABLE-STATEMENTS*

*LOOP-KEYWORDS*

*OBFUSCATED-PACKAGES*

*PACKAGE-PREFIX-TABLE*

*RESERVED-SYMBOL-NAMES*

*SPECIAL-EXPRESSION-OPERATORS*

*SPECIAL-STATEMENT-OPERATORS*

*SYMBOL-MACRO-ENV*

*SYMBOL-MACRO-TOPLEVEL*

CLASS

Public

Undocumented

ARRAY

LIST (&REST ARGS)

T

Private

Undocumented

LOOP-STATE

CONDITION

Private

Undocumented

COMPILE-EXPRESSION-ERROR

SIMPLE-STYLE-WARNING

CONSTANT

Public

Undocumented

PI

T