The closure-template Reference Manual

Table of Contents

The closure-template Reference Manual

This is the closure-template Reference Manual, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:01:48 2018 GMT+0.

1 Introduction

cl-closure-template - Common Lisp implementation of Closure Template from Google

Sample Code

 CL-USER> (asdf:operate 'asdf:load-op '#:closure-template)

 CL-USER> (defparameter *template* "
 /*
  *  Greets a person using 'Hello' by default.
  */
{namespace closureTemplate.Example}
{template helloName}
   {if not $greetingWorld}
      Hello {$name}!
   {else}
      {$greetingWorld} {$name}!
    {/if}
{/template}")
*TEMPLATE*


CL-USER> (closure-template:compile-template :common-lisp-backend *template*)
#<PACKAGE "CLOSURETEMPLATE.EXAMPLE">
CL-USER> (closuretemplate.example:hello-name '(:name "Andrey"))
"Hello Andrey!"
CL-USER> (closure-template.example:hello-name '(:name "Andrey" :greeting-world "Hi"))
"Hi Andrey!"


CL-USER> (closure-template:compile-template :javascript-backend *template*)
"if (typeof closureTemplate === 'undefined') { closureTemplate = {}; }
if (typeof closureTemplate.Example === 'undefined') { closureTemplate.Example = {}; }

closureTemplate.Example.$isEmpty$ = function (obj) {
    for (var prop in obj) if (obj.hasOwnProperty(prop)) return false;
    return true;
};

closureTemplate.Example.$escapeHTML$ = function (obj) {
    if (typeof obj == 'string') return String(obj).split('&').join('&amp;').split( '<').join('&lt;').split('>').join('&gt;').split('\\\"').join('&quot;').split('\\'').join('&#039;');
    else return obj;
};

closureTemplate.Example.$round$ = function (number, ndigits) {
    if (ndigits) {
        var factor = Math.pow(10.0, ndigits);
        return Math.round(number * factor) / factor;
    }
    else return Math.round(number)
};

closureTemplate.Example.$objectFromPrototype$ = function (obj) {
    function C () {}
    C.prototype = obj;
    return new C;
};

closureTemplate.Example.helloName = function($env$, $target$) {
    if (!$env$) { $env$ = {}; }
    var $result$ = $target$ || [];

    if (!$env$.greetingWorld) {
        $result$.push(\"Hello \");
        $result$.push(closureTemplate.Example.$escapeHTML$($env$.name));
        $result$.push(\"!\");
    }
    else {
        $result$.push(closureTemplate.Example.$escapeHTML$($env$.greetingWorld));
        $result$.push(\" \");
        $result$.push(closureTemplate.Example.$escapeHTML$($env$.name));
        $result$.push(\"!\");
    }

    if (!$target$) return $result$.join('');
    else return null;
};
"

CL-USER> (closure-template:compile-template :requirejs-backend *template*)
"define(function () {
var module = { };
module.$isEmpty$ = function (obj) {
    for (var prop in obj) if (obj.hasOwnProperty(prop)) return false;
    return true;
};

module.$escapeHTML$ = function (obj) {
    if (typeof obj == 'string') return String(obj).split('&').join('&amp;').split( '<').join('&lt;').split('>').join('&gt;').split('\\\"').join('&quot;').split('\\'').join('&#039;');
    else return obj;
};

module.$round$ = function (number, ndigits) {
    if (ndigits) {
        var factor = Math.pow(10.0, ndigits);
        return Math.round(number * factor) / factor;
    }
    else return Math.round(number)
};

module.$objectFromPrototype$ = function (obj) {
    function C () {}
    C.prototype = obj;
    return new C;
};

module.helloName = function($env$, $target$) {
    if (!$env$) { $env$ = {}; }
    var $result$ = $target$ || [];

    if (!$env$.greetingWorld) {
        $result$.push(\"Hello \");
        $result$.push(module.$escapeHTML$($env$.name));
        $result$.push(\"!\");
    }
    else {
        $result$.push(module.$escapeHTML$($env$.greetingWorld));
        $result$.push(\" \");
        $result$.push(module.$escapeHTML$($env$.name));
        $result$.push(\"!\");
    }

    if (!$target$) return $result$.join('');
    else return null;
};
return module; });"

Adding Custom Print Directives

You can add custom print directives. For example, printing integers as hexadecimal values:

CL-USER> (closure-template:define-print-syntax printHex "hex" (:constant t)) 
CLOSURE-TEMPLATE.PARSER::PRINT-DIRECTIVE
CL-USER> (closure-template:register-print-handler :common-lisp-backend 'printHex :function #'(lambda (params end value) (format nil "~X" value)))
#<Anonymous Function #x302001B7085F>
CL-USER> (defparameter *template* "
     /*
      *  Greets a person using 'Hello' by default.
      */
    {namespace closureTemplate.Example}
    {template helloName}
    Hello {$name} {$param|hex}!
    {/template}")
*TEMPLATE*
CL-USER> (closure-template:compile-template :common-lisp-backend *template*)
#<Package "CLOSURE-TEMPLATE.EXAMPLE">
CL-USER> (closure-template.example:hello-Name '(:name "Name" :param 128))
"Hello Name 80!"

To use Javascript backend, you need to register a handler for Javascript or RequireJS backends. This is a more complex example which shows how to handle parameters of the directive:

CL-USER> (closure-template:define-print-syntax printHex (and "hex" (esrap:? (and ":" (or "upper" "lower"))))
           (:destructure (tag value)
                         (declare (ignore tag))
                         (list (if (and value (string= (second value) "lower")) 'case-lower 'case-upper))))
PRINT-HEX
CL-USER> (closure-template:register-print-handler :common-lisp-backend 'printHex
                                                  :function #'(lambda (params env value)
                                                                (declare (ignore env))
                                                                (format nil (if (member 'case-lower params) "~(~X~)" "~X") value)))
PRINT-HEX
CL-USER> (closure-template:register-print-handler :javascript-backend 'printHex
                                         :handler "function (params, value) { var result = value.toString(16); if (params.case == \"upper\") { result = result.toUpperCase(); } return result; }"
                                         :parameter-converter #'(lambda (params)
                                                                  (format nil "{ case: \"~A\"; }" (if (member 'case-lower params) "lower" "upper"))))

PRINTHEX
CL-USER> (defparameter *template* "
     /*
      *  Greets a person using 'Hello' by default.
      */
    {namespace closureTemplate.Example}
    {template helloName}
    Hello {$name} {$param|hex:lower}!
    {/template}")
*TEMPLATE*
CL-USER> (closure-template.example:hello-name '(name "Name" :param 143))
"Hello Name 8F!"

You can also use a predefined function by name or RequireJS module. For detals, please see docstrings for REGISTER-PRINT-HANDLER implementations.

2 Systems

The main system appears first, followed by any subsystem dependency.

2.1 closure-template

Dependencies

• babel
• parse-number
• esrap
• iterate
• closer-mop
• split-sequence
• alexandria

Source

closure-template.asd (file)

Components

• parser (module)
• defpackage.lisp (file)
• interface.lisp (file)
• asdf.lisp (file)
• common-lisp-backend (module)
• standard-templates.lisp (file)
• javascript-backend (module)

3 Modules

Modules are listed depth-first from the system components tree.

3.1 closure-template/parser

Parent

closure-template (system)

Location

parser/

Components

• defpackage.lisp (file)
• command.lisp (file)
• expression.lisp (file)

3.2 closure-template/common-lisp-backend

Dependency

asdf.lisp (file)

Parent

closure-template (system)

Location

Components

• escape.lisp (file)
• common-lisp-backend.lisp (file)

3.3 closure-template/javascript-backend

Dependency

standard-templates.lisp (file)

Parent

closure-template (system)

Location

Component

javascript-backend.lisp (file)

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.

4.1 Lisp

4.1.1 closure-template.asd

Location

/home/quickref/quicklisp/dists/quicklisp/software/cl-closure-template-20150804-git/closure-template.asd

Systems

closure-template (system)

4.1.2 closure-template/parser/defpackage.lisp

Parent

parser (module)

Location

parser/defpackage.lisp

Packages

closure-template.parser

Exported Definitions

• *uglify* (special variable)
• closure-template-parse (function)
• lispify-name (function)
• lispify-string (function)
• not-equal (function)

Internal Definitions

• *closure-template-rules* (special variable)
• define-rule (macro)
• with-closure-template-rules (macro)

4.1.3 closure-template/parser/command.lisp

Dependency

defpackage.lisp (file)

Parent

parser (module)

Location

parser/command.lisp

Exported Definitions

• call (class)
• call-data (method)
• call-name (method)
• call-namespace (method)
• call-params (method)
• comment (class)
• comment-multiline-p (method)
• comment-text (method)
• define-print-syntax (macro)
• for-code-block (method)
• for-command (class)
• for-range (method)
• for-varname (method)
• foreach (class)
• foreach-code-block (method)
• foreach-expression (method)
• foreach-if-empty-code (method)
• foreach-varname (method)
• if-command (class)
• if-command-options (method)
• literal (class)
• literal-content (method)
• namespace (class)
• namespace-name (method)
• namespace-templates (method)
• parse-template (function)
• print-command (class)
• print-directives (method)
• print-expression (method)
• switch-cases (method)
• switch-command (class)
• switch-default (method)
• switch-expression (method)
• template (class)
• template-code-block (method)
• template-name (method)
• template-properties (method)
• user-print-directive-p (function)
• with-body (method)
• with-vars (method)

Internal Definitions

• *substitiotn-map* (special variable)
• +standard-print-directives+ (special variable)
• check-expression-p (function)
• define-print-directive (macro)
• define-substitions (macro)
• parse-template-name (function)
• replace-substition (function)
• simple-text-char-p (function)
• simplify-code (function)
• text-neighboring-strings (function)
• trim-whitespace (function)

4.1.4 closure-template/parser/expression.lisp

Dependency

command.lisp (file)

Parent

parser (module)

Location

parser/expression.lisp

Exported Definitions

• add-possible-function (function)
• arref (class)
• arref-position (method)
• dotref (class)
• dotref-jsname (method)
• dotref-name (method)
• fcall (class)
• fcall-args (method)
• fcall-jsname (method)
• fcall-name (method)
• injected-data (class)
• list-expr (class)
• list-expr-values (method)
• map-expr (class)
• map-expr-items (method)
• op-args (method)
• op-name (method)
• operator (class)
• parse-expression (function)
• ref-expr (method)
• var (class)
• var-jsname (method)
• var-name (method)

Internal Definitions

• *infix-ops-priority* (special variable)
• *possible-functions* (special variable)
• ->prefix (function)
• define-escape-sequence (macro)
• define-operator (macro)
• not-quote-p (function)
• reduce-infix (function)
• reduce-ref (function)
• ref (class)
• replace-subseq (function)

4.1.5 closure-template/defpackage.lisp

Dependency

parser (module)

Parent

closure-template (system)

Location

defpackage.lisp

Packages

closure-template

4.1.6 closure-template/interface.lisp

Dependency

defpackage.lisp (file)

Parent

closure-template (system)

Location

interface.lisp

Exported Definitions

• compile-template (generic function)
• register-print-handler (generic function)

4.1.7 closure-template/asdf.lisp

Dependencies

• interface.lisp (file)
• defpackage.lisp (file)

Parent

closure-template (system)

Location

asdf.lisp

Exported Definitions

closure-template (class)

4.1.8 closure-template/common-lisp-backend/escape.lisp

Parent

common-lisp-backend (module)

Location

escape.lisp

Exported Definitions

• decode-uri (function)
• encode-uri (function)
• encode-uri-component (function)
• escape-html (function)

Internal Definitions

encode-string (function)

4.1.9 closure-template/common-lisp-backend/common-lisp-backend.lisp

Dependency

escape.lisp (file)

Parent

common-lisp-backend (module)

Location

common-lisp-backend.lisp

Exported Definitions

• *default-closure-template-package* (special variable)
• *injected-data* (special variable)
• *ttable* (special variable)
• compile-cl-templates (function)
• compile-template (method)
• compile-template (method)
• compile-template (method)
• ensure-ttable-package (function)
• fetch-keys (generic function)
• fetch-keys (method)
• fetch-keys (method)
• fetch-keys (method)
• fetch-keys (method)
• fetch-property (generic function)
• fetch-property (method)
• fetch-property (method)
• fetch-property (method)
• fetch-property (method)
• fetch-property (method)
• fetch-property (method)
• package-ttable (function)
• register-print-handler (method)
• ttable (class)
• ttable-call-template (function)
• ttable-extend-package (function)
• ttable-find-template (function)
• ttable-register-template (function)
• with-user-functions (macro)

Internal Definitions

• %!= (function)
• %+ (function)
• %is-nonnull (function)
• %nonblank (generic function)
• %nonblank (method)
• %nonblank (method)
• %nonblank (method)
• %nonblank (method)
• %nonblank (method)
• %nonblank (method)
• %nonblank (method)
• %round (function)
• %same-name (generic function)
• %same-name (method)
• %same-name (method)
• %same-name (method)
• %same-name (method)
• %same-name (method)
• %same-name (method)
• %same-name (method)
• %str-contains (function)
• *autoescape* (special variable)
• *loops-vars* (special variable)
• *template-data* (special variable)
• *user-functions* (special variable)
• *user-print-directive-handlers* (special variable)
• add-user-function (function)
• common-lisp-backend (class)
• compile-namespace (function)
• dict (class)
• find-user-function (function)
• has-data (function)
• index (function)
• is-first (function)
• is-last (function)
• make-all-user-print-directives-handler (function)
• make-and-handler (function)
• make-boolean-expression-handler (function)
• make-call-data-handler (function)
• make-code-block-handler (function)
• make-command-handler (generic function)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-dict (function)
• make-expression-handler (generic function)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-foreach-function-handler (function)
• make-function-handler (function)
• make-if-operator-handler (function)
• make-not-handler (function)
• make-or-handler (function)
• make-param-handler (function)
• make-switch-command-handler (function)
• make-user-print-directive-handler (function)
• ttable-hash (method)
• ttable-prototype (method)
• ttable-template-name-list (function)
• write-template-atom (function)

4.1.10 closure-template/standard-templates.lisp

Dependency

common-lisp-backend (module)

Parent

closure-template (system)

Location

standard-templates.lisp

4.1.11 closure-template/javascript-backend/javascript-backend.lisp

Parent

javascript-backend (module)

Location

javascript-backend.lisp

Exported Definitions

• compile-js-templates (method)
• compile-template (method)
• compile-template (method)
• compile-template (method)
• compile-template (method)
• compile-template (method)
• register-print-handler (method)
• register-print-handler (method)

Internal Definitions

• %js (function)
• *indent-level* (special variable)
• *js-custom-print-handlers* (special variable)
• *js-namespace* (special variable)
• *local-variables* (special variable)
• *requirejs-custom-print-handlers* (special variable)
• *requirejs-deps* (special variable)
• *symbol-counter* (special variable)
• +json-lisp-escaped-chars+ (special variable)
• +reserved-js-words+ (special variable)
• compile-to-js (generic function)
• compile-to-js (method)
• compile-to-js (method)
• compile-to-requirejs (function)
• copy-print-handler (function)
• javascript-backend (class)
• make-print-handler (function)
• print-handler (structure)
• print-handler-impl (function)
• (setf print-handler-impl) (function)
• print-handler-module (function)
• (setf print-handler-module) (function)
• print-handler-name (function)
• (setf print-handler-name) (function)
• print-handler-p (function)
• print-handler-param-converter (function)
• (setf print-handler-param-converter) (function)
• requirejs-backend (class)
• with-increase-indent (macro)
• with-local-var (macro)
• with-write-parenthesis (macro)
• write-call-name (function)
• write-call-with-params (function)
• write-call-without-params (function)
• write-command (generic function)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-custom-print-directives (function)
• write-expression (generic function)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-indent (function)
• write-namespace (function)
• write-namespace-body (function)
• write-namespace-declaration (function)
• write-namespace-helpers (function)
• write-template (function)

5 Packages

Packages are listed by definition order.

5.1 closure-template.parser

Source

defpackage.lisp (file)

Use List

• esrap
• iterate
• common-lisp

Used By List

closure-template

Exported Definitions

• *uglify* (special variable)
• add-possible-function (function)
• arref (class)
• arref-position (generic function)
• arref-position (method)
• call (class)
• call-data (generic function)
• call-data (method)
• call-name (generic function)
• call-name (method)
• call-namespace (generic function)
• call-namespace (method)
• call-params (generic function)
• call-params (method)
• closure-template-parse (function)
• comment (class)
• comment-multiline-p (generic function)
• comment-multiline-p (method)
• comment-text (generic function)
• comment-text (method)
• define-print-syntax (macro)
• dotref (class)
• dotref-jsname (generic function)
• dotref-jsname (method)
• dotref-name (generic function)
• dotref-name (method)
• fcall (class)
• fcall-args (generic function)
• fcall-args (method)
• fcall-jsname (generic function)
• fcall-jsname (method)
• fcall-name (generic function)
• fcall-name (method)
• for-code-block (generic function)
• for-code-block (method)
• for-command (class)
• for-range (generic function)
• for-range (method)
• for-varname (generic function)
• for-varname (method)
• foreach (class)
• foreach-code-block (generic function)
• foreach-code-block (method)
• foreach-expression (generic function)
• foreach-expression (method)
• foreach-if-empty-code (generic function)
• foreach-if-empty-code (method)
• foreach-varname (generic function)
• foreach-varname (method)
• if-command (class)
• if-command-options (generic function)
• if-command-options (method)
• injected-data (class)
• lispify-name (function)
• lispify-string (function)
• list-expr (class)
• list-expr-values (generic function)
• list-expr-values (method)
• literal (class)
• literal-content (generic function)
• literal-content (method)
• map-expr (class)
• map-expr-items (generic function)
• map-expr-items (method)
• namespace (class)
• namespace-name (generic function)
• namespace-name (method)
• namespace-templates (generic function)
• namespace-templates (method)
• not-equal (function)
• op-args (generic function)
• op-args (method)
• op-name (generic function)
• op-name (method)
• operator (class)
• parse-expression (function)
• parse-template (function)
• print-command (class)
• print-directives (generic function)
• print-directives (method)
• print-expression (generic function)
• print-expression (method)
• ref-expr (generic function)
• ref-expr (method)
• switch-cases (generic function)
• switch-cases (method)
• switch-command (class)
• switch-default (generic function)
• switch-default (method)
• switch-expression (generic function)
• switch-expression (method)
• template (class)
• template-code-block (generic function)
• template-code-block (method)
• template-name (generic function)
• template-name (method)
• template-properties (generic function)
• template-properties (method)
• user-print-directive-p (function)
• var (class)
• var-jsname (generic function)
• var-jsname (method)
• var-name (generic function)
• var-name (method)
• with-body (generic function)
• with-body (method)
• with-vars (generic function)
• with-vars (method)

Internal Definitions

• *closure-template-rules* (special variable)
• *infix-ops-priority* (special variable)
• *possible-functions* (special variable)
• *substitiotn-map* (special variable)
• +standard-print-directives+ (special variable)
• ->prefix (function)
• check-expression-p (function)
• define-escape-sequence (macro)
• define-operator (macro)
• define-print-directive (macro)
• define-rule (macro)
• define-substitions (macro)
• not-quote-p (function)
• parse-template-name (function)
• reduce-infix (function)
• reduce-ref (function)
• ref (class)
• replace-subseq (function)
• replace-substition (function)
• simple-text-char-p (function)
• simplify-code (function)
• text-neighboring-strings (function)
• trim-whitespace (function)
• with-closure-template-rules (macro)

5.2 closure-template

Source

defpackage.lisp (file)

Use List

• closure-template.parser
• alexandria.0.dev
• iterate
• common-lisp

Exported Definitions

• *default-closure-template-package* (special variable)
• *injected-data* (special variable)
• *ttable* (special variable)
• closure-template (class)
• compile-cl-templates (function)
• compile-js-templates (generic function)
• compile-js-templates (method)
• compile-template (generic function)
• compile-template (method)
• compile-template (method)
• compile-template (method)
• compile-template (method)
• compile-template (method)
• compile-template (method)
• compile-template (method)
• compile-template (method)
• decode-uri (function)
• encode-uri (function)
• encode-uri-component (function)
• ensure-ttable-package (function)
• escape-html (function)
• fetch-keys (generic function)
• fetch-keys (method)
• fetch-keys (method)
• fetch-keys (method)
• fetch-keys (method)
• fetch-property (generic function)
• fetch-property (method)
• fetch-property (method)
• fetch-property (method)
• fetch-property (method)
• fetch-property (method)
• fetch-property (method)
• package-ttable (function)
• register-print-handler (generic function)
• register-print-handler (method)
• register-print-handler (method)
• register-print-handler (method)
• ttable (class)
• ttable-call-template (function)
• ttable-extend-package (function)
• ttable-find-template (function)
• ttable-register-template (function)
• with-user-functions (macro)

Internal Definitions

• %!= (function)
• %+ (function)
• %is-nonnull (function)
• %js (function)
• %nonblank (generic function)
• %nonblank (method)
• %nonblank (method)
• %nonblank (method)
• %nonblank (method)
• %nonblank (method)
• %nonblank (method)
• %nonblank (method)
• %round (function)
• %same-name (generic function)
• %same-name (method)
• %same-name (method)
• %same-name (method)
• %same-name (method)
• %same-name (method)
• %same-name (method)
• %same-name (method)
• %str-contains (function)
• *autoescape* (special variable)
• *indent-level* (special variable)
• *js-custom-print-handlers* (special variable)
• *js-namespace* (special variable)
• *local-variables* (special variable)
• *loops-vars* (special variable)
• *requirejs-custom-print-handlers* (special variable)
• *requirejs-deps* (special variable)
• *symbol-counter* (special variable)
• *template-data* (special variable)
• *user-functions* (special variable)
• *user-print-directive-handlers* (special variable)
• +json-lisp-escaped-chars+ (special variable)
• +reserved-js-words+ (special variable)
• add-user-function (function)
• common-lisp-backend (class)
• compile-namespace (function)
• compile-to-js (generic function)
• compile-to-js (method)
• compile-to-js (method)
• compile-to-requirejs (function)
• copy-print-handler (function)
• dict (class)
• encode-string (function)
• find-user-function (function)
• has-data (function)
• index (function)
• is-first (function)
• is-last (function)
• javascript-backend (class)
• make-all-user-print-directives-handler (function)
• make-and-handler (function)
• make-boolean-expression-handler (function)
• make-call-data-handler (function)
• make-code-block-handler (function)
• make-command-handler (generic function)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-command-handler (method)
• make-dict (function)
• make-expression-handler (generic function)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-expression-handler (method)
• make-foreach-function-handler (function)
• make-function-handler (function)
• make-if-operator-handler (function)
• make-not-handler (function)
• make-or-handler (function)
• make-param-handler (function)
• make-print-handler (function)
• make-switch-command-handler (function)
• make-user-print-directive-handler (function)
• print-handler (structure)
• print-handler-impl (function)
• (setf print-handler-impl) (function)
• print-handler-module (function)
• (setf print-handler-module) (function)
• print-handler-name (function)
• (setf print-handler-name) (function)
• print-handler-p (function)
• print-handler-param-converter (function)
• (setf print-handler-param-converter) (function)
• requirejs-backend (class)
• ttable-hash (generic function)
• ttable-hash (method)
• ttable-prototype (generic function)
• ttable-prototype (method)
• ttable-template-name-list (function)
• with-increase-indent (macro)
• with-local-var (macro)
• with-write-parenthesis (macro)
• write-call-name (function)
• write-call-with-params (function)
• write-call-without-params (function)
• write-command (generic function)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-command (method)
• write-custom-print-directives (function)
• write-expression (generic function)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-expression (method)
• write-indent (function)
• write-namespace (function)
• write-namespace-body (function)
• write-namespace-declaration (function)
• write-namespace-helpers (function)
• write-template (function)
• write-template-atom (function)

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.

6.1 Exported definitions

6.1.1 Special variables

Special Variable: *default-closure-template-package*

Package

closure-template

Source

common-lisp-backend.lisp (file)

Special Variable: *injected-data*

Package

closure-template

Source

common-lisp-backend.lisp (file)

Special Variable: *ttable*

Package

closure-template

Source

common-lisp-backend.lisp (file)

Special Variable: *uglify*

Package

closure-template.parser

Source

defpackage.lisp (file)

6.1.2 Macros

Macro: define-print-syntax SYMBOL EXPR &body RULE

Define a syntax rule for a new user print directive which is identified by SYMBOL. EXPR defines a grammar of the new directive without whitespace and the "|" delimiter. The body of definition should contain semantic rules used to convert possible parameters of the directive

Package

closure-template.parser

Source

command.lisp (file)

Macro: with-user-functions (&rest FUNCTIONS) &body BODY

Executes body with possibility to call specified functions from templates.
Usage: (with-user-functions (("incr" #’1+))
(closure-template:compile-template :common-lisp-backend "{template test} x + 1 = {incr($x)}{/template}"))

Package

closure-template

Source

common-lisp-backend.lisp (file)

6.1.3 Functions

Function: add-possible-function NAME

Package

closure-template.parser

Source

expression.lisp (file)

Function: closure-template-parse SYMBOL TEXT

Package

closure-template.parser

Source

defpackage.lisp (file)

Function: compile-cl-templates TEMPLATES

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: decode-uri STRING

Replaces each escape sequence in the encoded URI with the character that it represents.

Package

closure-template

Source

escape.lisp (file)

Function: encode-uri STR

Package

closure-template

Source

escape.lisp (file)

Function: encode-uri-component STR

Package

closure-template

Source

escape.lisp (file)

Function: ensure-ttable-package NAME &key PROTOTYPE

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: escape-html STR

Package

closure-template

Source

escape.lisp (file)

Function: lispify-name STR

Package

closure-template.parser

Source

defpackage.lisp (file)

Function: lispify-string STR

Package

closure-template.parser

Source

defpackage.lisp (file)

Function: not-equal OBJ1 OBJ2

Package

closure-template.parser

Source

defpackage.lisp (file)

Function: package-ttable PACKAGE

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: parse-expression TEXT

Package

closure-template.parser

Source

expression.lisp (file)

Function: parse-template OBJ

Package

closure-template.parser

Source

command.lisp (file)

Function: ttable-call-template TTABLE NAME ENV &optional OUT

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: ttable-extend-package TTABLE PACKAGE

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: ttable-find-template TTABLE LNAME

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: ttable-register-template TTABLE LNAME TEMPLATE &key SUPERSEDE

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: user-print-directive-p SYMBOL

Package

closure-template.parser

Source

command.lisp (file)

6.1.4 Generic functions

Generic Function: arref-position OBJECT

Package

closure-template.parser

Methods

Method: arref-position (ARREF arref)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: call-data OBJECT

Package

closure-template.parser

Methods

Method: call-data (CALL call)

automatically generated reader method

Source

command.lisp (file)

Generic Function: call-name OBJECT

Package

closure-template.parser

Methods

Method: call-name (CALL call)

automatically generated reader method

Source

command.lisp (file)

Generic Function: call-namespace OBJECT

Package

closure-template.parser

Methods

Method: call-namespace (CALL call)

automatically generated reader method

Source

command.lisp (file)

Generic Function: call-params OBJECT

Package

closure-template.parser

Methods

Method: call-params (CALL call)

automatically generated reader method

Source

command.lisp (file)

Generic Function: comment-multiline-p OBJECT

Package

closure-template.parser

Methods

Method: comment-multiline-p (COMMENT comment)

automatically generated reader method

Source

command.lisp (file)

Generic Function: comment-text OBJECT

Package

closure-template.parser

Methods

Method: comment-text (COMMENT comment)

automatically generated reader method

Source

command.lisp (file)

Generic Function: compile-js-templates TEMPLATES

Package

closure-template

Methods

Method: compile-js-templates TEMPLATES

Source

javascript-backend.lisp (file)

Generic Function: compile-template BACKEND TEMPLATE

Compile templates from TEMPLATE using BACKEND as target language

Package

closure-template

Source

interface.lisp (file)

Methods

Method: compile-template (BACKEND javascript-backend) (TEMPLATES list)

Source

javascript-backend.lisp (file)

Method: compile-template (BACKEND requirejs-backend) TEMPLATE

Source

javascript-backend.lisp (file)

Method: compile-template (BACKEND javascript-backend) TEMPLATE

Source

javascript-backend.lisp (file)

Method: compile-template (BACKEND (eql requirejs-backend)) TEMPLATE

Source

javascript-backend.lisp (file)

Method: compile-template (BACKEND (eql javascript-backend)) TEMPLATE

Source

javascript-backend.lisp (file)

Method: compile-template (BACKEND common-lisp-backend) (TEMPLATES list)

Source

common-lisp-backend.lisp (file)

Method: compile-template (BACKEND common-lisp-backend) TEMPLATE

Source

common-lisp-backend.lisp (file)

Method: compile-template (BACKEND (eql common-lisp-backend)) TEMPLATE

Source

common-lisp-backend.lisp (file)

Generic Function: dotref-jsname OBJECT

Package

closure-template.parser

Methods

Method: dotref-jsname (DOTREF dotref)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: dotref-name OBJECT

Package

closure-template.parser

Methods

Method: dotref-name (DOTREF dotref)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: fcall-args OBJECT

Package

closure-template.parser

Methods

Method: fcall-args (FCALL fcall)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: fcall-jsname OBJECT

Package

closure-template.parser

Methods

Method: fcall-jsname (FCALL fcall)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: fcall-name OBJECT

Package

closure-template.parser

Methods

Method: fcall-name (FCALL fcall)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: fetch-keys MAP

Package

closure-template

Source

common-lisp-backend.lisp (file)

Methods

Method: fetch-keys (MAP dict)

Method: fetch-keys (MAP hash-table)

Method: fetch-keys (MAP list)

Method: fetch-keys (OBJ standard-object)

Generic Function: fetch-property MAP KEY

Package

closure-template

Source

common-lisp-backend.lisp (file)

Methods

Method: fetch-property (MAP dict) KEY

Method: fetch-property MAP (KEY integer)

Method: fetch-property (MAP list) (KEY integer)

Method: fetch-property (MAP hash-table) KEY

Method: fetch-property (MAP list) KEY

Method: fetch-property (OBJ standard-object) KEY

Generic Function: for-code-block OBJECT

Package

closure-template.parser

Methods

Method: for-code-block (FOR-COMMAND for-command)

automatically generated reader method

Source

command.lisp (file)

Generic Function: for-range OBJECT

Package

closure-template.parser

Methods

Method: for-range (FOR-COMMAND for-command)

automatically generated reader method

Source

command.lisp (file)

Generic Function: for-varname OBJECT

Package

closure-template.parser

Methods

Method: for-varname (FOR-COMMAND for-command)

automatically generated reader method

Source

command.lisp (file)

Generic Function: foreach-code-block OBJECT

Package

closure-template.parser

Methods

Method: foreach-code-block (FOREACH foreach)

automatically generated reader method

Source

command.lisp (file)

Generic Function: foreach-expression OBJECT

Package

closure-template.parser

Methods

Method: foreach-expression (FOREACH foreach)

automatically generated reader method

Source

command.lisp (file)

Generic Function: foreach-if-empty-code OBJECT

Package

closure-template.parser

Methods

Method: foreach-if-empty-code (FOREACH foreach)

automatically generated reader method

Source

command.lisp (file)

Generic Function: foreach-varname OBJECT

Package

closure-template.parser

Methods

Method: foreach-varname (FOREACH foreach)

automatically generated reader method

Source

command.lisp (file)

Generic Function: if-command-options OBJECT

Package

closure-template.parser

Methods

Method: if-command-options (IF-COMMAND if-command)

automatically generated reader method

Source

command.lisp (file)

Generic Function: list-expr-values OBJECT

Package

closure-template.parser

Methods

Method: list-expr-values (LIST-EXPR list-expr)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: literal-content OBJECT

Package

closure-template.parser

Methods

Method: literal-content (LITERAL literal)

automatically generated reader method

Source

command.lisp (file)

Generic Function: map-expr-items OBJECT

Package

closure-template.parser

Methods

Method: map-expr-items (MAP-EXPR map-expr)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: namespace-name OBJECT

Package

closure-template.parser

Methods

Method: namespace-name (NAMESPACE namespace)

automatically generated reader method

Source

command.lisp (file)

Generic Function: namespace-templates OBJECT

Package

closure-template.parser

Methods

Method: namespace-templates (NAMESPACE namespace)

automatically generated reader method

Source

command.lisp (file)

Generic Function: op-args OBJECT

Package

closure-template.parser

Methods

Method: op-args (OPERATOR operator)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: op-name OBJECT

Package

closure-template.parser

Methods

Method: op-name (OPERATOR operator)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: print-directives OBJECT

Package

closure-template.parser

Methods

Method: print-directives (PRINT-COMMAND print-command)

automatically generated reader method

Source

command.lisp (file)

Generic Function: print-expression OBJECT

Package

closure-template.parser

Methods

Method: print-expression (PRINT-COMMAND print-command)

automatically generated reader method

Source

command.lisp (file)

Generic Function: ref-expr OBJECT

Package

closure-template.parser

Methods

Method: ref-expr (REF ref)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: register-print-handler BACKEND DIRECTIVE &rest OPTIONS

Register handler for custom print directive in BACKEND.
Directive syntax is defined by DIRECTIVE. Actual handler parameters are depend on backend type.

Package

closure-template

Source

interface.lisp (file)

Methods

Method: register-print-handler (BACKEND (eql requirejs-backend)) DIRECTIVE &rest PARAMS

Register DIRECTIVE handler for Javascript backend.
The following parameters are accepted:
:HANDLER - string which defines actual Javascript handler like "function (params, value) { }";
:FUNCTION - string with name of handler function (it should be defined elsewhere with
prototype similar to above);
:MODULE - RequireJS module which implements :FUNCTION.
:PARAMETER-CONVERTER - lambda which accepts data from parser and returns string parameters for handler.

:HANDLER or :FUNCTION are required, :PARAMETER-CONVERTER and :MODULE are optional. If :PARAMETER-CONVERTER is NIL or it returns NIL or empty string then "params" argument will be omitted in call to handler. if :MODULE not is missing it should contain URI of the RequireJS module which implements function :FUNCTION. :MODULE it not used when :HANDLER is specified

Source

javascript-backend.lisp (file)

Method: register-print-handler (BACKEND (eql javascript-backend)) DIRECTIVE &rest PARAMS

Register DIRECTIVE handler for Javascript backend.
The following parameters are accepted:
:HANDLER - string which defines actual Javascript handler like "function (params, value) { }"; :FUNCTION - string with name of handler function (it should be defined elsewhere with
prototype similar to above);
:PARAMETER-CONVERTER - lambda which accepts data from parser and returns string parameters for handler.

:HANDLER or :FUNCTION are required, :PARAMETER-CONVERTER is optional. If :PARAMETER-CONVERTER is NIL or it returns NIL or empty string then "params" argument will be omitted in call to handler.

Source

javascript-backend.lisp (file)

Method: register-print-handler (BACKEND-TYPE (eql common-lisp-backend)) DIRECTIVE &rest ARGS

Register handler for print DIRECTIVE in the BACKEND. ARGS must contain symbol :FUNCTION and lambda function with prototype (lambda (parameters environment value))

Source

common-lisp-backend.lisp (file)

Generic Function: switch-cases OBJECT

Package

closure-template.parser

Methods

Method: switch-cases (SWITCH-COMMAND switch-command)

automatically generated reader method

Source

command.lisp (file)

Generic Function: switch-default OBJECT

Package

closure-template.parser

Methods

Method: switch-default (SWITCH-COMMAND switch-command)

automatically generated reader method

Source

command.lisp (file)

Generic Function: switch-expression OBJECT

Package

closure-template.parser

Methods

Method: switch-expression (SWITCH-COMMAND switch-command)

automatically generated reader method

Source

command.lisp (file)

Generic Function: template-code-block OBJECT

Package

closure-template.parser

Methods

Method: template-code-block (TEMPLATE template)

automatically generated reader method

Source

command.lisp (file)

Generic Function: template-name OBJECT

Package

closure-template.parser

Methods

Method: template-name (TEMPLATE template)

automatically generated reader method

Source

command.lisp (file)

Generic Function: template-properties OBJECT

Package

closure-template.parser

Methods

Method: template-properties (TEMPLATE template)

automatically generated reader method

Source

command.lisp (file)

Generic Function: var-jsname OBJECT

Package

closure-template.parser

Methods

Method: var-jsname (VAR var)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: var-name OBJECT

Package

closure-template.parser

Methods

Method: var-name (VAR var)

automatically generated reader method

Source

expression.lisp (file)

Generic Function: with-body OBJECT

Package

closure-template.parser

Methods

Method: with-body (WITH with)

automatically generated reader method

Source

command.lisp (file)

Generic Function: with-vars OBJECT

Package

closure-template.parser

Methods

Method: with-vars (WITH with)

automatically generated reader method

Source

command.lisp (file)

6.1.5 Classes

Class: arref ()

Package

closure-template.parser

Source

expression.lisp (file)

Direct superclasses

ref (class)

Direct methods

• write-expression (method)
• make-expression-handler (method)
• arref-position (method)

Direct slots

Slot: position

Initargs

:position

Readers

arref-position (generic function)

Class: call ()

Package

closure-template.parser

Source

command.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-command (method)
• make-command-handler (method)
• call-params (method)
• call-data (method)
• call-namespace (method)
• call-name (method)

Direct slots

Slot: name

Initargs

:name

Readers

call-name (generic function)

Slot: namespace

Initargs

nil, :namespace

Readers

call-namespace (generic function)

Slot: data

Initargs

:data

Readers

call-data (generic function)

Slot: params

Initargs

:params

Readers

call-params (generic function)

Class: closure-template ()

Package

closure-template

Source

asdf.lisp (file)

Direct superclasses

source-file (class)

Direct methods

• output-files (method)
• perform (method)
• perform (method)

Direct slots

Slot: type

Initform

"tmpl"

Class: comment ()

Package

closure-template.parser

Source

command.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-command (method)
• comment-multiline-p (method)
• comment-text (method)

Direct slots

Slot: text

Initargs

:text

Readers

comment-text (generic function)

Slot: multiline

Initargs

:multiline

Readers

comment-multiline-p (generic function)

Class: dotref ()

Package

closure-template.parser

Source

expression.lisp (file)

Direct superclasses

ref (class)

Direct methods

• write-expression (method)
• make-expression-handler (method)
• dotref-jsname (method)
• dotref-name (method)

Direct slots

Slot: name

Initargs

:name

Readers

dotref-name (generic function)

Slot: jsname

Initargs

:jsname

Readers

dotref-jsname (generic function)

Class: fcall ()

Package

closure-template.parser

Source

expression.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-expression (method)
• make-expression-handler (method)
• fcall-args (method)
• fcall-jsname (method)
• fcall-name (method)

Direct slots

Slot: name

Initargs

:name

Readers

fcall-name (generic function)

Slot: jsname

Initargs

:jsname

Readers

fcall-jsname (generic function)

Slot: args

Initargs

:args

Readers

fcall-args (generic function)

Class: for-command ()

Package

closure-template.parser

Source

command.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-command (method)
• make-command-handler (method)
• for-code-block (method)
• for-range (method)
• for-varname (method)

Direct slots

Slot: varname

Initargs

:varname

Readers

for-varname (generic function)

Slot: range

Initargs

:range

Readers

for-range (generic function)

Slot: code-block

Initargs

:code-block

Readers

for-code-block (generic function)

Class: foreach ()

Package

closure-template.parser

Source

command.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-command (method)
• make-command-handler (method)
• foreach-if-empty-code (method)
• foreach-code-block (method)
• foreach-expression (method)
• foreach-varname (method)

Direct slots

Slot: varname

Initargs

:varname

Readers

foreach-varname (generic function)

Slot: expression

Initargs

:expr

Readers

foreach-expression (generic function)

Slot: codeblock

Initargs

:code-block

Readers

foreach-code-block (generic function)

Slot: if-empty-code

Initargs

:if-empty-code

Readers

foreach-if-empty-code (generic function)

Class: if-command ()

Package

closure-template.parser

Source

command.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-command (method)
• make-command-handler (method)
• if-command-options (method)

Direct slots

Slot: options

Initargs

:options

Readers

if-command-options (generic function)

Class: injected-data ()

Package

closure-template.parser

Source

expression.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-expression (method)
• make-expression-handler (method)

Class: list-expr ()

Package

closure-template.parser

Source

expression.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-expression (method)
• make-expression-handler (method)
• list-expr-values (method)

Direct slots

Slot: values

Initargs

:values

Readers

list-expr-values (generic function)

Class: literal ()

Package

closure-template.parser

Source

command.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-command (method)
• make-command-handler (method)
• literal-content (method)

Direct slots

Slot: content

Initargs

:content

Readers

literal-content (generic function)

Class: map-expr ()

Package

closure-template.parser

Source

expression.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-expression (method)
• make-expression-handler (method)
• map-expr-items (method)

Direct slots

Slot: pairs

Initargs

:pairs

Readers

map-expr-items (generic function)

Class: namespace ()

Package

closure-template.parser

Source

command.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• compile-to-js (method)
• namespace-templates (method)
• namespace-name (method)

Direct slots

Slot: name

Initargs

:name

Readers

namespace-name (generic function)

Slot: templates

Initargs

:templates

Readers

namespace-templates (generic function)

Class: operator ()

Package

closure-template.parser

Source

expression.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-expression (method)
• make-expression-handler (method)
• op-args (method)
• op-name (method)

Direct slots

Slot: name

Initargs

:name

Readers

op-name (generic function)

Slot: args

Initargs

:args

Readers

op-args (generic function)

Class: print-command ()

Package

closure-template.parser

Source

command.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-command (method)
• make-command-handler (method)
• print-directives (method)
• print-expression (method)

Direct slots

Slot: expr

Initargs

:expr

Readers

print-expression (generic function)

Slot: directives

Initargs

:directives

Readers

print-directives (generic function)

Class: switch-command ()

Package

closure-template.parser

Source

command.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-command (method)
• make-command-handler (method)
• switch-default (method)
• switch-cases (method)
• switch-expression (method)

Direct slots

Slot: expr

Initargs

:expr

Readers

switch-expression (generic function)

Slot: cases

Initargs

:cases

Readers

switch-cases (generic function)

Slot: default

Initargs

:default

Readers

switch-default (generic function)

Class: template ()

Package

closure-template.parser

Source

command.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• template-code-block (method)
• template-properties (method)
• template-name (method)

Direct slots

Slot: name

Initargs

:name

Readers

template-name (generic function)

Slot: properties

Initargs

:properties

Readers

template-properties (generic function)

Slot: code-block

Initargs

:code-block

Readers

template-code-block (generic function)

Class: ttable ()

Package

closure-template

Source

common-lisp-backend.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• ttable-prototype (method)
• ttable-hash (method)

Direct slots

Slot: hash

Initform

(make-hash-table :test (quote equal))

Readers

ttable-hash (generic function)

Slot: prototype

Initargs

:prototype

Readers

ttable-prototype (generic function)

Class: var ()

Package

closure-template.parser

Source

expression.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• write-expression (method)
• make-expression-handler (method)
• var-jsname (method)
• var-name (method)

Direct slots

Slot: name

Initargs

:name

Readers

var-name (generic function)

Slot: jsname

Initargs

:jsname

Readers

var-jsname (generic function)

6.2 Internal definitions

6.2.1 Special variables

Special Variable: *autoescape*

Package

closure-template

Source

common-lisp-backend.lisp (file)

Special Variable: *closure-template-rules*

Package

closure-template.parser

Source

defpackage.lisp (file)

Special Variable: *indent-level*

Package

closure-template

Source

javascript-backend.lisp (file)

Special Variable: *infix-ops-priority*

Package

closure-template.parser

Source

expression.lisp (file)

Special Variable: *js-custom-print-handlers*

Package

closure-template

Source

javascript-backend.lisp (file)

Special Variable: *js-namespace*

Current JavaScript namespace

Package

closure-template

Source

javascript-backend.lisp (file)

Special Variable: *local-variables*

Package

closure-template

Source

javascript-backend.lisp (file)

Special Variable: *loops-vars*

Package

closure-template

Source

common-lisp-backend.lisp (file)

Special Variable: *possible-functions*

Package

closure-template.parser

Source

expression.lisp (file)

Special Variable: *requirejs-custom-print-handlers*

Package

closure-template

Source

javascript-backend.lisp (file)

Special Variable: *requirejs-deps*

Package

closure-template

Source

javascript-backend.lisp (file)

Special Variable: *substitiotn-map*

Package

closure-template.parser

Source

command.lisp (file)

Special Variable: *symbol-counter*

Package

closure-template

Source

javascript-backend.lisp (file)

Special Variable: *template-data*

Package

closure-template

Source

common-lisp-backend.lisp (file)

Special Variable: *user-functions*

Package

closure-template

Source

common-lisp-backend.lisp (file)

Special Variable: *user-print-directive-handlers*

Package

closure-template

Source

common-lisp-backend.lisp (file)

Special Variable: +json-lisp-escaped-chars+

Package

closure-template

Source

javascript-backend.lisp (file)

Special Variable: +reserved-js-words+

Package

closure-template

Source

javascript-backend.lisp (file)

Special Variable: +standard-print-directives+

Package

closure-template.parser

Source

command.lisp (file)

6.2.2 Macros

Macro: define-escape-sequence NAME CHAR &optional RESULT

Package

closure-template.parser

Source

expression.lisp (file)

Macro: define-operator NAME &optional VAL

Package

closure-template.parser

Source

expression.lisp (file)

Macro: define-print-directive NAME VALUE

Package

closure-template.parser

Source

command.lisp (file)

Macro: define-rule SYMBOL EXPRESSION &body OPTIONS

Package

closure-template.parser

Source

defpackage.lisp (file)

Macro: define-substitions NAME STR VALUE

Package

closure-template.parser

Source

command.lisp (file)

Macro: with-closure-template-rules &body BODY

Package

closure-template.parser

Source

defpackage.lisp (file)

Macro: with-increase-indent &body BODY

Package

closure-template

Source

javascript-backend.lisp (file)

Macro: with-local-var (NAME) &body BODY

Package

closure-template

Source

javascript-backend.lisp (file)

Macro: with-write-parenthesis (OUT &optional PARENTHESIS) &body BODY

Package

closure-template

Source

javascript-backend.lisp (file)

6.2.3 Functions

Function: %!= ARG1 ARG2

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: %+ ARG1 ARG2

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: %is-nonnull VALUE

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: %js TEXT

Package

closure-template

Source

javascript-backend.lisp (file)

Function: %round NUMBER &optional DIGITS-AFTER-POINT

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: %str-contains STR SUBSTR

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: ->prefix INFIX

Convert an infix expression to prefix.

Package

closure-template.parser

Source

expression.lisp (file)

Function: add-user-function NAME FUNCTION

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: check-expression-p OBJ

Package

closure-template.parser

Source

command.lisp (file)

Function: compile-namespace OBJ

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: compile-to-requirejs OBJ

Package

closure-template

Source

javascript-backend.lisp (file)

Function: copy-print-handler INSTANCE

Package

closure-template

Source

javascript-backend.lisp (file)

Function: encode-string STR NOT-ENCODE

Package

closure-template

Source

escape.lisp (file)

Function: find-user-function NAME

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: has-data ()

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: index SYMBOL

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: is-first SYMBOL

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: is-last SYMBOL

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: make-all-user-print-directives-handler CMD EXPR

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: make-and-handler ARGS

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: make-boolean-expression-handler EXPR

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: make-call-data-handler DATA

Package

closure-template

Source

common-lisp-backend.lisp (file)

Function: make-code-block-handler EXPR

Package

closure-template

Source

common-lisp-backend.lisp (file)