Common Lisp Package: JWACS

README:

FUNCTION

Public

BUILD-APP (MAIN-MODULE-PATH &KEY DEBUG-MODE (COMPRESS-MODE (NOT DEBUG-MODE)) (COMBINE-MODE (NOT DEBUG-MODE)) TEMPLATE-URIPATH OUTPUT-URIPATH PREFIX-LOOKUP (RUNTIME-URIPATH (IF DEBUG-MODE jw-debug-runtime.js jw-rt.js)) INLINE-OUTPUT-STREAM INLINE-MAIN-TEXT)

Build a wrapper html file for a jwacs application. COMBINE-MODE is forced to T if an INLINE-OUTPUT-STREAM is provided.

PARSE (STR)

Parse STR as a Javascript script, returning a list of statements. Semicolon insertion is performed according to the ECMA-262 standard.

Undocumented

PROCESS (IN-PATH)

Private

ABSOLUTE-URIPATH-P (URIPATH)

Predicate for checking if a URIPATH is specified from the root rather than relative to the current tree position.

ADD-ASSIGNMENT-EDGE (LEFT-NODE RIGHT-NODE &OPTIONAL QUEUE)

Add an assignment edge from LEFT-NODE to RIGHT-NODE if no such edge already exists. If QUEUE is non-NIL, queues LEFT-NODE for further processing.

ADD-BINDING (VAR-NAME VAR-NEWNAME)

Add a binding to the environment. In our case, name and new name

ADD-HANDLER-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ADD-HANDLER-HANDLER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ADD-HANDLER-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ADD-HANDLER-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ADD-HANDLER-THUNK-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ANONYMOUS-NODE-P (NODE)

Return T if NODE is an 'anonymous' node (ie, one whose name is an uninterned symbol).

APPEND-MODULE (SRC-MODULE TARGET-MODULE)

Appends the contents of SRC-MODULE to the end of TARGET-MODULE, creating TARGET-MODULE if necessary. If TARGET-MODULE is compressed and SRC-MODULE is not, then SRC-MODULE's text will be compressed before being added to TARGET-MODULE.

ARRAY-LITERAL-ELEMENTS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ARRAY-LITERAL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ARRAY-LITERAL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ARRAY-LITERAL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ASSIGNMENT-OPERATOR-P (ELM)

Returns non-NIL if ELM represents an operation with an assignment side-effect

BACKCHANNEL-SIGNAL (CHANNEL VALUE)

Signals VALUE on backchannel CHANNEL. Returns T if the message was received.

