The zenekindarl Reference Manual

Table of Contents

The zenekindarl Reference Manual

This is the zenekindarl Reference Manual, version 0.1, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Apr 28 13:21:53 2020 GMT+0.

1 Introduction

Zenekindarl

Expected to be a fast, flexible, extensible, low memory usage, async, concurrent template engine.

Usage

Like this

(render "Hello {{var name}}!!"
        :name "κeen")

(let ((renderer (compile-template-string :stream "Hello {{var name}}!!")))
  (funcall renderer *standard-output* :name "κeen"))

.

For more information, see docstring

Instant Benchmark

Zenekindarl perform x16 as fast as a template engine in Python in the following instant benchmark.

Template engines | Time[sec] ---------------------|---------- Zenekindarl, SBCL 1.1.8 | 1.365 Jinja2, Python 2.7.5 | 24.07

The benchmark code for Zenekindarl:

> (time
   (with-open-file (out #P"~/Desktop/out" :direction :output :if-exists :supersede)
     (let ((fun (zenekindarl:compile-template-string :stream "Hello {{var name}}!!")))
       (loop repeat 1000000
          do (funcall fun out :name "κeen")))))
Evaluation took:
1.625 seconds of real time
1.364707 seconds of total run time (1.302198 user, 0.062509 system)
[ Run times consist of 0.042 seconds GC time, and 1.323 seconds non-GC time. ]
84.00% CPU
1 form interpreted
3 lambdas converted
3,265,218,807 processor cycles
528,706,464 bytes consed

The benchmark code for a template engine in Python:

$ cat te.py
from jinja2 import Template

template = Template( u'Hello {{ name }}!!' )

f = open( 'out', 'w' )
for i in range( 1000000 ):
  f.write( template.render( name=u'κeen' ).encode( 'utf-8' ) )

$ time python te.py
real    0m25.612s
user    0m24.069s
sys	    0m0.190s

Syntax

Variable

variables will be HTML escaped

{{var foo}}

Repeat

{{repeat 10}}hello{{endrepeat}}

{{repeat n as i}}<li>{{var i}}th item</li>{{endrepeat}}

Loop

<ol>
  {{loop items as item}}
  <li>{{var item}}</li>
  {{endloop}}
</ol>

If

{{if new-p}}New{{else}}Old{{endif}}

Insert

See code below
<code><pre>
{{insert "snippet.lisp"}}
</pre></code>

Include

<nav>
{{incude "sidebar.tmpl"}}
</nav>

Author

• κeen

Copyright

Copyright (c) 2014

2 Systems

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

2.1 zenekindarl

Author

κeen

License

Description

A fast precompiling template engine

Version

0.1

Dependencies

• alexandria
• anaphora
• babel
• optima
• cl-ppcre
• html-encode
• fast-io
• maxpc
• cl-annot

Source

zenekindarl.asd (file)

Component

src (module)

3 Modules

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

3.1 zenekindarl/src

Parent

zenekindarl (system)

Location

src/

Components

• zenekindarl.lisp (file)
• att.lisp (file)
• backend.lisp (file)
• be (module)
• token.lisp (file)
• pass.lisp (file)
• parse.lisp (file)
• lexer.lisp (file)
• le (module)
• parser.lisp (file)
• util.lisp (file)

3.2 zenekindarl/src/be

Dependency

backend.lisp (file)

Parent

src (module)

Location

src/backend/

Components

• stream.lisp (file)
• sequence.lisp (file)
• fast-io.lisp (file)

3.3 zenekindarl/src/le

Dependencies

• lexer.lisp (file)
• token.lisp (file)

Parent

src (module)

Location

src/lexer/

Component

default.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 zenekindarl.asd

Location

zenekindarl.asd

Systems

zenekindarl (system)

4.1.2 zenekindarl/src/zenekindarl.lisp

Dependencies

• parse.lisp (file)
• pass.lisp (file)
• backend.lisp (file)
• be (module)

Parent

src (module)

Location

src/zenekindarl.lisp

Packages

zenekindarl

Exported Definitions

• compile-template-file (function)
• compile-template-string (function)
• render (function)
• render-file (function)

4.1.3 zenekindarl/src/att.lisp

Dependency

util.lisp (file)

Parent

src (module)

Location

src/att.lisp

Packages

zenekindarl.att

Exported Definitions

• arg (method)
• (setf arg) (method)
• att-constant (function)
• att-constant (class)
• att-control (class)
• att-equal (generic function)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-eval (function)
• att-eval (class)
• att-gensym (function)
• att-gensym (class)
• att-if (function)
• att-if (class)
• att-include (function)
• att-include (class)
• att-leaf (class)
• att-loop (function)
• att-loop (class)
• att-nil (function)
• att-nil (class)
• att-node (class)
• att-output (function)
• att-output (class)
• att-progn (function)
• att-progn (class)
• att-repeat (function)
• att-repeat (class)
• att-string (function)
• att-string (class)
• att-variable (function)
• att-variable (class)
• auto-escape (method)
• (setf auto-escape) (method)
• body (method)
• (setf body) (method)
• body (method)
• (setf body) (method)
• cond-clause (method)
• (setf cond-clause) (method)
• else-clause (method)
• (setf else-clause) (method)
• gensym-string (method)
• (setf gensym-string) (method)
• loop-seq (method)
• (setf loop-seq) (method)
• loop-var (method)
• (setf loop-var) (method)
• nodes (method)
• (setf nodes) (method)
• path (method)
• (setf path) (method)
• repeat-times (method)
• (setf repeat-times) (method)
• repeat-var (method)
• (setf repeat-var) (method)
• sexp (method)
• (setf sexp) (method)
• then-clause (method)
• (setf then-clause) (method)
• value (method)
• (setf value) (method)
• value (method)
• (setf value) (method)
• varsym (method)
• (setf varsym) (method)
• vartype (method)
• (setf vartype) (method)

4.1.4 zenekindarl/src/backend.lisp

Dependencies

• util.lisp (file)
• att.lisp (file)

Parent

src (module)

Location

src/backend.lisp

Packages

zenekindarl.backend

Exported Definitions

• backend (class)
• emit-code (generic function)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-lambda (generic function)
• emit-lambda (method)
• emit-parameters (generic function)
• emit-parameters (method)
• make-backend (generic function)
• symbols (method)
• (setf symbols) (method)

Internal Definitions

• add-to-scope (generic function)
• add-to-scope (method)
• find-from-scope (generic function)
• find-from-scope (method)
• http-escape (generic function)
• http-escape (method)
• http-escape (method)
• http-escape (method)
• http-escape (method)
• pop-scope (generic function)
• pop-scope (method)
• push-scope (generic function)
• push-scope (method)
• scopes (method)
• (setf scopes) (method)

4.1.5 zenekindarl/src/be/stream.lisp

Parent

be (module)

Location

src/backend/stream.lisp

Packages

zenekindarl.backend.stream

Exported Definitions

• emit-code (method)
• emit-code (method)
• emit-lambda (method)
• emit-lambda (method)
• make-backend (method)
• make-backend (method)
• octet-stream-backend (class)
• stream-backend (class)
• stream-of (method)
• (setf stream-of) (method)

4.1.6 zenekindarl/src/be/sequence.lisp

Dependency

stream.lisp (file)

Parent

be (module)

Location

src/backend/sequence.lisp

Packages

zenekindarl.backend.sequence

Exported Definitions

• buffer-of (method)
• (setf buffer-of) (method)
• emit-code (method)
• emit-lambda (method)
• emit-lambda (method)
• make-backend (method)
• make-backend (method)
• octet-backend (class)
• string-backend (class)

Internal Definitions

• string-of (method)
• (setf string-of) (method)

4.1.7 zenekindarl/src/be/fast-io.lisp

Dependency

sequence.lisp (file)

Parent

be (module)

Location

src/backend/fast-io.lisp

Packages

zenekindarl.backend.fast-io

Exported Definitions

• emit-lambda (method)
• fast-io-backend (class)
• make-backend (method)

4.1.8 zenekindarl/src/token.lisp

Parent

src (module)

Location

src/token.lisp

Packages

zenekindarl.token

Exported Definitions

• make-token-else (function)
• make-token-end (function)
• make-token-if (function)
• make-token-include (function)
• make-token-insert (function)
• make-token-loop (function)
• make-token-repeat (function)
• make-token-string (function)
• make-token-variable (function)
• token-auto-escape (function)
• (setf token-auto-escape) (function)
• token-cond-clause (function)
• (setf token-cond-clause) (function)
• token-else (structure)
• token-else-p (function)
• token-end (function)
• (setf token-end) (function)
• token-end (structure)
• token-end-p (function)
• token-if (structure)
• token-if-p (function)
• token-include (structure)
• token-include-p (function)
• token-include-template (function)
• (setf token-include-template) (function)
• token-insert (structure)
• token-insert-p (function)
• token-insert-string (function)
• (setf token-insert-string) (function)
• token-loop (structure)
• token-loop-p (function)
• token-loop-sym (function)
• (setf token-loop-sym) (function)
• token-repeat (structure)
• token-repeat-p (function)
• token-repeat-sym (function)
• (setf token-repeat-sym) (function)
• token-seq (function)
• (setf token-seq) (function)
• token-start (function)
• (setf token-start) (function)
• token-str (function)
• (setf token-str) (function)
• token-string (structure)
• token-string-p (function)
• token-template (function)
• (setf token-template) (function)
• token-times (function)
• (setf token-times) (function)
• token-value (function)
• (setf token-value) (function)
• token-variable (structure)
• token-variable-p (function)

Internal Definitions

• copy-token (function)
• copy-token-else (function)
• copy-token-end (function)
• copy-token-if (function)
• copy-token-include (function)
• copy-token-insert (function)
• copy-token-loop (function)
• copy-token-repeat (function)
• copy-token-string (function)
• copy-token-variable (function)
• make-token (function)
• token (structure)
• token-p (function)

4.1.9 zenekindarl/src/pass.lisp

Dependencies

• util.lisp (file)
• att.lisp (file)

Parent

src (module)

Location

src/pass.lisp

Packages

zenekindarl.pass

Exported Definitions

• *optimizing-passes* (special variable)
• append-sequence-pass (function)
• apply-passes (function)
• flatten-pass (function)
• fold-variables-pass (function)
• remove-progn-pass (function)

Internal Definitions

• *necessary-passes* (special variable)
• append-att-node (function)
• append-att-node-aux (generic function)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-sequence-impl (generic function)
• append-sequence-impl (method)
• append-sequence-impl (method)
• flatten-impl (generic function)
• flatten-impl (method)
• flatten-impl (method)
• fold-variables-impl (generic function)
• fold-variables-impl (method)
• fold-variables-impl (method)
• remove-progn-impl (generic function)
• remove-progn-impl (method)
• remove-progn-impl (method)
• traverse-node (generic function)
• traverse-node (method)
• traverse-node (method)
• traverse-node (method)
• traverse-node (method)
• traverse-node (method)
• traverse-node (method)

4.1.10 zenekindarl/src/parse.lisp

Dependencies

• att.lisp (file)
• lexer.lisp (file)
• le (module)
• parser.lisp (file)

Parent

src (module)

Location

src/parse.lisp

Packages

zenekindarl.parse

Exported Definitions

• parse-template-file (function)
• parse-template-string (function)

4.1.11 zenekindarl/src/lexer.lisp

Parent

src (module)

Location

src/lexer.lisp

Packages

zenekindarl.lexer

Exported Definitions

lex (generic function)

4.1.12 zenekindarl/src/le/default.lisp

Parent

le (module)

Location

src/lexer/default.lisp

Packages

zenekindarl.lexer.default

Exported Definitions

lex (method)

Internal Definitions

• read-out (function)
• tokenize (function)
• tokenize-else (function)
• tokenize-end (function)
• tokenize-if (function)
• tokenize-include (function)
• tokenize-insert (function)
• tokenize-loop (function)
• tokenize-repeat (function)
• tokenize-variable (function)
• tokens (function)

4.1.13 zenekindarl/src/parser.lisp

Dependencies

• token.lisp (file)
• att.lisp (file)
• lexer.lisp (file)
• le (module)

Parent

src (module)

Location

src/parser.lisp

Packages

zenekindarl.parser

Exported Definitions

=template (function)

Internal Definitions

• =control-if (function)
• =control-include (function)
• =control-insert (function)
• =control-loop (function)
• =control-repeat (function)
• =control-variable (function)
• =template-string (function)
• ?token-else (function)
• ?token-end (function)
• ?token-if (function)
• ?token-include (function)
• ?token-insert (function)
• ?token-loop (function)
• ?token-repeat (function)
• ?token-string (function)
• ?token-variable (function)
• id (function)

4.1.14 zenekindarl/src/util.lisp

Parent

src (module)

Location

src/util.lisp

Packages

zenekindarl.util

Exported Definitions

• octets (function)
• octets (type)

5 Packages

Packages are listed by definition order.

5.1 zenekindarl

Source

zenekindarl.lisp (file)

Nickname

zen

Use List

• zenekindarl.util
• zenekindarl.backend.fast-io
• zenekindarl.backend.sequence
• zenekindarl.backend.stream
• zenekindarl.backend
• zenekindarl.pass
• zenekindarl.parse
• common-lisp

Exported Definitions

• compile-template-file (function)
• compile-template-string (function)
• render (function)
• render-file (function)

5.2 zenekindarl.att

Source

att.lisp (file)

Use List

• zenekindarl.util
• common-lisp

Used By List

• zenekindarl.backend.fast-io
• zenekindarl.backend.sequence
• zenekindarl.backend.stream
• zenekindarl.backend
• zenekindarl.pass
• zenekindarl.parse
• zenekindarl.parser

Exported Definitions

• arg (generic function)
• arg (method)
• (setf arg) (method)
• (setf arg) (generic function)
• att-constant (function)
• att-constant (class)
• att-control (class)
• att-equal (generic function)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-equal (method)
• att-eval (function)
• att-eval (class)
• att-gensym (function)
• att-gensym (class)
• att-if (function)
• att-if (class)
• att-include (function)
• att-include (class)
• att-leaf (class)
• att-loop (function)
• att-loop (class)
• att-nil (function)
• att-nil (class)
• att-node (class)
• att-output (function)
• att-output (class)
• att-progn (function)
• att-progn (class)
• att-repeat (function)
• att-repeat (class)
• att-string (function)
• att-string (class)
• att-variable (function)
• att-variable (class)
• auto-escape (generic function)
• auto-escape (method)
• (setf auto-escape) (method)
• (setf auto-escape) (generic function)
• body (generic function)
• body (method)
• (setf body) (method)
• body (method)
• (setf body) (method)
• (setf body) (generic function)
• cond-clause (generic function)
• cond-clause (method)
• (setf cond-clause) (method)
• (setf cond-clause) (generic function)
• else-clause (generic function)
• else-clause (method)
• (setf else-clause) (method)
• (setf else-clause) (generic function)
• gensym-string (generic function)
• gensym-string (method)
• (setf gensym-string) (method)
• (setf gensym-string) (generic function)
• loop-seq (generic function)
• loop-seq (method)
• (setf loop-seq) (method)
• (setf loop-seq) (generic function)
• loop-var (generic function)
• loop-var (method)
• (setf loop-var) (method)
• (setf loop-var) (generic function)
• nodes (generic function)
• nodes (method)
• (setf nodes) (method)
• (setf nodes) (generic function)
• path (generic function)
• path (method)
• (setf path) (method)
• (setf path) (generic function)
• repeat-times (generic function)
• repeat-times (method)
• (setf repeat-times) (method)
• (setf repeat-times) (generic function)
• repeat-var (generic function)
• repeat-var (method)
• (setf repeat-var) (method)
• (setf repeat-var) (generic function)
• sexp (generic function)
• sexp (method)
• (setf sexp) (method)
• (setf sexp) (generic function)
• then-clause (generic function)
• then-clause (method)
• (setf then-clause) (method)
• (setf then-clause) (generic function)
• value (generic function)
• value (method)
• (setf value) (method)
• value (method)
• (setf value) (method)
• (setf value) (generic function)
• varsym (generic function)
• varsym (method)
• (setf varsym) (method)
• (setf varsym) (generic function)
• vartype (generic function)
• vartype (method)
• (setf vartype) (method)
• (setf vartype) (generic function)

5.3 zenekindarl.backend

Source

backend.lisp (file)

Use List

• zenekindarl.att
• zenekindarl.util
• common-lisp

Used By List

• zenekindarl
• zenekindarl.backend.fast-io
• zenekindarl.backend.sequence
• zenekindarl.backend.stream

Exported Definitions

• backend (class)
• emit-code (generic function)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-code (method)
• emit-lambda (generic function)
• emit-lambda (method)
• emit-lambda (method)
• emit-lambda (method)
• emit-lambda (method)
• emit-lambda (method)
• emit-lambda (method)
• emit-parameters (generic function)
• emit-parameters (method)
• make-backend (generic function)
• make-backend (method)
• make-backend (method)
• make-backend (method)
• make-backend (method)
• make-backend (method)
• symbols (generic function)
• symbols (method)
• (setf symbols) (method)
• (setf symbols) (generic function)

Internal Definitions

• add-to-scope (generic function)
• add-to-scope (method)
• find-from-scope (generic function)
• find-from-scope (method)
• http-escape (generic function)
• http-escape (method)
• http-escape (method)
• http-escape (method)
• http-escape (method)
• pop-scope (generic function)
• pop-scope (method)
• push-scope (generic function)
• push-scope (method)
• scopes (generic function)
• scopes (method)
• (setf scopes) (method)
• (setf scopes) (generic function)

5.4 zenekindarl.backend.stream

Source

stream.lisp (file)

Use List

• zenekindarl.backend
• zenekindarl.att
• zenekindarl.util
• common-lisp

Used By List

• zenekindarl
• zenekindarl.backend.sequence

Exported Definitions

• buffer-of (generic function)
• buffer-of (method)
• (setf buffer-of) (method)
• (setf buffer-of) (generic function)
• octet-stream-backend (class)
• stream-backend (class)
• stream-of (generic function)
• stream-of (method)
• (setf stream-of) (method)
• (setf stream-of) (generic function)

5.5 zenekindarl.backend.sequence

Source

sequence.lisp (file)

Use List

• zenekindarl.backend.stream
• zenekindarl.backend
• zenekindarl.att
• zenekindarl.util
• common-lisp

Used By List

zenekindarl

Exported Definitions

• octet-backend (class)
• string-backend (class)

Internal Definitions

• string-of (generic function)
• string-of (method)
• (setf string-of) (method)
• (setf string-of) (generic function)

5.6 zenekindarl.backend.fast-io

Source

fast-io.lisp (file)

Use List

• zenekindarl.backend
• zenekindarl.att
• zenekindarl.util
• common-lisp

Used By List

zenekindarl

Exported Definitions

fast-io-backend (class)

5.7 zenekindarl.token

Source

token.lisp (file)

Use List

• cl-annot.class
• common-lisp

Used By List

• zenekindarl.parser
• zenekindarl.lexer.default

Exported Definitions

• make-token-else (function)
• make-token-end (function)
• make-token-if (function)
• make-token-include (function)
• make-token-insert (function)
• make-token-loop (function)
• make-token-repeat (function)
• make-token-string (function)
• make-token-variable (function)
• token-auto-escape (function)
• (setf token-auto-escape) (function)
• token-cond-clause (function)
• (setf token-cond-clause) (function)
• token-else (structure)
• token-else-p (function)
• token-end (function)
• (setf token-end) (function)
• token-end (structure)
• token-end-p (function)
• token-if (structure)
• token-if-p (function)
• token-include (structure)
• token-include-p (function)
• token-include-template (function)
• (setf token-include-template) (function)
• token-insert (structure)
• token-insert-p (function)
• token-insert-string (function)
• (setf token-insert-string) (function)
• token-loop (structure)
• token-loop-p (function)
• token-loop-sym (function)
• (setf token-loop-sym) (function)
• token-repeat (structure)
• token-repeat-p (function)
• token-repeat-sym (function)
• (setf token-repeat-sym) (function)
• token-seq (function)
• (setf token-seq) (function)
• token-start (function)
• (setf token-start) (function)
• token-str (function)
• (setf token-str) (function)
• token-string (structure)
• token-string-p (function)
• token-template (function)
• (setf token-template) (function)
• token-times (function)
• (setf token-times) (function)
• token-value (function)
• (setf token-value) (function)
• token-variable (structure)
• token-variable-p (function)

Internal Definitions

• copy-token (function)
• copy-token-else (function)
• copy-token-end (function)
• copy-token-if (function)
• copy-token-include (function)
• copy-token-insert (function)
• copy-token-loop (function)
• copy-token-repeat (function)
• copy-token-string (function)
• copy-token-variable (function)
• make-token (function)
• token (structure)
• token-p (function)

5.8 zenekindarl.pass

Source

pass.lisp (file)

Use List

• zenekindarl.att
• zenekindarl.util
• common-lisp

Used By List

zenekindarl

Exported Definitions

• *optimizing-passes* (special variable)
• append-sequence-pass (function)
• apply-passes (function)
• flatten-pass (function)
• fold-variables-pass (function)
• remove-progn-pass (function)

Internal Definitions

• *necessary-passes* (special variable)
• append-att-node (function)
• append-att-node-aux (generic function)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-att-node-aux (method)
• append-sequence-impl (generic function)
• append-sequence-impl (method)
• append-sequence-impl (method)
• flatten-impl (generic function)
• flatten-impl (method)
• flatten-impl (method)
• fold-variables-impl (generic function)
• fold-variables-impl (method)
• fold-variables-impl (method)
• remove-progn-impl (generic function)
• remove-progn-impl (method)
• remove-progn-impl (method)
• traverse-node (generic function)
• traverse-node (method)
• traverse-node (method)
• traverse-node (method)
• traverse-node (method)
• traverse-node (method)
• traverse-node (method)

5.9 zenekindarl.parse

Source

parse.lisp (file)

Use List

• zenekindarl.parser
• zenekindarl.lexer
• zenekindarl.att
• common-lisp

Used By List

zenekindarl

Exported Definitions

• parse-template-file (function)
• parse-template-string (function)

5.10 zenekindarl.lexer

Source

lexer.lisp (file)

Use List

common-lisp

Used By List

• zenekindarl.parse
• zenekindarl.lexer.default

Exported Definitions

• lex (generic function)
• lex (method)

5.11 zenekindarl.lexer.default

Source

default.lisp (file)

Use List

• zenekindarl.lexer
• zenekindarl.token
• zenekindarl.util
• common-lisp

Internal Definitions

• read-out (function)
• tokenize (function)
• tokenize-else (function)
• tokenize-end (function)
• tokenize-if (function)
• tokenize-include (function)
• tokenize-insert (function)
• tokenize-loop (function)
• tokenize-repeat (function)
• tokenize-variable (function)
• tokens (function)

5.12 zenekindarl.parser

Source

parser.lisp (file)

Use List

• maxpc
• zenekindarl.att
• zenekindarl.token
• zenekindarl.util
• common-lisp

Used By List

zenekindarl.parse

Exported Definitions

=template (function)

Internal Definitions

• =control-if (function)
• =control-include (function)
• =control-insert (function)
• =control-loop (function)
• =control-repeat (function)
• =control-variable (function)
• =template-string (function)
• ?token-else (function)
• ?token-end (function)
• ?token-if (function)
• ?token-include (function)
• ?token-insert (function)
• ?token-loop (function)
• ?token-repeat (function)
• ?token-string (function)
• ?token-variable (function)
• id (function)
• s/=template (function)

5.13 zenekindarl.util

Source

util.lisp (file)

Use List

common-lisp

Used By List

• zenekindarl
• zenekindarl.backend.fast-io
• zenekindarl.backend.sequence
• zenekindarl.backend.stream
• zenekindarl.backend
• zenekindarl.pass
• zenekindarl.parser
• zenekindarl.lexer.default
• zenekindarl.att

Exported Definitions

• octets (function)
• octets (type)

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: *optimizing-passes*

Package

zenekindarl.pass

Source

pass.lisp (file)

6.1.2 Functions

Function: =template ()

Package

zenekindarl.parser

Source

parser.lisp (file)

Function: append-sequence-pass OBJ ENV

Package

zenekindarl.pass

Source

pass.lisp (file)

Function: apply-passes ATT ENV

Package

zenekindarl.pass

Source

pass.lisp (file)

Function: att-constant VAL

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-eval SEXP

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-gensym GENSYM-STRING &optional TYPE

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-if COND-CLAUSE THEN-CLAUSE &optional ELSE-CLAUSE

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-include PATH

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-loop LOOP-SEQ BODY &optional LOOP-VAR

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-nil ()

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-output ARG

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-progn &rest NODES

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-repeat REPEAT-TIMES BODY &optional REPEAT-VAR

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-string STR

Package

zenekindarl.att

Source

att.lisp (file)

Function: att-variable SYM &optional TYPE AUTO-ESCAPE

Package

zenekindarl.att

Source

att.lisp (file)

Function: compile-template-file BACKEND FILE &key SYNTAX ENV

Read ‘file’ into string and passes ‘compile-template-string’

Package

zenekindarl

Source

zenekindarl.lisp (file)

Function: compile-template-string BACKEND STR &key SYNTAX ENV

compiles ‘str’ with ‘env’ and emmit renderer with backend ‘backend’.
‘backend’: Currently, one of :stream :octet-stream :string :octets :fast-io.
‘str’: A template string.
‘syntax’: Currently, :default only.
‘env’: A plist of compile time information. Left nil.
return: A keyword argumented lambda.
If the backend is :stream or :octet-stream, it looks like (lambda (stream &key ...) ...). If the backend is :string or :octets, it looks like (lambda (&key ...) ...).
If the backend is :fast-io, it looks like (lambda (fast-io-buffer &key ...) ...). Keys are free variables appear in the template.

Package

zenekindarl

Source

zenekindarl.lisp (file)

Function: flatten-pass OBJ ENV

Package

zenekindarl.pass

Source

pass.lisp (file)

Function: fold-variables-pass OBJ ENV

Package

zenekindarl.pass

Source

pass.lisp (file)

Function: make-token-else &key (START START) (END END) (TEMPLATE TEMPLATE)

Package

zenekindarl.token

Source

token.lisp (file)

Function: make-token-end &key (START START) (END END) (TEMPLATE TEMPLATE)

Package

zenekindarl.token

Source

token.lisp (file)

Function: make-token-if &key (START START) (END END) (TEMPLATE TEMPLATE) (COND-CLAUSE COND-CLAUSE)

Package

zenekindarl.token

Source

token.lisp (file)

Function: make-token-include &key (START START) (END END) (TEMPLATE TEMPLATE) (INCLUDE-TEMPLATE INCLUDE-TEMPLATE)

Package

zenekindarl.token

Source

token.lisp (file)

Function: make-token-insert &key (START START) (END END) (TEMPLATE TEMPLATE) (INSERT-STRING INSERT-STRING)

Package

zenekindarl.token

Source

token.lisp (file)

Function: make-token-loop &key (START START) (END END) (TEMPLATE TEMPLATE) (SEQ SEQ) (LOOP-SYM LOOP-SYM)

Package

zenekindarl.token

Source

token.lisp (file)

Function: make-token-repeat &key (START START) (END END) (TEMPLATE TEMPLATE) (TIMES TIMES) (REPEAT-SYM REPEAT-SYM)

Package

zenekindarl.token

Source

token.lisp (file)

Function: make-token-string &key (START START) (END END) (TEMPLATE TEMPLATE) (STR STR)

Package

zenekindarl.token

Source

token.lisp (file)

Function: make-token-variable &key (START START) (END END) (TEMPLATE TEMPLATE) (VALUE VALUE) (AUTO-ESCAPE AUTO-ESCAPE)

Package

zenekindarl.token

Source

token.lisp (file)

Function: octets &rest CONTENTS

Package

zenekindarl.util

Source

util.lisp (file)

Function: parse-template-file FILE &optional SYNTAX

Package

zenekindarl.parse

Source

parse.lisp (file)

Function: parse-template-string STR &optional SYNTAX

Package

zenekindarl.parse

Source

parse.lisp (file)

Function: remove-progn-pass OBJ ENV

Package

zenekindarl.pass

Source

pass.lisp (file)

Function: render TEMPLATE &rest ARGS

Parse template and render it with args. Like below:
(render "Hello {{var name}}!!" :name "κeen")
(render "Hello {{var name}}!!" :backend :octet-stream stream :name "κeen")
.
If args have ‘:backend backend’ key-value pair, this function uses it. If not given the backend is :stream and stream is *standard-output*. And also if ‘:syntax syntax’ is given, use it or default to :default.

Package

zenekindarl

Source

zenekindarl.lisp (file)

Function: render-file TEMPLATE-FILE &rest ARGS

A wrapper of ‘render’

Package

zenekindarl

Source

zenekindarl.lisp (file)

Function: token-auto-escape INSTANCE

Function: (setf token-auto-escape) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-cond-clause INSTANCE

Function: (setf token-cond-clause) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-else-p OBJECT

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-end INSTANCE

Function: (setf token-end) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-end-p OBJECT

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-if-p OBJECT

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-include-p OBJECT

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-include-template INSTANCE

Function: (setf token-include-template) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-insert-p OBJECT

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-insert-string INSTANCE

Function: (setf token-insert-string) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-loop-p OBJECT

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-loop-sym INSTANCE

Function: (setf token-loop-sym) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-repeat-p OBJECT

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-repeat-sym INSTANCE

Function: (setf token-repeat-sym) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-seq INSTANCE

Function: (setf token-seq) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-start INSTANCE

Function: (setf token-start) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-str INSTANCE

Function: (setf token-str) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-string-p OBJECT

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-template INSTANCE

Function: (setf token-template) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-times INSTANCE

Function: (setf token-times) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-value INSTANCE

Function: (setf token-value) VALUE INSTANCE

Package

zenekindarl.token

Source

token.lisp (file)

Function: token-variable-p OBJECT

Package

zenekindarl.token

Source

token.lisp (file)

6.1.3 Generic functions

Generic Function: arg OBJECT

Generic Function: (setf arg) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: arg (ATT-OUTPUT att-output)

automatically generated reader method

Source

att.lisp (file)

Method: (setf arg) NEW-VALUE (ATT-OUTPUT att-output)

automatically generated writer method

Source

att.lisp (file)

Generic Function: att-equal X Y

Package

zenekindarl.att

Source

att.lisp (file)

Methods

Method: att-equal (X att-include) (Y att-include)

Method: att-equal (X att-repeat) (Y att-repeat)

Method: att-equal (X att-loop) (Y att-loop)

Method: att-equal (X att-if) (Y att-if)

Method: att-equal (X att-progn) (Y att-progn)

Method: att-equal (X att-output) (Y att-output)

Method: att-equal (X att-nil) (Y att-nil)

Method: att-equal (X att-eval) (Y att-eval)

Method: att-equal (X att-constant) (Y att-constant)

Method: att-equal (X att-gensym) (Y att-gensym)

Method: att-equal (X att-variable) (Y att-variable)

Method: att-equal (X att-string) (Y att-string)

Method: att-equal X Y

Generic Function: auto-escape OBJECT

Generic Function: (setf auto-escape) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: auto-escape (ATT-LEAF att-leaf)

automatically generated reader method

Source

att.lisp (file)

Method: (setf auto-escape) NEW-VALUE (ATT-LEAF att-leaf)

automatically generated writer method

Source

att.lisp (file)

Generic Function: body OBJECT

Generic Function: (setf body) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: body (ATT-REPEAT att-repeat)

automatically generated reader method

Source

att.lisp (file)

Method: (setf body) NEW-VALUE (ATT-REPEAT att-repeat)

automatically generated writer method

Source

att.lisp (file)

Method: body (ATT-LOOP att-loop)

automatically generated reader method

Source

att.lisp (file)

Method: (setf body) NEW-VALUE (ATT-LOOP att-loop)

automatically generated writer method

Source

att.lisp (file)

Generic Function: buffer-of OBJECT

Generic Function: (setf buffer-of) NEW-VALUE OBJECT

Package

zenekindarl.backend.stream

Methods

Method: buffer-of (OCTET-BACKEND octet-backend)

automatically generated reader method

Source

sequence.lisp (file)

Method: (setf buffer-of) NEW-VALUE (OCTET-BACKEND octet-backend)

automatically generated writer method

Source

sequence.lisp (file)

Generic Function: cond-clause OBJECT

Generic Function: (setf cond-clause) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: cond-clause (ATT-IF att-if)

automatically generated reader method

Source

att.lisp (file)

Method: (setf cond-clause) NEW-VALUE (ATT-IF att-if)

automatically generated writer method

Source

att.lisp (file)

Generic Function: else-clause OBJECT

Generic Function: (setf else-clause) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: else-clause (ATT-IF att-if)

automatically generated reader method

Source

att.lisp (file)

Method: (setf else-clause) NEW-VALUE (ATT-IF att-if)

automatically generated writer method

Source

att.lisp (file)

Generic Function: emit-code BACKEND OBJ &key OUTPUT-P

Package

zenekindarl.backend

Source

backend.lisp (file)

Methods

Method: emit-code (BACKEND octet-backend) (OBJ att-output) &key OUTPUT-P

Source

sequence.lisp (file)

Method: emit-code (BACKEND octet-stream-backend) (OBJ att-output) &key OUTPUT-P

Source

stream.lisp (file)

Method: emit-code (BACKEND stream-backend) (OBJ att-output) &key OUTPUT-P

Source

stream.lisp (file)

Method: emit-code BACKEND (OBJ att-repeat) &key OUTPUT-P

Method: emit-code BACKEND (OBJ att-loop) &key OUTPUT-P

Method: emit-code BACKEND (OBJ att-if) &key OUTPUT-P

Method: emit-code BACKEND (OBJ att-progn) &key OUTPUT-P

Method: emit-code BACKEND (OBJ att-nil) &key OUTPUT-P

Method: emit-code BACKEND (OBJ att-eval) &key OUTPUT-P

Method: emit-code BACKEND (OBJ att-constant) &key OUTPUT-P

Method: emit-code BACKEND (OBJ att-variable) &key OUTPUT-P

Method: emit-code BACKEND (OBJ att-string) &key OUTPUT-P

Method: emit-code BACKEND (OBJ att-leaf) &key OUTPUT-P around

Method: emit-code BACKEND OBJ &key OUTPUT-P

Generic Function: emit-lambda BACKEND ATT

Package

zenekindarl.backend

Source

backend.lisp (file)

Methods

Method: emit-lambda (BACKEND fast-io-backend) ATT

Source

fast-io.lisp (file)

Method: emit-lambda (BACKEND octet-backend) ATT

Source

sequence.lisp (file)

Method: emit-lambda (BACKEND string-backend) ATT

Source

sequence.lisp (file)

Method: emit-lambda (BACKEND octet-stream-backend) ATT

Source

stream.lisp (file)

Method: emit-lambda (BACKEND stream-backend) ATT

Source

stream.lisp (file)

Method: emit-lambda BACKEND ATT

Generic Function: emit-parameters BACKEND

Package

zenekindarl.backend

Source

backend.lisp (file)

Methods

Method: emit-parameters BACKEND

Generic Function: gensym-string OBJECT

Generic Function: (setf gensym-string) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: gensym-string (ATT-GENSYM att-gensym)

automatically generated reader method

Source

att.lisp (file)

Method: (setf gensym-string) NEW-VALUE (ATT-GENSYM att-gensym)

automatically generated writer method

Source

att.lisp (file)

Generic Function: lex TEMPLATE LEXER

Package

zenekindarl.lexer

Source

lexer.lisp (file)

Methods

Method: lex STR (LEXER (eql default))

Source

default.lisp (file)

Generic Function: loop-seq OBJECT

Generic Function: (setf loop-seq) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: loop-seq (ATT-LOOP att-loop)

automatically generated reader method

Source

att.lisp (file)

Method: (setf loop-seq) NEW-VALUE (ATT-LOOP att-loop)

automatically generated writer method

Source

att.lisp (file)

Generic Function: loop-var OBJECT

Generic Function: (setf loop-var) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: loop-var (ATT-LOOP att-loop)

automatically generated reader method

Source

att.lisp (file)

Method: (setf loop-var) NEW-VALUE (ATT-LOOP att-loop)

automatically generated writer method

Source

att.lisp (file)

Generic Function: make-backend BACKEND &key STRING &allow-other-keys

Package

zenekindarl.backend

Source

backend.lisp (file)

Methods

Method: make-backend (BACKEND (eql fast-io)) &key &allow-other-keys

Source

fast-io.lisp (file)

Method: make-backend (BACKEND (eql octets)) &key &allow-other-keys

Source

sequence.lisp (file)

Method: make-backend (BACKEND (eql string)) &key STRING &allow-other-keys

Source

sequence.lisp (file)

Method: make-backend (BACKEND (eql octet-stream)) &key &allow-other-keys

Source

stream.lisp (file)

Method: make-backend (BACKEND (eql stream)) &key &allow-other-keys

Source

stream.lisp (file)

Generic Function: nodes OBJECT

Generic Function: (setf nodes) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: nodes (ATT-PROGN att-progn)

automatically generated reader method

Source

att.lisp (file)

Method: (setf nodes) NEW-VALUE (ATT-PROGN att-progn)

automatically generated writer method

Source

att.lisp (file)

Generic Function: path OBJECT

Generic Function: (setf path) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: path (ATT-INCLUDE att-include)

automatically generated reader method

Source

att.lisp (file)

Method: (setf path) NEW-VALUE (ATT-INCLUDE att-include)

automatically generated writer method

Source

att.lisp (file)

Generic Function: repeat-times OBJECT

Generic Function: (setf repeat-times) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: repeat-times (ATT-REPEAT att-repeat)

automatically generated reader method

Source

att.lisp (file)

Method: (setf repeat-times) NEW-VALUE (ATT-REPEAT att-repeat)

automatically generated writer method

Source

att.lisp (file)

Generic Function: repeat-var OBJECT

Generic Function: (setf repeat-var) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: repeat-var (ATT-REPEAT att-repeat)

automatically generated reader method

Source

att.lisp (file)

Method: (setf repeat-var) NEW-VALUE (ATT-REPEAT att-repeat)

automatically generated writer method

Source

att.lisp (file)

Generic Function: sexp OBJECT

Generic Function: (setf sexp) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: sexp (ATT-EVAL att-eval)

automatically generated reader method

Source

att.lisp (file)

Method: (setf sexp) NEW-VALUE (ATT-EVAL att-eval)

automatically generated writer method

Source

att.lisp (file)

Generic Function: stream-of OBJECT

Generic Function: (setf stream-of) NEW-VALUE OBJECT

Package

zenekindarl.backend.stream

Methods

Method: stream-of (STREAM-BACKEND stream-backend)

automatically generated reader method

Source

stream.lisp (file)

Method: (setf stream-of) NEW-VALUE (STREAM-BACKEND stream-backend)

automatically generated writer method

Source

stream.lisp (file)

Generic Function: symbols OBJECT

Generic Function: (setf symbols) NEW-VALUE OBJECT

Package

zenekindarl.backend

Methods

Method: symbols (BACKEND backend)

automatically generated reader method

Source

backend.lisp (file)

Method: (setf symbols) NEW-VALUE (BACKEND backend)

automatically generated writer method

Source

backend.lisp (file)

Generic Function: then-clause OBJECT

Generic Function: (setf then-clause) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: then-clause (ATT-IF att-if)

automatically generated reader method

Source

att.lisp (file)

Method: (setf then-clause) NEW-VALUE (ATT-IF att-if)

automatically generated writer method

Source

att.lisp (file)

Generic Function: value OBJECT

Generic Function: (setf value) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: value (ATT-CONSTANT att-constant)

automatically generated reader method

Source

att.lisp (file)

Method: (setf value) NEW-VALUE (ATT-CONSTANT att-constant)

automatically generated writer method

Source

att.lisp (file)

Method: value (ATT-STRING att-string)

automatically generated reader method

Source

att.lisp (file)

Method: (setf value) NEW-VALUE (ATT-STRING att-string)

automatically generated writer method

Source

att.lisp (file)

Generic Function: varsym OBJECT

Generic Function: (setf varsym) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: varsym (ATT-VARIABLE att-variable)

automatically generated reader method

Source

att.lisp (file)

Method: (setf varsym) NEW-VALUE (ATT-VARIABLE att-variable)

automatically generated writer method

Source

att.lisp (file)

Generic Function: vartype OBJECT

Generic Function: (setf vartype) NEW-VALUE OBJECT

Package

zenekindarl.att

Methods

Method: vartype (ATT-VARIABLE att-variable)

automatically generated reader method

Source

att.lisp (file)

Method: (setf vartype) NEW-VALUE (ATT-VARIABLE att-variable)

automatically generated writer method

Source

att.lisp (file)

6.1.4 Structures

Structure: token-else ()

Package

zenekindarl.token

Source

token.lisp (file)

Direct superclasses

token (structure)

Structure: token-end ()

Package

zenekindarl.token

Source

token.lisp (file)

Direct superclasses

token (structure)

Structure: token-if ()

Package

zenekindarl.token

Source

token.lisp (file)

Direct superclasses

token (structure)

Direct slots

Slot: cond-clause

Readers

token-cond-clause (function)

Writers

(setf token-cond-clause) (function)

Structure: token-include ()

Package

zenekindarl.token

Source

token.lisp (file)

Direct superclasses

token (structure)

Direct slots

Slot: include-template

Type

list

Readers

token-include-template (function)

Writers

(setf token-include-template) (function)

Structure: token-insert ()

Package

zenekindarl.token

Source

token.lisp (file)

Direct superclasses

token (structure)

Direct slots

Slot: insert-string

Type

string

Initform

""

Readers

token-insert-string (function)

Writers

(setf token-insert-string) (function)

Structure: token-loop ()

Package

zenekindarl.token

Source

token.lisp (file)

Direct superclasses

token (structure)

Direct slots

Slot: seq

Type

(or list symbol)

Readers

token-seq (function)

Writers

(setf token-seq) (function)

Slot: loop-sym

Type

(or null symbol)

Readers

token-loop-sym (function)

Writers

(setf token-loop-sym) (function)

Structure: token-repeat ()

Package

zenekindarl.token

Source

token.lisp (file)

Direct superclasses

token (structure)

Direct slots

Slot: times

Type

(or integer symbol)

Readers

token-times (function)

Writers

(setf token-times) (function)

Slot: repeat-sym

Type

(or null symbol)

Readers

token-repeat-sym (function)

Writers

(setf token-repeat-sym) (function)

Structure: token-string ()

Package

zenekindarl.token

Source

token.lisp (file)

Direct superclasses

token (structure)

Direct slots

Slot: str

Type

string

Initform

""

Readers

token-str (function)

Writers

(setf token-str) (function)

Structure: token-variable ()

Package

zenekindarl.token

Source

token.lisp (file)

Direct superclasses

token (structure)

Direct slots

Slot: value

Type

(or null symbol)

Readers

token-value (function)

Writers

(setf token-value) (function)

Slot: auto-escape

Type

boolean

Initform

t

Readers

token-auto-escape (function)

Writers

(setf token-auto-escape) (function)

6.1.5 Classes

Class: att-constant ()

Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-leaf (class)

Direct methods

• emit-code (method)
• att-equal (method)
• print-object (method)
• value (method)
• value (method)

Direct slots

Slot: value

Initargs

:value

Readers

value (generic function)

Writers

(setf value) (generic function)

Slot: auto-escape

Class: att-control ()

Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-node (class)

Direct subclasses

• att-output (class)
• att-progn (class)
• att-if (class)
• att-loop (class)
• att-repeat (class)
• att-include (class)

Class: att-eval ()

Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-leaf (class)

Direct methods

• emit-code (method)
• att-equal (method)
• print-object (method)
• sexp (method)
• sexp (method)

Direct slots

Slot: sexp

Initargs

:sexp

Readers

sexp (generic function)

Writers

(setf sexp) (generic function)

Class: att-gensym ()

Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-variable (class)

Direct methods

• att-equal (method)
• print-object (method)
• gensym-string (method)
• gensym-string (method)

Direct slots

Slot: gensym-string

Type

(quote (or null string))

Initargs

:gensym-string

Readers

gensym-string (generic function)

Writers

(setf gensym-string) (generic function)

Class: att-if ()

Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-control (class)

Direct methods

• emit-code (method)
• traverse-node (method)
• att-equal (method)
• print-object (method)
• else-clause (method)
• else-clause (method)
• then-clause (method)
• then-clause (method)
• cond-clause (method)
• cond-clause (method)

Direct slots

Slot: cond-clause

Initargs

:cond

Readers

cond-clause (generic function)

Writers

(setf cond-clause) (generic function)

Slot: then-clause

Type

(quote zenekindarl.att:att-node)

Initargs

:then

Readers

then-clause (generic function)

Writers

(setf then-clause) (generic function)

Slot: else-clause

Type

(quote zenekindarl.att:att-node)

Initargs

:else

Initform

(zenekindarl.att:att-nil)

Readers

else-clause (generic function)

Writers

(setf else-clause) (generic function)

Class: att-include ()

Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-control (class)

Direct methods

• att-equal (method)
• print-object (method)
• path (method)
• path (method)

Direct slots

Slot: path

Initargs

:path

Readers

path (generic function)

Writers

(setf path) (generic function)

Class: att-leaf ()

Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-node (class)

Direct subclasses

• att-string (class)
• att-variable (class)
• att-constant (class)
• att-eval (class)
• att-nil (class)

Direct methods

• emit-code (method)
• http-escape (method)
• auto-escape (method)
• auto-escape (method)

Direct slots

Slot: auto-escape

Type

(quote (or null t))

Initargs

:auto-escape

Initform

t

Readers

auto-escape (generic function)

Writers

(setf auto-escape) (generic function)

Class: att-loop ()

Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-control (class)

Direct methods

• emit-code (method)
• traverse-node (method)
• att-equal (method)
• print-object (method)
• body (method)
• body (method)
• loop-var (method)
• loop-var (method)
• loop-seq (method)
• loop-seq (method)

Direct slots

Slot: loop-seq

Type

(quote zenekindarl.att:att-leaf)

Initargs

:loop-seq

Readers

loop-seq (generic function)

Writers

(setf loop-seq) (generic function)

Slot: loop-var

Type

(quote zenekindarl.att:att-variable)

Initargs

:loop-var

Readers

loop-var (generic function)

Writers

(setf loop-var) (generic function)

Slot: body

Type

(quote zenekindarl.att:att-node)

Initargs

:body

Readers

body (generic function)

Writers

(setf body) (generic function)