BINARY-OPERATOR-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BINARY-OPERATOR-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BINARY-OPERATOR-LEFT-ARG (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BINARY-OPERATOR-OP-SYMBOL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BINARY-OPERATOR-RIGHT-ARG (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BINARY-OPERATOR-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BOOLEAN-ARG (NAME VAL)

Converts an argument to a boolean option to a boolean value

BREAK-STATEMENT-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BREAK-STATEMENT-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BREAK-STATEMENT-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BREAK-STATEMENT-TARGET-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CALL-EXPRESSION-P (ELM)

Return non-NIL if ELM is a CallExpression, or NIL otherwise.

CASE-CLAUSE-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CASE-CLAUSE-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CASE-CLAUSE-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CASE-CLAUSE-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CASE-CLAUSE-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CATCH-CLAUSE-BINDING (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CATCH-CLAUSE-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CATCH-CLAUSE-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CATCH-CLAUSE-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CATCH-CLAUSE-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CHANGE-URIPATH-EXTENSION (URIPATH NEW-EXTENSION)

Converts URIPATH to a URIPATH that points to a different type of file. Eg, (CHANGE-URIPATH-EXTENSION "/common/lib.jw" "js") ==> "/common/lib.js"

COERCE-TOKEN (LEXER TERMINAL)

Force LEXER to interpret the next token as TERMINAL. An error will be raised if that's not actually possible.

COLLAPSE-TYPE-GRAPH (GRAPH)

Adds an edge from each location-node in GRAPH to each value-node that it has a path to, and removes all other assignment edges. Removes all 'dotted' edges (ie, args, ret, and props) from location-nodes; only value-nodes will have dotted edges after this processing is done.

COMBINE-STATEMENTS (&REST ELM-ARGUMENTS)

Combine ELM-ARGUMENTS into a single list, stripping out statement-blocks if necessary

COMMA-EXPR-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COMMA-EXPR-EXPRS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COMMA-EXPR-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COMMA-EXPR-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COMMAND-LINE-ARGUMENTS

return a list of the command-line arguments

COMPUTE-FIELD-NAME (FIELD-ELM)

Return the name of a property. For properties specified by literals, this is the name of the property; for all other field names (ie, for identifiers or other expressions) this will be the special field-name 'ANY.

COMPUTE-TERMINATED-CLAUSES (CLAUSE-LIST)

Takes a list of switch clauses that may or may not be terminated (eg, by a break statement), and returns a list of clauses with equivalent effects that are more suitable for cps translation. Specifically: 1) Terminated clauses are returned unchanged. A terminated clause is one which is terminated in all its control paths. 2) 'Null clauses' (ie, clauses with no body) are also returned unchanged so long as they aren't the final clause. If they are the final clause, their body is set to a single break statement. 3) Unterminated clauses have the body of each following clause appended to them (up to and including the first terminated clause). 4) If the final clause is unterminated, it will have a break statement appended to it 5) If there is no default clause, a default clause will be added to the end of the list with a body containing a single break statement. eg: case 10: doSomething(); case 20: case 30: doSomethingElse(); break; default: ===> case 10: doSomething(); doSomethingElse(); break; case 20: case 30: doSomethingElse(); break; default: break;

CONDITIONAL-CONDITION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONDITIONAL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONDITIONAL-FALSE-ARG (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONDITIONAL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONDITIONAL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONDITIONAL-TRUE-ARG (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONSUME-TOKEN (LEXER)

Reads the next token from LEXER's source text (where 'next' is determined by the value of LEXER's cursor). The cursor is assumed to point to a non-whitespace character on entry; on exit points to the first character after the consumed token. Returns a token structure. The token's terminal will be NIL on end of input

CONSUME-WHITESPACE (LEXER)

Consumes whitespace and comments. Lexer's cursor is updated to the next non-whitespace character, and its ENCOUNTERED-LINE-TERMINATOR slot is set based upon whether or not the skipped whitespace included a newline. Returns non-NIL if line-terminators were encountered.

CONTINUATION-CALL-ARGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUATION-CALL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUATION-CALL-FN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUATION-CALL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUATION-CALL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUATION-FUNCTION-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUATION-FUNCTION-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUATION-FUNCTION-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUATION-FUNCTION-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUATION-FUNCTION-PARAMETERS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUATION-FUNCTION-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUE-STATEMENT-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUE-STATEMENT-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUE-STATEMENT-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONTINUE-STATEMENT-TARGET-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COPY-TYPE-GRAPH (GRAPH)

Returns a newly-created equivalent GRAPH

DECODE-ARGUMENTS

Decode the command-line arguments and return the resulting option values

DEFAULT-CLAUSE-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DEFAULT-CLAUSE-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DEFAULT-CLAUSE-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DEFAULT-CLAUSE-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DEQUEUE-NODE (QUEUE)

Remove and return a node from the front of QUEUE

DETERMINE-IMPORTED-MODULES (MAIN-MODULE PREFIX-LOOKUP &OPTIONAL ALREADY-IMPORTED)

Determines the modules imported by MAIN-MODULE. Modules whose pathnames are elements of ALREADY-IMPORTED will not be included. Nonexistent files return an empty list of modules.

DETERMINE-MODULES (MAIN-MODULE PREFIX-LOOKUP)

Using MAIN-MODULE as the main module, determine a list of modules that need to be processed to generate an app.

DO-STATEMENT-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DO-STATEMENT-CONDITION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DO-STATEMENT-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DO-STATEMENT-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DO-STATEMENT-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

EFFECTIVE-FN-CALL-P (ELM)

Both function calls and new expressions are 'effective' function calls, because they will both wind up as function calls after the compiler pipeline gets through with them.

ELEMENT-END (ELEMENT)

Returns the end position of source-element or token ELEMENT.

ELEMENT-START (ELEMENT)

Returns the start position of source-element or token ELEMENT.

EMIT-ELMS (ELMS OUT-STREAM &KEY PRETTY-OUTPUT)

Prints ELMS to OUT-STREAM. If PRETTY-OUTPUT is NIL, the elements will be printed compactly

ENQUEUE-ANCESTORS (QUEUE NODE PATH)

Adds NODE and all of the assignment-ancestors of NODE to QUEUE. PATH contains a list of nodes processed so far (used for cycle-detection).

ENQUEUE-NODE (QUEUE NODE)

Add NODE to the end of QUEUE

ENSURE-UNIQUE-BINDING (VAR-NAME)

Adds a unique name for VAR-NAME to the environment, and returns the unique name. The unique name will be uglified or otherwise 'uniquified' for non-toplevel identifiers; toplevel identifiers will be left as-is.

EXPAND-HASHTABLE-TO-VALUES (HASHTABLE)

Returns a list of all the values stored in a hashtable.

EXPLICIT-RETURN-P (ELM)

Convenience function for the common case where we're concerned about function termination (rather than loop or clause termination)

EXPLICITIZE-SHORT-CIRCUIT-OPERATOR (ELM)

Transforms ELM (should be a BINARY-OPERATOR) in a way that preserves the short-circuit semantics

EXPRESSION-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

EXPRESSION-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

EXPRESSION-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FINALLY-CLAUSE-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FINALLY-CLAUSE-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FINALLY-CLAUSE-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FINALLY-CLAUSE-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FIND-BINDING (VAR-NAME)

Looks through the set of environments and finds the most recently bound variable, returns its bound value

FIND-FREE-VARIABLES-IN-SCOPE (ELM)

This is basically TRANSFORM-IN-SCOPE. It adds bindings for each variable and function declaration that it encounters.

FIND-LOCATION-NODE (GRAPH NAME)

Return the location node named NAME from GRAPH if one already exists, or NIL otherwise

FIND-NODE-PROPERTY (NODE NAME)

Return the location node pointed to by NODE's NAME property if one already exists, or NIL otherwise

FIND-VALUE-NODE (GRAPH NAME)

Return the value named NAME from GRAPH

FIND-VALUE-NODE-NAMED (NAME NODE-LIST)

If NODE-LIST contains a value-node named NAME, returns it.

FN-CALL-ARGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FN-CALL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FN-CALL-FN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FN-CALL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FN-CALL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-CONDITION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-IN-BINDING (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-IN-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-IN-COLLECTION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-IN-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-IN-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-IN-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-INITIALIZER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FOR-STEP (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FORCE-SPACE (S)

Prints a space to S in ugly mode to ensure that two elements will be separated

FRESH-LINE-INDENTED (S)

Start a new, indented line.

FUNCTION-DECL-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-DECL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-DECL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-DECL-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-DECL-PARAMETERS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-DECL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-EXPRESSION-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-EXPRESSION-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-EXPRESSION-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-EXPRESSION-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-EXPRESSION-PARAMETERS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-EXPRESSION-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FUNCTION-IN-SCOPE-P (TARGET-NAME)

Return non-NIL if a function-decl with name NAME is currently visible in scope

GENERATE-PRODUCTIONS (PRODUCTIONS)

Used by defparser macro. Take the lispworks list of productions and convert them into CL-YACC versions

GENERATE-RULES-WITH-OPTIONAL (RULE-SPEC &OPTIONAL (MASK 0))

Accepts a PARSERGEN rulespec and transforms it by treating each symbol that begins with a #\? character as being optional. The output is a list of one or more rules that exhaust all the present/absent possibilities. This is an internal utility for generating rules for the different grammar rules that are specified with wildcards.

GENERATE-RUNTIME (RUNTIME-MODULE COMPRESS-MODE COMBINE-MODE)

Generate a runtime at the location pointed to by RUNTIME-MODULE. Only specially-named runtimes will be generated. If COMBINE-MODE is non-NIL, an inline module will be generated; otherwise a module will be emitted to disk.

GENVAR (&OPTIONAL ORIG-NAME)

Generates a unique string that will be our ugly name for variables. When *PRETTY-MODE* is non-NIL and ORIG-NAME is provided, the name will be unique but not all that ugly.

GET-CONSTRUCTOR (STRUCT-OBJECT)

Accept a structure object and return the (likely) name of its constructor. CAVEAT: Assumes that the structure was defined in the same package as its name.

GET-CONTINUATION-NODE (GRAPH NODE &OPTIONAL QUEUE)

Returns the continuation value-node for value-node NODE, creating it if necessary. Creating a continuation node may cause a return-node to be created and queued as a side-effect.

GET-EXEMPLAR-VALUE-NODES (GRAPH CONSTRUCTOR-NAME)

Returns a list containing a value-node for an exemplar value of a type created by constructor CONSTRUCTOR-NAME (which will usually be the name of a built-in type such as Number)

GET-INSTANCE-NODE (GRAPH CONSTRUCTOR &OPTIONAL QUEUE)

Returns a node representing an instance of the type(s) constructed by CONSTRUCTOR. CONSTRUCTOR is either the name of a location-node to retrieve from GRAPH, or a node in GRAPH representing the constructor. For Object and Array types, a new instance node is created. For all other types, the same 'exemplar node' is used for all instances. If QUEUE is non-NIL and the constructor node had to be created, then the new node will be queued for processing.

GET-LOCATION-NODE (GRAPH NAME &OPTIONAL QUEUE)

Return the location node named NAME from GRAPH, creating it if necessary. If the node is created and QUEUE is non-NIL, then the new node will be queued for processing.

GET-MODULE-TEXT (MODULE)

Reads the entire text of a module.

GET-NODE-ARGUMENT (GRAPH NODE INDEX)

Return the location node pointed to by NODE's INDEXth argument, creating it in GRAPH if necessary

GET-NODE-PROPERTY (GRAPH NODE NAME &OPTIONAL QUEUE)

Return the location node pointed to by NODE's NAME property, creating it in GRAPH if necessary. If the property node is created, then it will be queued for processing if QUEUE is non-NIL.

GET-RETURN-NODE (GRAPH NODE &OPTIONAL QUEUE)

Returns the return-node of type-graph-node NODE, creating it in GRAPH if necessary. If NODE is created then it will be added to QUEUE if QUEUE is non-NIL.

GET-THIS-CONTEXT-NODE (GRAPH NODE &OPTIONAL QUEUE)

Returns the this-context-node of value-node NODE, creating it if necessary. If a new node is created then it will be added to QUEUE if QUEUE is non-NIL.

IDEMPOTENT-EXPRESSION-P (ELM)

Return true if ELM is an 'idempotent expression', ie one which it is safe to add repetitions of

IDENTIFIER-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IDENTIFIER-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IDENTIFIER-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IDENTIFIER-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IF-STATEMENT-CONDITION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IF-STATEMENT-ELSE-STATEMENT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IF-STATEMENT-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IF-STATEMENT-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IF-STATEMENT-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IF-STATEMENT-THEN-STATEMENT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IMPORT-DECL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IMPORT-DECL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IMPORT-DECL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IMPORT-DECL-TYPE-SYMBOL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IMPORT-DECL-URIPATH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

INLINEABLE-CALL-TARGET (FN-ELM)

Return non-NIL if it is definitely safe to use FN-ELM as the target of an inlined call (rather than one that has been indirected through $call)

LINE-TERMINATOR-P (C)

Return non-NIL if C is a line-terminator character according to the Javascript spec

LOCATION-NODE-ARGUMENTS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LOCATION-NODE-ASSIGNMENTS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LOCATION-NODE-MIN-CALL-ARITY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LOCATION-NODE-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LOCATION-NODE-PROPERTIES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LOCATION-NODE-RETURN-NODE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LOCATION-NODE-THIS-BINDINGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LOOKUP-MODULE-TYPE (RAW-TYPE)

Converts a 'raw' module type into a canonical type symbol. A warning will be signalled for unrecognized raw types. RAW-TYPE should be either a string or a symbol. The recognized types are: Symbol | Description | Extensions -------|------------------------|------------------ 'JW | jwacs source | .jw, .jwa, .jwacs 'JS | Javascript source | .js

MAIN

This is the main entry-point for the jwacs binary.

MAKE-BOXED-RESULT (ELM)

Returns an object literal whose `done` field is `true` and whose `result` field contains ELM. If ELM is NIL, the result field will be left undefined.

MAKE-BOXED-THUNK (BODY-ELM &OPTIONAL STACK-OP STACK-OP-ARG)

Returns an object literal whose `done` field is `false` and whose `thunk` field contains a thunk whose body is BODY-ELM. When STACK-OP is non-NIL, a handler stack operation property will also be added with a value of STACK-OP-ARG. When *DEBUG-MODE* is non-NIL, an `$evalArg` parameter is also provided, along with boilerplate code that evaluates the argument and then returns when it's present.

MAKE-CALL-STYLE-GUARD (FN-NAME)

Builds a if statement that checks whether the incoming continuation argument is actually a continuation. If it isn't, then (on the assumption that this is an incoming direct-style call), re-calls the current function (whose name is FN-NAME) with a default continuation parameter (`$id`) followed by the original incoming parameters

MAKE-FORIN-ASSIGN (ELM NEW-ARRAY NEW-COUNT-REC)

Creates the assignment that spoofs our iterating through the for-in collection. Just assigns the orignal iterator var from the for-in a value from our new array of values, which we are iterating through using a while loop and the variable new-count-rec

MAKE-KEYWORD (X)

Makes a keyword out of a symbol.

MAKE-LABELLED-CATCH-CONTINUATION (NAME CATCH-CLAUSE &OPTIONAL TAIL-RESUME-ELM)

Returns a labelled continuation that can be used as a catch handler based on CATCH-CLAUSE. The continuation will accept an argument that represents the binding in the clause. Returns a var-init statement that assigns the catch continuation to a var named NAME. If TAIL-RESUME-ELM is non-NIL, it will be added as the last statement of the handler function. It should be a resume statement that resumes the tail continuation for unterminated catch clauses.

MAKE-LABELLED-CONTINUATION (NAME STATEMENT-TAIL)

Constructs a continuation from STATEMENT-TAIL and returns a var-decl-statement that initializes a variable named NAME to the new continuation. Note that labelled continuations accept no arguments.

MAKE-LEXER-FUNCTION (LEXER)

Returns a function of 0 arguments that calls NEXT-TOKEN on LEXER whenever it is called. This is normally the function that gets passed into a parser.

MAKE-MAIN-MODULE (MAIN-PATHNAME INLINE-TEXT)

Constructs a module for the file located at PATH, assuming that the uripath '.' points to MAIN-PATHNAME's directory. If INLINE-TEXT is non-NIL, the module will be an in-memory module.

MAKE-NODE-QUEUE (&KEY (TEST 'EQUAL))

Create an empty NODE-QUEUE

MAKE-TAIL-CALL-CONTINUATION (CONT-ID LEXICALLY-ACTIVE-HANDLERS)

If LEXICALLY-ACTIVE-HANDLERS is non-NIL, returns a continuation function that removes all of the active handlers and then calls the continuation represented by CONT-ID; otherwise returns CONT-ID.

MAKE-VAR-INIT (VAR-NAME INIT-VALUE)

Create a VAR-DECL-STATEMENT that initializes a variable named VAR-NAME to INIT-VALUE

MAKE-VOID-CONTINUATION (CURRENT-CONT)

Returns a function expression that calls CURRENT-CONT with no arguments. This allows us to preserve the behaviour of functions that return no value.

MAPTREE (FN TREE)

MAPTREE maps a function over a tree of cons cells. If TREE is NIL, returns NIL. If TREE is a cons cell, recursively calls MAPTREE on the CAR and CDR and returns a new cons cell whose CAR and CDR are the results. Otherwise, returns the result of applying FN to TREE.

MAYBE-TERMINATE-TOPLEVEL (ELM-LIST)

When *IN-LOCAL-SCOPE* is NIL, returns a list of source elements that is guaranteed to be correctly terminated for the toplevel. When *IN-LOCAL-SCOPE* is non-NIL, ELM-LIST is returned unchanged. 'Correctly terminated for the toplevel' means that if there are any effective function calls, then all control paths are terminated by either a suspend, resume, or throw statement.

MIN* (LEFT RIGHT)

Returns the minimum of LEFT and RIGHT. Either or both arguments may be NIL. NIL is treated as being larger than any other value.

MODULE-COMPRESSED-P (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODULE-IMPORT-ELM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODULE-INLINE-STREAM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODULE-PARENT-MODULE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODULE-PATH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODULE-TEXT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODULE-TYPE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODULE-URIPATH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NESTED-EXPLICITIZE (ELM)

Call TX-EXPLICITIZE on ELM in a nested context (ie, with *NESTED-CONTEXT* bound to T)

NEW-EXPR-ARGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NEW-EXPR-CONSTRUCTOR (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NEW-EXPR-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NEW-EXPR-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NEW-EXPR-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NEXT-TOKEN (LEXER)

Returns a token structure containing the next token in the lexing operation represented by LEXER. This token will have a terminal of NIL at end of stream. The next token will be fetched from the unget-stack if that stack is non-empty.

NODE-QUEUE-CONTAINER-LOOKUP (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NODE-QUEUE-CONTAINER-ROOT-ENTRY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NODE-QUEUE-ENTRY-ITEM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NODE-QUEUE-ENTRY-NEXT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NODE-QUEUE-ENTRY-PREV (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NODE-QUEUE-SIZE (QUEUE)

Return the number of nodes stored in QUEUE

NUMERIC-LITERAL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NUMERIC-LITERAL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NUMERIC-LITERAL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

NUMERIC-LITERAL-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

OBJECT-LITERAL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

OBJECT-LITERAL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

OBJECT-LITERAL-PROPERTIES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

OBJECT-LITERAL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PARSE-FILE (PATH)

Load the file at PATH and parse it into a js/jw source model

PARSE-JAVASCRIPT-INTEGER (INTEGER-STR &KEY (START 0) END)

Parse integer literals, taking account of 0x and 0 radix-specifiers

PARSE-MODULE (MODULE)

Parse the source text contained in MODULE and return a js/jw source-model

PARSE-PREFIX-LOOKUP (RAW-STR)

Takes the argument to the prefix lookup command line option and parses it into a prefix-lookup table.

PATHNAMES-EQUAL (PATH1 PATH2)

Return non-NIL if PATH1 and PATH2 are equivalent. This function avoids some of the complexity that pathnames can entail by comparing the namestrings of the two paths rather than the paths themselves. That way we don't have to worry about spurious distinctions between :UNSPECIFIED and NIL, :NEWEST and NIL and some actual version number, etc.

PIPELINE-COMPILE (ELM &OPTIONAL (PIPELINE *COMPILER-PIPELINE*))

Applies the transformations specified in PIPELINE to ELM in order. ELM may be either a source-element or a list of source-elements.

POPULATE-TYPE-GRAPH (ELM)

Populate a type-graph with nodes and initial edges based on source-element ELM

POSITION-TO-LINE/COLUMN (TEXT INDEX)

Returns a cons cell containing the 1-based row and column for the character at INDEX in TEXT.

POSTPEND (LIST-ARG ATOM-ARG)

Appends a list containing ATOM-ARG to LIST-ARG. eg: (POSTPEND '(1 2) 3) ===> '(1 2 3)

PREFIX-P (STRING PREFIX)

return: whether prefix is a prefix of the string.

PRETTY-PRINT-ARG (ARG-ELM PARENT-ELM S &OPTIONAL ASSOCIATIVITY)

Pretty print an argument subexpression, parenthesizing if: 1. The sub-expression has a lower precedence than the parent expression, or 2. The sub-expression and the parent expression have the same precedence and this arg is on the non-associative branch.

PRETTY-PRINT-SEPARATED-LIST (ELM-LIST S &OPTIONAL (SEP-STRING ,~a))

Pretty print the elements of ELM-LIST to S separated by SEP-STRING.

PROPERTY-ACCESS-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PROPERTY-ACCESS-FIELD (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PROPERTY-ACCESS-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PROPERTY-ACCESS-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PROPERTY-ACCESS-TARGET (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PUSH-TOKEN (LEXER TOKEN &OPTIONAL (ENCOUNTERED-LINE-TERMINATOR (ENCOUNTERED-LINE-TERMINATOR LEXER)))

Push a token onto the top of LEXER's unget stack. The next token fetched by NEXT-TOKEN will be the pushed token. The state of the ENCOUNTERED-LINE-TERMINATOR flag is also saved and will be restored by the next NEXT-TOKEN call.

RE-LITERAL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RE-LITERAL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RE-LITERAL-OPTIONS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RE-LITERAL-PATTERN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RE-LITERAL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

READ-ASDF-COMPONENT-TEXT (COMPONENT-PATH)

Returns the contents of a file that is a component of a currently-loaded asdf system. COMPONENT-PATH is a path describing the location of the component to read. It should have at least 2 elements. The first element is a symbol naming a system. The last element is a string naming a component. There may be intermediate strings naming intermediate modules. Eg: (:JWACS-TESTS "tests" "test-cps-transformation") names the test-cps-transformation component, which is part of the tests module, which is part of the :JWACS-TESTS system.

READ-ENTIRE-FILE (PATH)

Reads the entire contents of the file located at PATH and returns it as a string

REMOVE-HANDLER-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

REMOVE-HANDLER-HANDLER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

REMOVE-HANDLER-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

REMOVE-HANDLER-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

REMOVE-HANDLER-THUNK-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

REMOVE-QUEUED-NODE (QUEUE NODE)

Removes the specified NODE from QUEUE

REPLACE-SPECIAL-VARIABLES (LEAF)

Replace $$n with (token-value (nth n-1 expr)) and $n with (nth n-1 expr)

RESOLVE-ABSOLUTE-URIPATH (URIPATH PREFIX-LOOKUP)

Finds the base-pathname in PREFIX-LOOKUP that most closely matches URIPATH. URIPATH should be a string representing the path component of a URI. PREFIX-LOOKUP should be an assoc list of cells whose CAR is a prefix that begins and ends with a slash, and whose CDR is a pathname representing a directory in the filesystem.

RESOLVE-IMPORT-URIPATH (BASE-PATHNAME URIPATH PREFIX-LOOKUP)

Resolves the URIPATH of an import that appears in the file located at BASE-PATHNAME. Absolute URIPATHs are resolved using PREFIX-LOOKUP to determine their base-pathname.

RESUME-STATEMENT-ARG (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RESUME-STATEMENT-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RESUME-STATEMENT-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RESUME-STATEMENT-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RESUME-STATEMENT-TARGET (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RETURN-STATEMENT-ARG (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RETURN-STATEMENT-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RETURN-STATEMENT-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RETURN-STATEMENT-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SET-CURSOR (LEXER NEW-POS)

Sets the cursor of the lexer to the position specified by NEW-POS

SETUP-FUNCTION-NODE (GRAPH NODE)

Sets up a location-node to point to a value-node of the same name. The existence of three nodes will be guaranteed: (1) A value-node with an assignment edge from NODE and the same name as NODE (2) A location node pointed to by the 'prototype' property of (1) (3) A value-node named #:|NAME-prototype| with an assignment edge from (2). Returns the function value-node (1)

SHIFT-FUNCTION-DECLS (ELM-LIST)

Moves all function-decls in elm-list to the front

SHIFT-VAR-DECLS (ELM-LIST)

Adds empty variable declarations at the top of elm-list for variable declarations that have new-exprs or fn-calls as initializers. The original variable decls are converted to simple assignments.

SINGLE-STATEMENT (&REST ELM-ARGUMENTS)

Takes a list of source elements and distills them into a single statement. If there is only one statement once all the lists have been flattened and the statement-blocks pulled apart, then returns that single statement. Otherwise, wraps the entire flattened sequence in a statement-block.

SOURCE-ELEMENT-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SOURCE-ELEMENT-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SOURCE-ELEMENT-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SPECIAL-VALUE-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SPECIAL-VALUE-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SPECIAL-VALUE-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SPECIAL-VALUE-SYMBOL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STATEMENT-BLOCK-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STATEMENT-BLOCK-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STATEMENT-BLOCK-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STATEMENT-BLOCK-STATEMENTS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STRING-LITERAL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STRING-LITERAL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STRING-LITERAL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STRING-LITERAL-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STRUCTURE-SLOTS (OBJECT)

Returns a list of the slot-names of the provided structure object

SUSPEND-STATEMENT-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SUSPEND-STATEMENT-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SUSPEND-STATEMENT-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SWITCH-CLAUSES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SWITCH-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SWITCH-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SWITCH-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SWITCH-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THROW-STATEMENT-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THROW-STATEMENT-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THROW-STATEMENT-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THROW-STATEMENT-TARGET (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THROW-STATEMENT-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THUNK-FUNCTION-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THUNK-FUNCTION-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THUNK-FUNCTION-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THUNK-FUNCTION-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THUNK-FUNCTION-PARAMETERS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

THUNK-FUNCTION-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TOKEN-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TOKEN-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TOKEN-TERMINAL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TOKEN-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TRANSFORM-IN-SCOPE (ELM)

Transforms source elements for the current scope. Given an element, collects all var-decls and fun-decls and adds them to the current environment. THEN goes through and transforms identifiers + names in said environment. This calls into the main uniquify transform methods, and subsequently will recurse through the tree

TRANSFORM-MODULES (MODULE-LIST &KEY (COMPRESS-MODE (NOT *DEBUG-MODE*)) INLINE-MODE (PIPELINE *COMPILER-PIPELINE*) (VAR-COUNTER 0))

Transforms each module in MODULE-LIST and returns a list of modules suitable for wrapping.

TRY-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TRY-CATCH-CLAUSE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TRY-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TRY-FINALLY-CLAUSE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TRY-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TRY-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TX-SHADOW-VALUES-BODY (BODY)

Transforms the body of a function expression or declaration and returns the new body

TYPE-ANALYZE (ELM)

Perform type analysis on ELM and return the corresponding type-map.

TYPE-GRAPH-NODE-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TYPE-GRAPH-NODE-PROPERTIES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TYPE-GRAPH-NODE-RETURN-NODE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TYPE-GRAPH-NODE-UNIQUE-NAME (NODE)

Return a name for NODE that is likely to be unique

UGLIFY-VARS (PROGRAM)

Entry point for our source transformation. Turn all var and function declarations and their related references s into ugly ones

UGLY-PRINT (ELM STREAM)

Outputs the AST to a stream with variables and function names converted to unique identifiers (ie. JW0) and with all formatting removed.

UNARY-OPERATOR-ARG (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

UNARY-OPERATOR-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

UNARY-OPERATOR-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

UNARY-OPERATOR-OP-SYMBOL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

UNARY-OPERATOR-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

UNNESTED-EXPLICITIZE (ELM)

Call TX-EXPLICITIZE on ELM in an unnested context (ie, with *NESTED-CONTEXT* bound to NIL)

VALUE-NODE-CONSTRUCTOR-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VALUE-NODE-CONTINUATION-NODE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VALUE-NODE-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VALUE-NODE-PARAMETERS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VALUE-NODE-PROPERTIES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VALUE-NODE-PROTOTYPE-NODE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VALUE-NODE-RETURN-NODE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VALUE-NODE-THIS-CONTEXT-NODE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VAR-DECL-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VAR-DECL-INITIALIZER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VAR-DECL-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VAR-DECL-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VAR-DECL-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VAR-DECL-STATEMENT-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VAR-DECL-STATEMENT-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VAR-DECL-STATEMENT-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VAR-DECL-STATEMENT-VAR-DECLS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WHILE-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WHILE-CONDITION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WHILE-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WHILE-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WHILE-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WITH-BODY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WITH-END (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WITH-LABEL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WITH-SCOPE-OBJECT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WITH-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

WRAP-MODULES (MODULE-LIST TEMPLATE-STRING OUT-STREAM COMBINED-JS-MODULE)

Creates a 'wrapper' html file that represents a jwacs application containing all of the files of MODULE-LIST. We modify the template-string to contain appropriate <SCRIPT> tags referencing each of the modules, and write it to OUT-STREAM. If COMBINED-JS-MODULE is NIL, each js-module gets its own SCRIPT tag; otherwise we will wrap all JS modules into COMBINED-JS-MODULE

Undocumented

SETFADD-HANDLER-END (NEW-VALUE INSTANCE)

SETFADD-HANDLER-HANDLER (NEW-VALUE INSTANCE)

SETFADD-HANDLER-LABEL (NEW-VALUE INSTANCE)

ADD-HANDLER-P (OBJECT)

SETFADD-HANDLER-START (NEW-VALUE INSTANCE)

SETFADD-HANDLER-THUNK-BODY (NEW-VALUE INSTANCE)

SETFARRAY-LITERAL-ELEMENTS (NEW-VALUE INSTANCE)

SETFARRAY-LITERAL-END (NEW-VALUE INSTANCE)

SETFARRAY-LITERAL-LABEL (NEW-VALUE INSTANCE)

ARRAY-LITERAL-P (OBJECT)

SETFARRAY-LITERAL-START (NEW-VALUE INSTANCE)

SETFBINARY-OPERATOR-END (NEW-VALUE INSTANCE)

SETFBINARY-OPERATOR-LABEL (NEW-VALUE INSTANCE)

SETFBINARY-OPERATOR-LEFT-ARG (NEW-VALUE INSTANCE)

SETFBINARY-OPERATOR-OP-SYMBOL (NEW-VALUE INSTANCE)

BINARY-OPERATOR-P (OBJECT)

SETFBINARY-OPERATOR-RIGHT-ARG (NEW-VALUE INSTANCE)

SETFBINARY-OPERATOR-START (NEW-VALUE INSTANCE)

SETFBREAK-STATEMENT-END (NEW-VALUE INSTANCE)

SETFBREAK-STATEMENT-LABEL (NEW-VALUE INSTANCE)

BREAK-STATEMENT-P (OBJECT)

SETFBREAK-STATEMENT-START (NEW-VALUE INSTANCE)

SETFBREAK-STATEMENT-TARGET-LABEL (NEW-VALUE INSTANCE)

SETFCASE-CLAUSE-BODY (NEW-VALUE INSTANCE)

SETFCASE-CLAUSE-END (NEW-VALUE INSTANCE)

SETFCASE-CLAUSE-LABEL (NEW-VALUE INSTANCE)

CASE-CLAUSE-P (OBJECT)

SETFCASE-CLAUSE-START (NEW-VALUE INSTANCE)

SETFCASE-CLAUSE-VALUE (NEW-VALUE INSTANCE)

SETFCATCH-CLAUSE-BINDING (NEW-VALUE INSTANCE)

SETFCATCH-CLAUSE-BODY (NEW-VALUE INSTANCE)

SETFCATCH-CLAUSE-END (NEW-VALUE INSTANCE)

SETFCATCH-CLAUSE-LABEL (NEW-VALUE INSTANCE)

CATCH-CLAUSE-P (OBJECT)

SETFCATCH-CLAUSE-START (NEW-VALUE INSTANCE)

SETFCOMMA-EXPR-END (NEW-VALUE INSTANCE)

SETFCOMMA-EXPR-EXPRS (NEW-VALUE INSTANCE)

SETFCOMMA-EXPR-LABEL (NEW-VALUE INSTANCE)

COMMA-EXPR-P (OBJECT)

SETFCOMMA-EXPR-START (NEW-VALUE INSTANCE)

SETFCONDITIONAL-CONDITION (NEW-VALUE INSTANCE)

SETFCONDITIONAL-END (NEW-VALUE INSTANCE)

SETFCONDITIONAL-FALSE-ARG (NEW-VALUE INSTANCE)

SETFCONDITIONAL-LABEL (NEW-VALUE INSTANCE)

CONDITIONAL-P (OBJECT)

SETFCONDITIONAL-START (NEW-VALUE INSTANCE)

SETFCONDITIONAL-TRUE-ARG (NEW-VALUE INSTANCE)

CONNECT-TYPE-GRAPH (GRAPH)

SETFCONTINUATION-CALL-ARGS (NEW-VALUE INSTANCE)

SETFCONTINUATION-CALL-END (NEW-VALUE INSTANCE)

SETFCONTINUATION-CALL-FN (NEW-VALUE INSTANCE)

SETFCONTINUATION-CALL-LABEL (NEW-VALUE INSTANCE)

CONTINUATION-CALL-P (OBJECT)

SETFCONTINUATION-CALL-START (NEW-VALUE INSTANCE)

SETFCONTINUATION-FUNCTION-BODY (NEW-VALUE INSTANCE)

SETFCONTINUATION-FUNCTION-END (NEW-VALUE INSTANCE)

SETFCONTINUATION-FUNCTION-LABEL (NEW-VALUE INSTANCE)

SETFCONTINUATION-FUNCTION-NAME (NEW-VALUE INSTANCE)

CONTINUATION-FUNCTION-P (OBJECT)

SETFCONTINUATION-FUNCTION-PARAMETERS (NEW-VALUE INSTANCE)

SETFCONTINUATION-FUNCTION-START (NEW-VALUE INSTANCE)

SETFCONTINUE-STATEMENT-END (NEW-VALUE INSTANCE)

SETFCONTINUE-STATEMENT-LABEL (NEW-VALUE INSTANCE)

CONTINUE-STATEMENT-P (OBJECT)

SETFCONTINUE-STATEMENT-START (NEW-VALUE INSTANCE)

SETFCONTINUE-STATEMENT-TARGET-LABEL (NEW-VALUE INSTANCE)

COPY-ADD-HANDLER (INSTANCE)

COPY-ARRAY-LITERAL (INSTANCE)

COPY-BINARY-OPERATOR (INSTANCE)

COPY-BREAK-STATEMENT (INSTANCE)

COPY-CASE-CLAUSE (INSTANCE)

COPY-CATCH-CLAUSE (INSTANCE)

COPY-COMMA-EXPR (INSTANCE)

COPY-CONDITIONAL (INSTANCE)

COPY-CONTINUATION-CALL (INSTANCE)

COPY-CONTINUATION-FUNCTION (INSTANCE)

COPY-CONTINUE-STATEMENT (INSTANCE)

COPY-DEFAULT-CLAUSE (INSTANCE)

COPY-DO-STATEMENT (INSTANCE)

COPY-EXPRESSION (INSTANCE)

COPY-FINALLY-CLAUSE (INSTANCE)

COPY-FN-CALL (INSTANCE)

COPY-FOR (INSTANCE)

COPY-FOR-IN (INSTANCE)

COPY-FUNCTION-DECL (INSTANCE)

COPY-FUNCTION-EXPRESSION (INSTANCE)

COPY-IDENTIFIER (INSTANCE)

COPY-IF-STATEMENT (INSTANCE)

COPY-IMPORT-DECL (INSTANCE)

COPY-LOCATION-NODE (INSTANCE)

COPY-MODULE (INSTANCE)

COPY-NEW-EXPR (INSTANCE)

COPY-NODE-QUEUE-CONTAINER (INSTANCE)

COPY-NODE-QUEUE-ENTRY (INSTANCE)

COPY-NUMERIC-LITERAL (INSTANCE)

COPY-OBJECT-LITERAL (INSTANCE)

COPY-PROPERTY-ACCESS (INSTANCE)

COPY-RE-LITERAL (INSTANCE)

COPY-REMOVE-HANDLER (INSTANCE)

COPY-RESUME-STATEMENT (INSTANCE)

COPY-RETURN-STATEMENT (INSTANCE)

COPY-SOURCE-ELEMENT (INSTANCE)

COPY-SPECIAL-VALUE (INSTANCE)

COPY-STATEMENT-BLOCK (INSTANCE)

COPY-STRING-LITERAL (INSTANCE)

COPY-SUSPEND-STATEMENT (INSTANCE)

COPY-SWITCH (INSTANCE)

COPY-THROW-STATEMENT (INSTANCE)

COPY-THUNK-FUNCTION (INSTANCE)

COPY-TOKEN (INSTANCE)

COPY-TRY (INSTANCE)

COPY-TYPE-GRAPH-NODE (INSTANCE)

COPY-UNARY-OPERATOR (INSTANCE)

COPY-VALUE-NODE (INSTANCE)

COPY-VAR-DECL (INSTANCE)

COPY-VAR-DECL-STATEMENT (INSTANCE)

COPY-WHILE (INSTANCE)

COPY-WITH (INSTANCE)

SETFDEFAULT-CLAUSE-BODY (NEW-VALUE INSTANCE)

SETFDEFAULT-CLAUSE-END (NEW-VALUE INSTANCE)

SETFDEFAULT-CLAUSE-LABEL (NEW-VALUE INSTANCE)

DEFAULT-CLAUSE-P (OBJECT)

SETFDEFAULT-CLAUSE-START (NEW-VALUE INSTANCE)

SETFDO-STATEMENT-BODY (NEW-VALUE INSTANCE)

SETFDO-STATEMENT-CONDITION (NEW-VALUE INSTANCE)

SETFDO-STATEMENT-END (NEW-VALUE INSTANCE)

SETFDO-STATEMENT-LABEL (NEW-VALUE INSTANCE)

DO-STATEMENT-P (OBJECT)

SETFDO-STATEMENT-START (NEW-VALUE INSTANCE)

ESCAPE-REGEXP (RE-STRING)

SETFEXPRESSION-END (NEW-VALUE INSTANCE)

SETFEXPRESSION-LABEL (NEW-VALUE INSTANCE)

EXPRESSION-P (OBJECT)

SETFEXPRESSION-START (NEW-VALUE INSTANCE)

SETFFINALLY-CLAUSE-BODY (NEW-VALUE INSTANCE)

SETFFINALLY-CLAUSE-END (NEW-VALUE INSTANCE)

SETFFINALLY-CLAUSE-LABEL (NEW-VALUE INSTANCE)

FINALLY-CLAUSE-P (OBJECT)

SETFFINALLY-CLAUSE-START (NEW-VALUE INSTANCE)

SETFFN-CALL-ARGS (NEW-VALUE INSTANCE)

SETFFN-CALL-END (NEW-VALUE INSTANCE)

SETFFN-CALL-FN (NEW-VALUE INSTANCE)

SETFFN-CALL-LABEL (NEW-VALUE INSTANCE)

FN-CALL-P (OBJECT)

SETFFN-CALL-START (NEW-VALUE INSTANCE)

SETFFOR-BODY (NEW-VALUE INSTANCE)

SETFFOR-CONDITION (NEW-VALUE INSTANCE)

SETFFOR-END (NEW-VALUE INSTANCE)

SETFFOR-IN-BINDING (NEW-VALUE INSTANCE)

SETFFOR-IN-BODY (NEW-VALUE INSTANCE)

SETFFOR-IN-COLLECTION (NEW-VALUE INSTANCE)

SETFFOR-IN-END (NEW-VALUE INSTANCE)

SETFFOR-IN-LABEL (NEW-VALUE INSTANCE)

FOR-IN-P (OBJECT)

SETFFOR-IN-START (NEW-VALUE INSTANCE)

SETFFOR-INITIALIZER (NEW-VALUE INSTANCE)

SETFFOR-LABEL (NEW-VALUE INSTANCE)

FOR-P (OBJECT)

SETFFOR-START (NEW-VALUE INSTANCE)

SETFFOR-STEP (NEW-VALUE INSTANCE)

SETFFUNCTION-DECL-BODY (NEW-VALUE INSTANCE)

SETFFUNCTION-DECL-END (NEW-VALUE INSTANCE)

SETFFUNCTION-DECL-LABEL (NEW-VALUE INSTANCE)

SETFFUNCTION-DECL-NAME (NEW-VALUE INSTANCE)

FUNCTION-DECL-P (OBJECT)

SETFFUNCTION-DECL-PARAMETERS (NEW-VALUE INSTANCE)

SETFFUNCTION-DECL-START (NEW-VALUE INSTANCE)

SETFFUNCTION-EXPRESSION-BODY (NEW-VALUE INSTANCE)

SETFFUNCTION-EXPRESSION-END (NEW-VALUE INSTANCE)

SETFFUNCTION-EXPRESSION-LABEL (NEW-VALUE INSTANCE)

SETFFUNCTION-EXPRESSION-NAME (NEW-VALUE INSTANCE)

FUNCTION-EXPRESSION-P (OBJECT)

SETFFUNCTION-EXPRESSION-PARAMETERS (NEW-VALUE INSTANCE)

SETFFUNCTION-EXPRESSION-START (NEW-VALUE INSTANCE)

SETFIDENTIFIER-END (NEW-VALUE INSTANCE)

SETFIDENTIFIER-LABEL (NEW-VALUE INSTANCE)

SETFIDENTIFIER-NAME (NEW-VALUE INSTANCE)

IDENTIFIER-P (OBJECT)

SETFIDENTIFIER-START (NEW-VALUE INSTANCE)

SETFIF-STATEMENT-CONDITION (NEW-VALUE INSTANCE)

SETFIF-STATEMENT-ELSE-STATEMENT (NEW-VALUE INSTANCE)

SETFIF-STATEMENT-END (NEW-VALUE INSTANCE)

SETFIF-STATEMENT-LABEL (NEW-VALUE INSTANCE)

IF-STATEMENT-P (OBJECT)

SETFIF-STATEMENT-START (NEW-VALUE INSTANCE)

SETFIF-STATEMENT-THEN-STATEMENT (NEW-VALUE INSTANCE)

SETFIMPORT-DECL-END (NEW-VALUE INSTANCE)

SETFIMPORT-DECL-LABEL (NEW-VALUE INSTANCE)

IMPORT-DECL-P (OBJECT)

SETFIMPORT-DECL-START (NEW-VALUE INSTANCE)

SETFIMPORT-DECL-TYPE-SYMBOL (NEW-VALUE INSTANCE)

SETFIMPORT-DECL-URIPATH (NEW-VALUE INSTANCE)

SETFLOCATION-NODE-ARGUMENTS (NEW-VALUE INSTANCE)

SETFLOCATION-NODE-ASSIGNMENTS (NEW-VALUE INSTANCE)

SETFLOCATION-NODE-MIN-CALL-ARITY (NEW-VALUE INSTANCE)

SETFLOCATION-NODE-NAME (NEW-VALUE INSTANCE)

LOCATION-NODE-P (OBJECT)

SETFLOCATION-NODE-PROPERTIES (NEW-VALUE INSTANCE)

SETFLOCATION-NODE-RETURN-NODE (NEW-VALUE INSTANCE)

SETFLOCATION-NODE-THIS-BINDINGS (NEW-VALUE INSTANCE)

MAKE-ADD-HANDLER (&KEY ((LABEL DUM3035) NIL) ((START DUM3036) NIL) ((END DUM3037) NIL) ((HANDLER DUM3038) NIL) ((THUNK-BODY DUM3039) NIL))

MAKE-ARRAY-LITERAL (&KEY ((LABEL DUM411) NIL) ((START DUM412) NIL) ((END DUM413) NIL) ((ELEMENTS DUM414) NIL))

MAKE-BINARY-OPERATOR (&KEY ((LABEL DUM917) NIL) ((START DUM918) NIL) ((END DUM919) NIL) ((OP-SYMBOL DUM920) NIL) ((LEFT-ARG DUM921) NIL) ((RIGHT-ARG DUM922) NIL))

MAKE-BREAK-STATEMENT (&KEY ((LABEL DUM1850) NIL) ((START DUM1851) NIL) ((END DUM1852) NIL) ((TARGET-LABEL DUM1853) NIL))

MAKE-CASE-CLAUSE (&KEY ((LABEL DUM2142) NIL) ((START DUM2143) NIL) ((END DUM2144) NIL) ((VALUE DUM2145) NIL) ((BODY DUM2146) NIL))

MAKE-CATCH-CLAUSE (&KEY ((LABEL DUM2457) NIL) ((START DUM2458) NIL) ((END DUM2459) NIL) ((BINDING DUM2460) NIL) ((BODY DUM2461) NIL))

MAKE-COMMA-EXPR (&KEY ((LABEL DUM1074) NIL) ((START DUM1075) NIL) ((END DUM1076) NIL) ((EXPRS DUM1077) NIL))

MAKE-CONDITIONAL (&KEY ((LABEL DUM994) NIL) ((START DUM995) NIL) ((END DUM996) NIL) ((CONDITION DUM997) NIL) ((TRUE-ARG DUM998) NIL) ((FALSE-ARG DUM999) NIL))

MAKE-CONTINUATION-CALL (&KEY ((LABEL DUM2957) NIL) ((START DUM2958) NIL) ((END DUM2959) NIL) ((FN DUM2960) NIL) ((ARGS DUM2961) NIL))

MAKE-CONTINUATION-FUNCTION (&KEY ((LABEL DUM2781) NIL) ((START DUM2782) NIL) ((END DUM2783) NIL) ((NAME DUM2784) NIL) ((PARAMETERS DUM2785) NIL) ((BODY DUM2786) NIL))

MAKE-CONTINUE-STATEMENT (&KEY ((LABEL DUM1777) NIL) ((START DUM1778) NIL) ((END DUM1779) NIL) ((TARGET-LABEL DUM1780) NIL))

MAKE-DEFAULT-CLAUSE (&KEY ((LABEL DUM2220) NIL) ((START DUM2221) NIL) ((END DUM2222) NIL) ((BODY DUM2223) NIL))

MAKE-DO-STATEMENT (&KEY ((LABEL DUM1450) NIL) ((START DUM1451) NIL) ((END DUM1452) NIL) ((CONDITION DUM1453) NIL) ((BODY DUM1454) NIL))

MAKE-DOT-GRAPH (TYPE-GRAPH &OPTIONAL (FNAME c:/temp/types.dot))

MAKE-EXPRESSION (&KEY ((LABEL DUM72) NIL) ((START DUM73) NIL) ((END DUM74) NIL))

MAKE-FINALLY-CLAUSE (&KEY ((LABEL DUM2534) NIL) ((START DUM2535) NIL) ((END DUM2536) NIL) ((BODY DUM2537) NIL))

MAKE-FN-CALL (&KEY ((LABEL DUM692) NIL) ((START DUM693) NIL) ((END DUM694) NIL) ((FN DUM695) NIL) ((ARGS DUM696) NIL))

MAKE-FOR (&KEY ((LABEL DUM1602) NIL) ((START DUM1603) NIL) ((END DUM1604) NIL) ((INITIALIZER DUM1605) NIL) ((CONDITION DUM1606) NIL) ((STEP DUM1607) NIL) ((BODY DUM1608) NIL))

MAKE-FOR-IN (&KEY ((LABEL DUM1695) NIL) ((START DUM1696) NIL) ((END DUM1697) NIL) ((BINDING DUM1698) NIL) ((COLLECTION DUM1699) NIL) ((BODY DUM1700) NIL))

MAKE-FUNCTION-DECL (&KEY ((LABEL DUM2607) NIL) ((START DUM2608) NIL) ((END DUM2609) NIL) ((NAME DUM2610) NIL) ((PARAMETERS DUM2611) NIL) ((BODY DUM2612) NIL))

MAKE-FUNCTION-EXPRESSION (&KEY ((LABEL DUM2693) NIL) ((START DUM2694) NIL) ((END DUM2695) NIL) ((NAME DUM2696) NIL) ((PARAMETERS DUM2697) NIL) ((BODY DUM2698) NIL))

MAKE-IDENTIFIER (&KEY ((LABEL DUM204) NIL) ((START DUM205) NIL) ((END DUM206) NIL) ((NAME DUM207) NIL))

MAKE-IF-STATEMENT (&KEY ((LABEL DUM1366) NIL) ((START DUM1367) NIL) ((END DUM1368) NIL) ((CONDITION DUM1369) NIL) ((THEN-STATEMENT DUM1370) NIL) ((ELSE-STATEMENT DUM1371) NIL))

MAKE-IMPORT-DECL (&KEY ((LABEL DUM3339) NIL) ((START DUM3340) NIL) ((END DUM3341) NIL) ((TYPE-SYMBOL DUM3342) NIL) ((URIPATH DUM3343) NIL))

MAKE-LOCATION-NODE (&KEY ((NAME DUM42) NIL) ((PROPERTIES DUM43) NIL) ((ASSIGNMENT-BACKLINKS DUM44) NIL) ((RETURN-NODE DUM45) NIL) ((ASSIGNMENTS DUM46) NIL) ((ARGUMENTS DUM47) NIL) ((THIS-BINDINGS DUM48) NIL) ((MIN-CALL-ARITY DUM49) NIL))

MAKE-MODULE (&KEY ((TYPE DUM0) NIL) ((PATH DUM1) NIL) ((URIPATH DUM2) NIL) ((IMPORT-ELM DUM3) NIL) ((PARENT-MODULE DUM4) NIL) ((COMPRESSED-P DUM5) NIL) ((TEXT DUM6) NIL) ((INLINE-STREAM DUM7) NIL))

MAKE-NEW-EXPR (&KEY ((LABEL DUM614) NIL) ((START DUM615) NIL) ((END DUM616) NIL) ((CONSTRUCTOR DUM617) NIL) ((ARGS DUM618) NIL))

MAKE-NODE-QUEUE-CONTAINER (&KEY ((ROOT-ENTRY DUM965) NIL) ((LOOKUP DUM966) NIL))

MAKE-NODE-QUEUE-ENTRY (&KEY ((PREV DUM925) NIL) ((NEXT DUM926) NIL) ((ITEM DUM927) NIL))

MAKE-NUMERIC-LITERAL (&KEY ((LABEL DUM273) NIL) ((START DUM274) NIL) ((END DUM275) NIL) ((VALUE DUM276) NIL))

MAKE-OBJECT-LITERAL (&KEY ((LABEL DUM478) NIL) ((START DUM479) NIL) ((END DUM480) NIL) ((PROPERTIES DUM481) NIL))

MAKE-PROPERTY-ACCESS (&KEY ((LABEL DUM770) NIL) ((START DUM771) NIL) ((END DUM772) NIL) ((TARGET DUM773) NIL) ((FIELD DUM774) NIL))

MAKE-RE-LITERAL (&KEY ((LABEL DUM545) NIL) ((START DUM546) NIL) ((END DUM547) NIL) ((PATTERN DUM548) NIL) ((OPTIONS DUM549) NIL))

MAKE-REMOVE-HANDLER (&KEY ((LABEL DUM3116) NIL) ((START DUM3117) NIL) ((END DUM3118) NIL) ((HANDLER DUM3119) NIL) ((THUNK-BODY DUM3120) NIL))

MAKE-RESUME-STATEMENT (&KEY ((LABEL DUM3262) NIL) ((START DUM3263) NIL) ((END DUM3264) NIL) ((TARGET DUM3265) NIL) ((ARG DUM3266) NIL))

MAKE-RETURN-STATEMENT (&KEY ((LABEL DUM1923) NIL) ((START DUM1924) NIL) ((END DUM1925) NIL) ((ARG DUM1926) NIL))

MAKE-SOURCE-ELEMENT (&KEY ((LABEL DUM7) NIL) ((START DUM8) NIL) ((END DUM9) NIL))

MAKE-SPECIAL-VALUE (&KEY ((LABEL DUM137) NIL) ((START DUM138) NIL) ((END DUM139) NIL) ((SYMBOL DUM140) NIL))

MAKE-STATEMENT-BLOCK (&KEY ((LABEL DUM1293) NIL) ((START DUM1294) NIL) ((END DUM1295) NIL) ((STATEMENTS DUM1296) NIL))

MAKE-STRING-LITERAL (&KEY ((LABEL DUM342) NIL) ((START DUM343) NIL) ((END DUM344) NIL) ((VALUE DUM345) NIL))

MAKE-SUSPEND-STATEMENT (&KEY ((LABEL DUM3197) NIL) ((START DUM3198) NIL) ((END DUM3199) NIL))

MAKE-SWITCH (&KEY ((LABEL DUM2070) NIL) ((START DUM2071) NIL) ((END DUM2072) NIL) ((VALUE DUM2073) NIL) ((CLAUSES DUM2074) NIL))

MAKE-THROW-STATEMENT (&KEY ((LABEL DUM2293) NIL) ((START DUM2294) NIL) ((END DUM2295) NIL) ((VALUE DUM2296) NIL) ((TARGET DUM2297) NIL))

MAKE-THUNK-FUNCTION (&KEY ((LABEL DUM2869) NIL) ((START DUM2870) NIL) ((END DUM2871) NIL) ((NAME DUM2872) NIL) ((PARAMETERS DUM2873) NIL) ((BODY DUM2874) NIL))

MAKE-TOKEN (&KEY ((TERMINAL DUM689) NIL) ((VALUE DUM690) NIL) ((START DUM691) NIL) ((END DUM692) NIL))

MAKE-TRY (&KEY ((LABEL DUM2372) NIL) ((START DUM2373) NIL) ((END DUM2374) NIL) ((BODY DUM2375) NIL) ((CATCH-CLAUSE DUM2376) NIL) ((FINALLY-CLAUSE DUM2377) NIL))

MAKE-TYPE-GRAPH-NODE (&KEY ((NAME DUM0) NIL) ((PROPERTIES DUM1) NIL) ((ASSIGNMENT-BACKLINKS DUM2) NIL) ((RETURN-NODE DUM3) NIL))

MAKE-UNARY-OPERATOR (&KEY ((LABEL DUM845) NIL) ((START DUM846) NIL) ((END DUM847) NIL) ((OP-SYMBOL DUM848) NIL) ((ARG DUM849) NIL))

MAKE-VALUE-NODE (&KEY ((NAME DUM92) NIL) ((PROPERTIES DUM93) NIL) ((ASSIGNMENT-BACKLINKS DUM94) NIL) ((RETURN-NODE DUM95) NIL) ((CONSTRUCTOR-NAME DUM96) NIL) ((PARAMETERS DUM97) NIL) ((THIS-CONTEXT-NODE DUM98) NIL) ((PROTOTYPE-NODE DUM99) NIL) ((CONTINUATION-NODE DUM100) NIL))

MAKE-VAR-DECL (&KEY ((LABEL DUM1217) NIL) ((START DUM1218) NIL) ((END DUM1219) NIL) ((NAME DUM1220) NIL) ((INITIALIZER DUM1221) NIL))

MAKE-VAR-DECL-STATEMENT (&KEY ((LABEL DUM1147) NIL) ((START DUM1148) NIL) ((END DUM1149) NIL) ((VAR-DECLS DUM1150) NIL))

MAKE-WHILE (&KEY ((LABEL DUM1525) NIL) ((START DUM1526) NIL) ((END DUM1527) NIL) ((CONDITION DUM1528) NIL) ((BODY DUM1529) NIL))

MAKE-WITH (&KEY ((LABEL DUM1995) NIL) ((START DUM1996) NIL) ((END DUM1997) NIL) ((SCOPE-OBJECT DUM1998) NIL) ((BODY DUM1999) NIL))

SETFMODULE-COMPRESSED-P (NEW-VALUE INSTANCE)

SETFMODULE-IMPORT-ELM (NEW-VALUE INSTANCE)

SETFMODULE-INLINE-STREAM (NEW-VALUE INSTANCE)

MODULE-P (OBJECT)

SETFMODULE-PARENT-MODULE (NEW-VALUE INSTANCE)

SETFMODULE-PATH (NEW-VALUE INSTANCE)

SETFMODULE-TEXT (NEW-VALUE INSTANCE)

SETFMODULE-TYPE (NEW-VALUE INSTANCE)

SETFMODULE-URIPATH (NEW-VALUE INSTANCE)

SETFNEW-EXPR-ARGS (NEW-VALUE INSTANCE)

SETFNEW-EXPR-CONSTRUCTOR (NEW-VALUE INSTANCE)

SETFNEW-EXPR-END (NEW-VALUE INSTANCE)

SETFNEW-EXPR-LABEL (NEW-VALUE INSTANCE)

NEW-EXPR-P (OBJECT)

SETFNEW-EXPR-START (NEW-VALUE INSTANCE)

SETFNODE-QUEUE-CONTAINER-LOOKUP (NEW-VALUE INSTANCE)

NODE-QUEUE-CONTAINER-P (OBJECT)

SETFNODE-QUEUE-CONTAINER-ROOT-ENTRY (NEW-VALUE INSTANCE)

SETFNODE-QUEUE-ENTRY-ITEM (NEW-VALUE INSTANCE)

SETFNODE-QUEUE-ENTRY-NEXT (NEW-VALUE INSTANCE)

NODE-QUEUE-ENTRY-P (OBJECT)

SETFNODE-QUEUE-ENTRY-PREV (NEW-VALUE INSTANCE)

SETFNUMERIC-LITERAL-END (NEW-VALUE INSTANCE)

SETFNUMERIC-LITERAL-LABEL (NEW-VALUE INSTANCE)

NUMERIC-LITERAL-P (OBJECT)

SETFNUMERIC-LITERAL-START (NEW-VALUE INSTANCE)

SETFNUMERIC-LITERAL-VALUE (NEW-VALUE INSTANCE)

SETFOBJECT-LITERAL-END (NEW-VALUE INSTANCE)

SETFOBJECT-LITERAL-LABEL (NEW-VALUE INSTANCE)

OBJECT-LITERAL-P (OBJECT)

SETFOBJECT-LITERAL-PROPERTIES (NEW-VALUE INSTANCE)

SETFOBJECT-LITERAL-START (NEW-VALUE INSTANCE)

SETFPROPERTY-ACCESS-END (NEW-VALUE INSTANCE)

SETFPROPERTY-ACCESS-FIELD (NEW-VALUE INSTANCE)

SETFPROPERTY-ACCESS-LABEL (NEW-VALUE INSTANCE)

PROPERTY-ACCESS-P (OBJECT)

SETFPROPERTY-ACCESS-START (NEW-VALUE INSTANCE)

SETFPROPERTY-ACCESS-TARGET (NEW-VALUE INSTANCE)

RE-COND-CLAUSE (STRING START BLOCK-NAME CLAUSE)

SETFRE-LITERAL-END (NEW-VALUE INSTANCE)

SETFRE-LITERAL-LABEL (NEW-VALUE INSTANCE)

SETFRE-LITERAL-OPTIONS (NEW-VALUE INSTANCE)

RE-LITERAL-P (OBJECT)

SETFRE-LITERAL-PATTERN (NEW-VALUE INSTANCE)

SETFRE-LITERAL-START (NEW-VALUE INSTANCE)

SETFREMOVE-HANDLER-END (NEW-VALUE INSTANCE)

SETFREMOVE-HANDLER-HANDLER (NEW-VALUE INSTANCE)

SETFREMOVE-HANDLER-LABEL (NEW-VALUE INSTANCE)

REMOVE-HANDLER-P (OBJECT)

SETFREMOVE-HANDLER-START (NEW-VALUE INSTANCE)

SETFREMOVE-HANDLER-THUNK-BODY (NEW-VALUE INSTANCE)

SETFRESUME-STATEMENT-ARG (NEW-VALUE INSTANCE)

SETFRESUME-STATEMENT-END (NEW-VALUE INSTANCE)

SETFRESUME-STATEMENT-LABEL (NEW-VALUE INSTANCE)

RESUME-STATEMENT-P (OBJECT)

SETFRESUME-STATEMENT-START (NEW-VALUE INSTANCE)

SETFRESUME-STATEMENT-TARGET (NEW-VALUE INSTANCE)

SETFRETURN-STATEMENT-ARG (NEW-VALUE INSTANCE)

SETFRETURN-STATEMENT-END (NEW-VALUE INSTANCE)

SETFRETURN-STATEMENT-LABEL (NEW-VALUE INSTANCE)

RETURN-STATEMENT-P (OBJECT)

SETFRETURN-STATEMENT-START (NEW-VALUE INSTANCE)

SHOW-BANNER

SHOW-USAGE

SETFSOURCE-ELEMENT-END (NEW-VALUE INSTANCE)

SETFSOURCE-ELEMENT-LABEL (NEW-VALUE INSTANCE)

SOURCE-ELEMENT-P (OBJECT)

SETFSOURCE-ELEMENT-START (NEW-VALUE INSTANCE)

SETFSPECIAL-VALUE-END (NEW-VALUE INSTANCE)

SETFSPECIAL-VALUE-LABEL (NEW-VALUE INSTANCE)

SPECIAL-VALUE-P (OBJECT)

SETFSPECIAL-VALUE-START (NEW-VALUE INSTANCE)

SETFSPECIAL-VALUE-SYMBOL (NEW-VALUE INSTANCE)

SETFSTATEMENT-BLOCK-END (NEW-VALUE INSTANCE)

SETFSTATEMENT-BLOCK-LABEL (NEW-VALUE INSTANCE)

STATEMENT-BLOCK-P (OBJECT)

SETFSTATEMENT-BLOCK-START (NEW-VALUE INSTANCE)

SETFSTATEMENT-BLOCK-STATEMENTS (NEW-VALUE INSTANCE)

SETFSTRING-LITERAL-END (NEW-VALUE INSTANCE)

SETFSTRING-LITERAL-LABEL (NEW-VALUE INSTANCE)

STRING-LITERAL-P (OBJECT)

SETFSTRING-LITERAL-START (NEW-VALUE INSTANCE)

SETFSTRING-LITERAL-VALUE (NEW-VALUE INSTANCE)

SETFSUSPEND-STATEMENT-END (NEW-VALUE INSTANCE)

SETFSUSPEND-STATEMENT-LABEL (NEW-VALUE INSTANCE)

SUSPEND-STATEMENT-P (OBJECT)

SETFSUSPEND-STATEMENT-START (NEW-VALUE INSTANCE)

SETFSWITCH-CLAUSES (NEW-VALUE INSTANCE)

SETFSWITCH-END (NEW-VALUE INSTANCE)

SETFSWITCH-LABEL (NEW-VALUE INSTANCE)

SWITCH-P (OBJECT)

SETFSWITCH-START (NEW-VALUE INSTANCE)

SETFSWITCH-VALUE (NEW-VALUE INSTANCE)

SETFTHROW-STATEMENT-END (NEW-VALUE INSTANCE)

SETFTHROW-STATEMENT-LABEL (NEW-VALUE INSTANCE)

THROW-STATEMENT-P (OBJECT)

SETFTHROW-STATEMENT-START (NEW-VALUE INSTANCE)

SETFTHROW-STATEMENT-TARGET (NEW-VALUE INSTANCE)

SETFTHROW-STATEMENT-VALUE (NEW-VALUE INSTANCE)

SETFTHUNK-FUNCTION-BODY (NEW-VALUE INSTANCE)

SETFTHUNK-FUNCTION-END (NEW-VALUE INSTANCE)

SETFTHUNK-FUNCTION-LABEL (NEW-VALUE INSTANCE)

SETFTHUNK-FUNCTION-NAME (NEW-VALUE INSTANCE)

THUNK-FUNCTION-P (OBJECT)

SETFTHUNK-FUNCTION-PARAMETERS (NEW-VALUE INSTANCE)

SETFTHUNK-FUNCTION-START (NEW-VALUE INSTANCE)

SETFTOKEN-END (NEW-VALUE INSTANCE)

TOKEN-P (OBJECT)

SETFTOKEN-START (NEW-VALUE INSTANCE)

SETFTOKEN-TERMINAL (NEW-VALUE INSTANCE)

SETFTOKEN-VALUE (NEW-VALUE INSTANCE)

SETFTRY-BODY (NEW-VALUE INSTANCE)

SETFTRY-CATCH-CLAUSE (NEW-VALUE INSTANCE)

SETFTRY-END (NEW-VALUE INSTANCE)

SETFTRY-FINALLY-CLAUSE (NEW-VALUE INSTANCE)

SETFTRY-LABEL (NEW-VALUE INSTANCE)

TRY-P (OBJECT)

SETFTRY-START (NEW-VALUE INSTANCE)

SETFTYPE-GRAPH-NODE-NAME (NEW-VALUE INSTANCE)

TYPE-GRAPH-NODE-P (OBJECT)

SETFTYPE-GRAPH-NODE-PROPERTIES (NEW-VALUE INSTANCE)

SETFTYPE-GRAPH-NODE-RETURN-NODE (NEW-VALUE INSTANCE)

SETFUNARY-OPERATOR-ARG (NEW-VALUE INSTANCE)

SETFUNARY-OPERATOR-END (NEW-VALUE INSTANCE)

SETFUNARY-OPERATOR-LABEL (NEW-VALUE INSTANCE)

SETFUNARY-OPERATOR-OP-SYMBOL (NEW-VALUE INSTANCE)

UNARY-OPERATOR-P (OBJECT)

SETFUNARY-OPERATOR-START (NEW-VALUE INSTANCE)

UNESCAPE-REGEXP (RE-STRING)

SETFVALUE-NODE-CONSTRUCTOR-NAME (NEW-VALUE INSTANCE)

SETFVALUE-NODE-CONTINUATION-NODE (NEW-VALUE INSTANCE)

SETFVALUE-NODE-NAME (NEW-VALUE INSTANCE)

VALUE-NODE-P (OBJECT)

SETFVALUE-NODE-PARAMETERS (NEW-VALUE INSTANCE)

SETFVALUE-NODE-PROPERTIES (NEW-VALUE INSTANCE)

SETFVALUE-NODE-PROTOTYPE-NODE (NEW-VALUE INSTANCE)

SETFVALUE-NODE-RETURN-NODE (NEW-VALUE INSTANCE)

SETFVALUE-NODE-THIS-CONTEXT-NODE (NEW-VALUE INSTANCE)

SETFVAR-DECL-END (NEW-VALUE INSTANCE)

SETFVAR-DECL-INITIALIZER (NEW-VALUE INSTANCE)

SETFVAR-DECL-LABEL (NEW-VALUE INSTANCE)

SETFVAR-DECL-NAME (NEW-VALUE INSTANCE)

VAR-DECL-P (OBJECT)

SETFVAR-DECL-START (NEW-VALUE INSTANCE)

SETFVAR-DECL-STATEMENT-END (NEW-VALUE INSTANCE)

SETFVAR-DECL-STATEMENT-LABEL (NEW-VALUE INSTANCE)

VAR-DECL-STATEMENT-P (OBJECT)

SETFVAR-DECL-STATEMENT-START (NEW-VALUE INSTANCE)

SETFVAR-DECL-STATEMENT-VAR-DECLS (NEW-VALUE INSTANCE)

SETFWHILE-BODY (NEW-VALUE INSTANCE)

SETFWHILE-CONDITION (NEW-VALUE INSTANCE)

SETFWHILE-END (NEW-VALUE INSTANCE)

SETFWHILE-LABEL (NEW-VALUE INSTANCE)

WHILE-P (OBJECT)

SETFWHILE-START (NEW-VALUE INSTANCE)

SETFWITH-BODY (NEW-VALUE INSTANCE)

SETFWITH-END (NEW-VALUE INSTANCE)

SETFWITH-LABEL (NEW-VALUE INSTANCE)

WITH-P (OBJECT)

SETFWITH-SCOPE-OBJECT (NEW-VALUE INSTANCE)

SETFWITH-START (NEW-VALUE INSTANCE)

MACRO

Private

AIF (TEST-FORM THEN-FORM &OPTIONAL ELSE-FORM)

Anaphoric IF expression; binds IT.

AWHEN (TEST-FORM &BODY BODY)

Anaphoric WHEN expression; binds IT.

DEFPARSER (PARSER-NAME STARTING-PRODUCTION &BODY PRODUCTIONS)

This macro emulates the Lispworks parsergenerator's defparser macro, but instead creates output for CL-YACC

DEFTOKEN (SYMBOL &OPTIONAL KEY TOKEN-TYPE)

Add a token's symbol and possibly string to the appropriate lookups. Different actions will be taken depending upon the TOKEN-TYPE: OPERATOR-TOKENs are infix operators, which are recognized as atomic tokens regardless of whether they are surrounded by whitespace (unlike identifier tokens, for example). KEYWORDs are reserved strings that can never be used as an identifier. OPERATIONs will never be returned by the lexer, but they are used in the source model in the same place as tokens (ie, in :op-symbol slots), so they are treated as tokens for now.

FORBID-TRANSFORMATION-ELEMENTS (XFORM ELM-TYPE-LIST)

Generate DEFMETHOD forms that throw an error if the transformation specified in XFORM is applied to any of the element types in ELM-TYPE-LIST

IN-LOCAL-SCOPE (&BODY BODY)

Execute BODY with *IN-LOCAL-SCOPE* bound to T

RE-COND ((STRING &KEY (START 0)) &REST CLAUSES)

(re-cond (STRING :start START) (REGEXP FORMS*)* If REGEXP matches STRING, then %S, %E, %SUB-S, and %SUB-E will be bound during execution of FORMS

WHEN-LET ((BIND-VAR TEST-FORM) &BODY BODY)

Anaphoric WHEN expression that allows the caller to specify the name of the bound variable

WITH-ADDED-ENVIRONMENT (&BODY BODY)

Executes BODY with a new environment added to the environment stack

WITH-INDENT (&BODY BODY)

Execute the contained forms with *indent* set one step deeper.

WITH-MODULE-OUTPUT ((STREAM-NAME MODULE &KEY APPEND) &BODY BODY)

Outputs to a module, optionally appending

WITH-NESTING (&BODY BODY)

Execute the forms of BODY with *NESTED-CONTEXT* bound to T.

Undocumented

BIND-WITH-BACKCHANNELS ((&REST BINDINGS) FORM &BODY BODY)

DEFELEMENT (NAME &REST SLOTS)

WITH-NON-ESCAPING-BREAK-TARGET ((ELM) &BODY BODY)

WITH-NON-ESCAPING-CONTINUE-TARGET ((ELM) &BODY BODY)

GENERIC-FUNCTION

Private

COLLAPSE-NODES (NODE PATH)

Adds an edge from NODE to each value-node that it has a path to, and removes all other assignment edges. Removes all 'dotted' edges (ie, args, ret, and props) from location-nodes; only value-nodes will have dotted edges after this processing is done. Recursively processes all assignment-children. PATH is a list of nodes representing the path taken to get to this node. Returns all value-nodes encountered so far.

COLLECT-IN-SCOPE (ELM TARGET-TYPE)

Finds and returns a list of all elements of TARGET-TYPE in the same scope as ELM. Does not recurse into function-decl or function-expression elements. So for example, searching for function-decls in this code: var x = 10; function foo(x) { function bar(y) { return 10; } return bar(x); } FOO would be returned but BAR would not, since the decl of BAR is in an innermore scope (namely, FOO's body).

COMPUTE-TYPES (EXPRESSION-ELM GRAPH &OPTIONAL EXECUTION-CONTEXT)

Returns a list of value-nodes representing a set of possible types for the expression represented by EXPRESSION-ELM based on the type-graph GRAPH. EXPRESSION-ELM is evaluated in the global execution context unless EXECUTION-CONTEXT is specified. EXECUTION-CONTEXT can be either NIL (for global context), the name of a function, or a value-node that represents a function.

CONNECT-NODES (NODE GRAPH QUEUE PATH ENV-THIS ENV-RETS ENV-ARGS ENV-MIN ENV-PROPS)

Adds extra connections NODE and its descendants to account for function calls and property-accesses. QUEUE is the queue of nodes to process; CONNECT-NODES may mutate its value. ENV-THIS is a list of this-bindings encountered so far. Every value-node that is encountered will have an edge added from its this-context-node to these nodes. ENV-RET is a list of RET nodes encountered so far; Every value-node that is encountered will have an edge added from its ret-node to each of these nodes. ENV-ARGS is a list of (ARG-INDEX . LOCATION-NODE) cells of arg-bindings encountered so far; value-nodes that are encountered will add edges from their parameter nodes to each of these nodes. ENV-MIN is the minimum of all ancestor nodes' MIN-CALL-ARITY. ENV-PROPS is a list of assoc-cells (PROP-NAME . NODE). Note that there may be more than one cell for a given property name, so it's not safe to use ASSOC.

COPY-TYPE-GRAPH-EDGES (NODE OLD-HASH NEW-HASH)

copy all of the edges of node to edges between the corresponding nodes in new-hash.

COPY-TYPE-GRAPH-NODES (NODE OLD-HASH NEW-HASH)

If NODE is not a member of old-hash, then add NODE to OLD-HASH and an identically-named fresh node to NEW-HASH and then recursively visit all of its descendants.

ELM-ASSOCIATIVITY (OPERATOR-OR-ELM)

Returns either :LEFT, :RIGHT, or NIL to indicate the associativity of the operator represented by OP-SYMBOL-OR-ELM (representing left-, right-, and no-associativity respectively.

ELM-PRECEDENCE (ELM)

Returns an integer specifying the precedence of the source element ELM. Smaller numbers represent higher precedence. The precedence numbers have no significance except relative to each other.

EXPLICITLY-TERMINATED-P (ELM TERMINATORS)

Returns non-NIL if ELM explicitly terminates via all control paths. The definition of 'termination' is configurable by the TERMINATORS argument. TERMINATORS is a list containing any or all of :RETURN :THROW :BREAK :CONTINUE :RESUME :SUSPEND. When :RETURN is in TERMINATORS, return statements are considered to terminate a control path; similarly for the other keywords.

FIND-FREE-VARIABLES (ELM)

Return a list of all the free variables in ELM

INTRODUCES-FN-CALL-P (ELM)

Returns non-NIL if there exists a control path through ELM that contains an effective function call.

POPULATE-NODES (GRAPH ELM)

Analyzes source element ELM and adds nodes and edges to GRAPH based upon that analysis. No transitive analysis is performed (that's for the CONNECT and COLLAPSE phases). Returns a location-node that represents ELM's value for expression elements.

PRETTY-PRINT (ELM STREAM)

Print source element ELM to stream STREAM as parseable and human-readable text.

PRETTY-PRINT-SUBORDINATE (ELM STREAM)

pretty-print source element ELM to stream STREAM as a 'subordinate statement'. This has differing indentation implications depending upon whether or not ELM is a BLOCK.

PRINTABLE-AS-DOT (LITERAL-ELM)

Return true if LITERAL-ELM is a string that could be printed as a valid identifier, and therefore can be used in dotted form for accessing properties in Javascript. Eg: (printable-as-dot #S(string-literal :value "value")) ==> T (printable-as-dot #S(numeric-literal :value 80)) ==> NIL (printable-as-dot #S(string-literal :value "has spaces")) ==> NIL (printable-as-dot #S(string-literal :value "has/punctuation")) ==> NIL

TRANSFORM (XFORM ELM)

Accepts a transformation name (symbol) and a source element, and returns a new source element that has been transformed in some way. Methods should /not/ perform destructive updates on the provided source-element.

TX-CPS (ELM STATEMENT-TAIL)

Converts ELM (which should be explicitized) into CPS form and returns the new version as its first return value. The second return value is T if STATEMENT-TAIL was consumed or NIL otherwise.

TX-EXPLICITIZE (ELM)

Performs the explicitization transformation on ELM and returns two values. The first value is a 'proxy' that should be place in the source tree at the same location that ELM originally occupied. The second value is a list of 'prerequisite' statements that should go immediately before the nearest enclosing statement of ELM. The nearest enclosing statement is a simple statement. The list of prerequisites may be NIL.

WRAP-MODULE (MODULE MODULE-TYPE STREAM)

Outputs HTML to STREAM to cause the wrapper html file to link to MODULE.

Undocumented

CHANNEL-NAME (CONDITION)

SETFCHANNEL-NAME (NEW-VALUE CONDITION)

COLUMN (CONDITION)

EXPECTED-TERMINALS (CONDITION)

FILENAME (CONDITION)

IMPORT-URIPATH (CONDITION)

MESSAGE-VALUE (CONDITION)

SETFMESSAGE-VALUE (NEW-VALUE CONDITION)

PARENT-URIPATH (CONDITION)

POS (CONDITION)

ROW (CONDITION)

TOKEN (CONDITION)

SLOT-ACCESSOR

Private

Undocumented

CURSOR (OBJECT)

SETFCURSOR (NEW-VALUE OBJECT)

ENCOUNTERED-LINE-TERMINATOR (OBJECT)

SETFENCOUNTERED-LINE-TERMINATOR (NEW-VALUE OBJECT)

TEXT (OBJECT)

UNGET-STACK (OBJECT)

SETFUNGET-STACK (NEW-VALUE OBJECT)

VARIABLE

Private

*ADD-HANDLER-PROP*

property name for the 'add exception handler to stack' operation field of a boxed result object

*ADDHANDLER-FN*

Runtime function that adds a new exception handler to the global handler stack

*ARGUMENTS-NAME*

Name of the `arguments` identifier

*CACHED-RUNTIMES*

A lookup table for generating the appropriate runtime depending upon the specified name

*CALL-FN*

Runtime function that we use to make indirect calls with large numbers of arguments to targets that may not be transformed

*CALL0-FN*

Runtime function that we use to make indirect calls with a small number of arguments to targets that may not be transformed

*CALLFROMDIRECT-FN*

Runtime function which will call a transformed function with a trampoline loop and identity continuation

*COMPILER-PIPELINE*

The list of transformations (in order) that are performed to convert jwacs source into Javascript source.

*CONSTRUCTOR-CACHE*

Map from structure-type symbol to copy-function symbol

*CONT-ID*

An identifier whose name is *cont-name*

*CONT-NAME*

The name of the standard continuation parameter

*CONTINUATION-PROPERTY*

The name of the property that we set on each continuation function

*CURRENT-FILENAME*

The name of the file currently being parsed

*CURRENT-HANDLER-STACK-REFERENCE*

Element that refers to the current handler stack. This should be one of *TOPLEVEL-HANDLER-STACK-REFERENCE*, *IN-FUNCTION-HANDLER-STACK-REFERENCE*, or *IN-THUNK-HANDLER-STACK-REFERENCE*.

*CYCLE-FREE-COLLAPSE-PASS*

T if no cycles were encountered on this pass of COLLAPSE-NODES

*DEBUG-EVAL-BOILERPLATE*

Boilerplate code for debug-mode local evaluation

*DEBUG-EVAL-VAR-NAME*

Name of the parameter containing an expression to be evaluated locally for debug-mode thunks

*DEBUG-MODE*

When true, we pack more information into each boxed thunk

*DEBUG-RUNTIME-TEXT*

The text of the debug-mode jwacs runtime

*DEFAULT-IFRAME*

The text of the hidden iframe for bookmark handling

*DEFAULT-TEMPLATE*

The text of the default application template

*DONE-PROP*

property name for the done field of a boxed result object

*END-POS-PROP*

property name for the end-position debug property on boxed thunks

*ENVIRONMENT*

list of assoc lists representing the current lexical environment

*ESCAPE-SCRIPT-END-TAGS*

When non-NIL, escape script end tags (for supporting inline scripts

*ESCAPING-REFERENCES*

List of variable names that are referenced in a statement tail that is going to be reordered into a labelled continuation. We use this to determine when it is safe to convert a variable declaration directly into a continuation parameter, vs when we need to retain the variable declaration and assign it at the beginning of a continuation.

*FUNCTION-DECLS-IN-SCOPE*

A list of names of currently-visible function-decls. We use this to determine which calls need to be indirected through $call, and which can be 'inlined' as unchecked CPS calls. We don't do any handling for duplicate identifiers, since we currently assume that variable names will all have been uglified by this point.

*HANDLER-STACK-K-PROP*

Name of the property on continuations that contains the handler stack to use

*HANDLER-STACK-VAR-NAME*

standard variable name for storing the current handler stack

*IN-FUNCTION-HANDLER-STACK-REFERENCE*

Inside a function but outside of a thunk, the current handler stack is the handler stack property of the function's continuation.

*IN-LOCAL-SCOPE*

T when the lexical scope is currently inside a function decl, NIL when the lexical scope is currently the global scope

*IN-THUNK-HANDLER-STACK-REFERENCE*

Inside a thunk, the current handler stack is passed in as a parameter named `$e`.

*INDENT*

Current indentation level, in spaces (not steps)

*INDENT-STEP*

Number of spaces per indentation step

*INNERMOST-FUNCTION-NODE*

The value-node of the innermost function decl, if any

*KEYWORD-SYMBOLS*

A list of the keyword symbols.

*LEXICALLY-ACTIVE-HANDLERS*

List of handlers that are active in the current lexical scope. These are the handlers that need to be removed just before a value return, or at the beginning of the continuation of a tail call.

*MAKEARGUMENTS-FN*

Runtime function that constructs a shadowing `arguments` object that omits the continuation argument from the numbered arguments (but which includes it as the 'continuation' field)

*MAKEK-FN*

Runtime function called to flag a function expression as a continuation

*MAKELAMBDA-FN*

Runtime function called to flag a function expression as a transformed jwacs function expression

*MAX-CALL0-ARGS*

Maximum number of arguments that can be passed to a function using $call0

*MAX-NEW0-ARGS*

Maximum number of arguments that can be passed to a constructor using $new0

*NEAREST-BREAK*

Name of the break continuation function for the nearest enclosing loop

*NEAREST-CONTINUE*

Name of the continue continuation function for the nearest enclosing loop

*NESTED-CONTEXT*

T when processing nested subexpressions

*NEW-FN*

Runtime function that we use to make indirect constructions with a large number of arguments to constructors that may have been transformed

*NEW0-FN*

Runtime function that we use to make indirect constructions with a small number of arguments to constructors that may have been transformed

*NON-ESCAPING-BREAK-LABELS*

Non-escaping label names that are valid targets for a `break` statement

*NON-ESCAPING-CONTINUE-LABELS*

Non-escaping label names that are valid targets for a `continue` statement

*OPERATOR-TOKENS*

These are operators (as distinct from general tokens) that will be built into a special regular expression. We can't just use the keys from *symbols-to-tokens*, because the order that the tokens appear in this list is significant. Specifically, each 'long' operator must occur before any operator that it is a supersequence of. Eg, '<<<' must occur before '<<', which must occur before '<'. '!=' must occur before both '!' and '='.

*POGO-FUNCTION*

Runtime function that drives trampoline-style programs; We have to add explicit calls to this function for toplevel calls to trampolined functions.

*PRETTY-MODE*

When non-NIL, print nicely (ie, with indentation and newlines). When NIL, print compactly (ie, with no unnecessary whitespace).

*REMOVE-HANDLER-PROP*

property name for the 'remove exception handler from stack' operation field of a boxed result object

*REMOVEHANDLER-FN*

Runtime function that removes the top exception handler from the global handler stack

*REPLACE-HANDLER-STACK-PROP*

property name for the 'replace exception handler stack' operation field of a boxed result object

*RESTRICTED-TOKENS*

Tokens that participate in 'restricted productions'. Value should be either :PRE or :POST. For each of these tokens, the lexer will emit either a :NO-LINE-TERMINATOR or a :LINE-TERMINATOR token depending upon whether the token was preceded/followed by a line-break.

*RESULT-PROP*

property name for the result field of a boxed result object

*RUNTIME-TEXT*

The text of the jwacs runtime

*SHADOWED-ARGUMENTS-NAME*

Name of the variable that currently shadows `arguments`

*SHADOWED-THIS-NAME*

Name of the variable that currently shadows `this`

*START-POS-PROP*

property name for the start-position debug property on boxed thunks

*SYMBOLS-TO-TOKENS*

Map from token symbol to token string. This contains an entry for every token in *tokens-to-symbols*, plus additional entries for the 'operation' symbols.

*THUNK-PROP*

property name for the thunk field of a boxed result object

*TOKENS-TO-SYMBOLS*

Map from string to token symbol. Every symbol that the tokenizer will return is in this map.

*TOPLEVEL-HANDLER-STACK-REFERENCE*

At the toplevel and outside of a thunk, there is no handler stack yet.

*TRANSFORMED-PROPERTY*

The name of the property that we set on each transformed function

FLOATING-RE

Regular expression for recognizing floating-point literals

INTEGER-RE

Regular expression for recognizing integer literals

OPERATOR-RE

Regular expression for recognizing operators

REGEXP-RE

(Lisp) regular expression for recognizing (Javascript) regular expression literals

STRING-RE

Regular expression for recognizing string literals

UNDEFINED-ID

Contains the `undefined` identifier

WHITESPACE-AND-COMMENTS-RE

Regular expression for consuming (and thereby skipping) whitespace and comments

Undocumented

*GENVAR-COUNTER*

*OPT-SPACE*

JAVASCRIPT-SCRIPT

CLASS

Private

ADD-HANDLER

Indicates that a new handler should be added to the handler stack at this point

CONTINUATION-CALL

A call to a continuation (as opposed to a call to any other sort of function)

CONTINUATION-FUNCTION

A function expression that is used as a continuation

EXPRESSION

A common base type for all source elements that can be expressions. (note that every expression can be a statement, but not all statements can be expressions)

JAVASCRIPT-LEXER

Represents the current state of a lexing operation

LOCATION-NODE

A type graph node that represents a location (eg variable, return value, parameter, intermediate value)

MODULE

Represents a single module of a jwacs application

REMOVE-HANDLER

Indicates that a handler should be removed from the top of the handler stack at this point

SOURCE-ELEMENT

A common base type for all source elements

THUNK-FUNCTION

A function expression that is used as a thunk in a boxed trampoline result

TOKEN (CONDITION)

Represents a token returned by the lexer

TYPE-GRAPH-NODE

A node in the type graph

VALUE-NODE

A node in the type graph that represents a value (object, function, number, etc.)

Undocumented

ARRAY-LITERAL

BINARY-OPERATOR

BREAK-STATEMENT

CASE-CLAUSE

CATCH-CLAUSE

COMMA-EXPR

CONDITIONAL

CONTINUE-STATEMENT

DEFAULT-CLAUSE

DO-STATEMENT

FINALLY-CLAUSE

FN-CALL

FOR

FOR-IN

FUNCTION-DECL

FUNCTION-EXPRESSION

IDENTIFIER

IF-STATEMENT

IMPORT-DECL

NEW-EXPR

NODE-QUEUE-CONTAINER

NODE-QUEUE-ENTRY

NUMERIC-LITERAL

OBJECT-LITERAL

PROPERTY-ACCESS

RE-LITERAL

RESUME-STATEMENT

RETURN-STATEMENT

SPECIAL-VALUE

STATEMENT-BLOCK

STRING-LITERAL

SUSPEND-STATEMENT

SWITCH

THROW-STATEMENT

TRY

UNARY-OPERATOR

VAR-DECL

VAR-DECL-STATEMENT

WHILE

WITH

CONDITION

Public

MISSING-IMPORT

Indicates that an import could not be located

SYNTAX-ERROR

Indicates that an error occured during parsing

Private

BACKCHANNEL-MESSAGE

A condition that indicates that a function further down the call chain has a message to pass back. BACKCHANNEL-MESSAGE should never be directly instantiated or used; use BIND-WITH-BACKCHANNELS and BACKCHANNEL-SIGNAL instead.

POSITIONED-CONDITION

Represents a condition that has a source position associated with it