The zenekindarl Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The zenekindarl Reference Manual

This is the zenekindarl Reference Manual, version 0.1, generated automatically by Declt version 2.3 "Robert April" on Tue Jan 09 16:04:33 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Build Status Coverage Status

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.

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

Copyright

Copyright (c) 2014


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 zenekindarl

Author

κeen

License
Description

A fast precompiling template engine

Version

0.1

Dependencies
Source

zenekindarl.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

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


Next: , Previous: , Up: Modules   [Contents][Index]

3.1 zenekindarl/src

Parent

zenekindarl (system)

Location

src/

Components

Next: , Previous: , Up: Modules   [Contents][Index]

3.2 zenekindarl/src/be

Dependency

backend.lisp (file)

Parent

src (module)

Location

src/backend/

Components

Previous: , Up: Modules   [Contents][Index]

3.3 zenekindarl/src/le

Dependencies
Parent

src (module)

Location

src/lexer/

Component

default.lisp (file)


Next: , Previous: , Up: Top   [Contents][Index]

4 Files

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


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 zenekindarl.asd

Location

zenekindarl.asd

Systems

zenekindarl (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 zenekindarl/src/zenekindarl.lisp

Dependencies
Parent

src (module)

Location

src/zenekindarl.lisp

Packages

zenekindarl

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 zenekindarl/src/att.lisp

Dependency

util.lisp (file)

Parent

src (module)

Location

src/att.lisp

Packages

zenekindarl.att

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 zenekindarl/src/backend.lisp

Dependencies
Parent

src (module)

Location

src/backend.lisp

Packages

zenekindarl.backend

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 zenekindarl/src/be/stream.lisp

Parent

be (module)

Location

src/backend/stream.lisp

Packages

zenekindarl.backend.stream

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

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
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

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

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 zenekindarl/src/token.lisp

Parent

src (module)

Location

src/token.lisp

Packages

zenekindarl.token

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.9 zenekindarl/src/pass.lisp

Dependencies
Parent

src (module)

Location

src/pass.lisp

Packages

zenekindarl.pass

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.10 zenekindarl/src/parse.lisp

Dependencies
Parent

src (module)

Location

src/parse.lisp

Packages

zenekindarl.parse

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.11 zenekindarl/src/lexer.lisp

Parent

src (module)

Location

src/lexer.lisp

Packages

zenekindarl.lexer

Exported Definitions

lex (generic function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

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

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.13 zenekindarl/src/parser.lisp

Dependencies
Parent

src (module)

Location

src/parser.lisp

Packages

zenekindarl.parser

Exported Definitions

=template (function)

Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.14 zenekindarl/src/util.lisp

Parent

src (module)

Location

src/util.lisp

Packages

zenekindarl.util

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 zenekindarl

Source

zenekindarl.lisp (file)

Nickname

zen

Use List
Exported Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.2 zenekindarl.att

Source

att.lisp (file)

Use List
Used By List
Exported Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.3 zenekindarl.backend

Source

backend.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.4 zenekindarl.backend.stream

Source

stream.lisp (file)

Use List
Used By List
Exported Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.5 zenekindarl.backend.sequence

Source

sequence.lisp (file)

Use List
Used By List

zenekindarl

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.6 zenekindarl.backend.fast-io

Source

fast-io.lisp (file)

Use List
Used By List

zenekindarl

Exported Definitions

fast-io-backend (class)


Next: , Previous: , Up: Packages   [Contents][Index]

5.7 zenekindarl.token

Source

token.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.8 zenekindarl.pass

Source

pass.lisp (file)

Use List
Used By List

zenekindarl

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.9 zenekindarl.parse

Source

parse.lisp (file)

Use List
Used By List

zenekindarl

Exported Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.10 zenekindarl.lexer

Source

lexer.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.11 zenekindarl.lexer.default

Source

default.lisp (file)

Use List
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.12 zenekindarl.parser

Source

parser.lisp (file)

Use List
Used By List

zenekindarl.parse

Exported Definitions

=template (function)

Internal Definitions

Previous: , Up: Packages   [Contents][Index]

5.13 zenekindarl.util

Source

util.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *optimizing-passes*
Package

zenekindarl.pass

Source

pass.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Classes

Class: att-constant ()
Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-leaf (class)

Direct methods
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
Class: att-eval ()
Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-leaf (class)

Direct methods
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
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
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
Direct methods
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
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)

Class: att-nil ()
Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-leaf (class)

Direct methods
Class: att-node ()
Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Class: att-output ()
Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-control (class)

Direct methods
Direct slots
Slot: arg
Initargs

:arg

Readers

arg (generic function)

Writers

(setf arg) (generic function)

Class: att-progn ()
Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-control (class)

Direct methods
Direct slots
Slot: nodes
Type

(quote list)

Initargs

:nodes

Readers

nodes (generic function)

Writers

(setf nodes) (generic function)

Class: att-repeat ()
Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-control (class)

Direct methods
Direct slots
Slot: repeat-times
Type

(quote zenekindarl.att:att-leaf)

Initargs

:repeat-times

Readers

repeat-times (generic function)

Writers

(setf repeat-times) (generic function)

Slot: repeat-var
Type

(quote zenekindarl.att:att-variable)

Initargs

:repeat-var

Readers

repeat-var (generic function)

Writers

(setf repeat-var) (generic function)

Slot: body
Type

(quote zenekindarl.att:att-node)

Initargs

:body

Readers

body (generic function)

Writers

(setf body) (generic function)

Class: att-string ()
Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-leaf (class)

Direct methods
Direct slots
Slot: value
Type

(quote string)

Initargs

:value

Readers

value (generic function)

Writers

(setf value) (generic function)

Slot: auto-escape
Class: att-variable ()
Package

zenekindarl.att

Source

att.lisp (file)

Direct superclasses

att-leaf (class)

Direct subclasses

att-gensym (class)

Direct methods
Direct slots
Slot: varsym
Type

(quote symbol)

Initargs

:varsym

Readers

varsym (generic function)

Writers

(setf varsym) (generic function)

Slot: vartype
Type

(quote (or :string :anything))

Initargs

:vartype

Initform

:anything

Readers

vartype (generic function)

Writers

(setf vartype) (generic function)

Class: backend ()
Package

zenekindarl.backend

Source

backend.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

stream-backend (class)

Direct methods
  • scopes (method)
  • scopes (method)
  • symbols (method)
  • symbols (method)
Direct slots
Slot: symbols
Readers

symbols (generic function)

Writers

(setf symbols) (generic function)

Slot: scopes
Readers

scopes (generic function)

Writers

(setf scopes) (generic function)

Class: fast-io-backend ()
Package

zenekindarl.backend.fast-io

Source

fast-io.lisp (file)

Direct superclasses

octet-backend (class)

Direct methods

emit-lambda (method)

Class: octet-backend ()
Package

zenekindarl.backend.sequence

Source

sequence.lisp (file)

Direct superclasses
Direct subclasses

fast-io-backend (class)

Direct methods
Direct slots
Slot: buffer%
Initform

(gensym "buffer")

Readers

buffer-of (generic function)

Writers

(setf buffer-of) (generic function)

Class: octet-stream-backend ()
Package

zenekindarl.backend.stream

Source

stream.lisp (file)

Direct superclasses

stream-backend (class)

Direct subclasses

octet-backend (class)

Direct methods
Class: stream-backend ()
Package

zenekindarl.backend.stream

Source

stream.lisp (file)

Direct superclasses

backend (class)

Direct subclasses
Direct methods
Direct slots
Slot: stream%
Initargs

:stream

Initform

(gensym "stream")

Readers

stream-of (generic function)

Writers

(setf stream-of) (generic function)

Class: string-backend ()
Package

zenekindarl.backend.sequence

Source

sequence.lisp (file)

Direct superclasses

stream-backend (class)

Direct subclasses

octet-backend (class)

Direct methods
Direct slots
Slot: string
Initargs

:string

Readers

string-of (generic function)

Writers

(setf string-of) (generic function)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 Types

Type: octets ()
Package

zenekindarl.util

Source

util.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: *necessary-passes*
Package

zenekindarl.pass

Source

pass.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Functions

Function: =control-if ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: =control-include ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: =control-insert ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: =control-loop ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: =control-repeat ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: =control-variable ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: =template-string ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: ?token-else ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: ?token-end ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: ?token-if ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: ?token-include ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: ?token-insert ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: ?token-loop ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: ?token-repeat ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: ?token-string ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: ?token-variable ()
Package

zenekindarl.parser

Source

parser.lisp (file)

Function: append-att-node &rest ARGS
Package

zenekindarl.pass

Source

pass.lisp (file)

Function: copy-token INSTANCE
Package

zenekindarl.token

Source

token.lisp (file)

Function: copy-token-else INSTANCE
Package

zenekindarl.token

Source

token.lisp (file)

Function: copy-token-end INSTANCE
Package

zenekindarl.token

Source

token.lisp (file)

Function: copy-token-if INSTANCE
Package

zenekindarl.token

Source

token.lisp (file)

Function: copy-token-include INSTANCE
Package

zenekindarl.token

Source

token.lisp (file)

Function: copy-token-insert INSTANCE
Package

zenekindarl.token

Source

token.lisp (file)

Function: copy-token-loop INSTANCE
Package

zenekindarl.token

Source

token.lisp (file)

Function: copy-token-repeat INSTANCE
Package

zenekindarl.token

Source

token.lisp (file)

Function: copy-token-string INSTANCE
Package

zenekindarl.token

Source

token.lisp (file)

Function: copy-token-variable INSTANCE
Package

zenekindarl.token

Source

token.lisp (file)

Function: id PROP
Package

zenekindarl.parser

Source

parser.lisp (file)

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

zenekindarl.token

Source

token.lisp (file)

Function: read-out STR START EOF-VALUE
Package

zenekindarl.lexer.default

Source

default.lisp (file)

Function: s/=template INPUT
Package

zenekindarl.parser

Source

/home/quickbuilder/quicklisp/dists/quicklisp/software/maxpc-20171130-git/primitives.lisp

Function: token-p OBJECT
Package

zenekindarl.token

Source

token.lisp (file)

Function: tokenize OBJ START END
Package

zenekindarl.lexer.default

Source

default.lisp (file)

Function: tokenize-else START END REST
Package

zenekindarl.lexer.default

Source

default.lisp (file)

Function: tokenize-end START END REST
Package

zenekindarl.lexer.default

Source

default.lisp (file)

Function: tokenize-if START END REST
Package

zenekindarl.lexer.default

Source

default.lisp (file)

Function: tokenize-include START END REST
Package

zenekindarl.lexer.default

Source

default.lisp (file)

Function: tokenize-insert START END REST
Package

zenekindarl.lexer.default

Source

default.lisp (file)

Function: tokenize-loop START END REST
Package

zenekindarl.lexer.default

Source

default.lisp (file)

Function: tokenize-repeat START END REST
Package

zenekindarl.lexer.default

Source

default.lisp (file)

Function: tokenize-variable START END REST
Package

zenekindarl.lexer.default

Source

default.lisp (file)

Function: tokens STR START
Package

zenekindarl.lexer.default

Source

default.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Generic functions

Generic Function: add-to-scope SYM BACKEND
Package

zenekindarl.backend

Source

backend.lisp (file)

Methods
Method: add-to-scope SYM BACKEND
Generic Function: append-att-node-aux X Y
Package

zenekindarl.pass

Source

pass.lisp (file)

Methods
Method: append-att-node-aux (X att-progn) (Y att-progn)
Method: append-att-node-aux (X att-string) (Y att-string)
Method: append-att-node-aux (X att-output) (Y att-output)
Method: append-att-node-aux (X att-nil) (Y att-nil)
Method: append-att-node-aux (X att-nil) Y
Method: append-att-node-aux X (Y att-nil)
Method: append-att-node-aux (X att-node) (Y att-node)
Generic Function: append-sequence-impl OBJ
Package

zenekindarl.pass

Source

pass.lisp (file)

Methods
Method: append-sequence-impl (OBJ att-progn)
Method: append-sequence-impl (OBJ att-node)
Generic Function: find-from-scope SYM BACKEND
Package

zenekindarl.backend

Source

backend.lisp (file)

Methods
Method: find-from-scope SYM BACKEND
Generic Function: flatten-impl OBJ
Package

zenekindarl.pass

Source

pass.lisp (file)

Methods
Method: flatten-impl (OBJ att-progn)
Method: flatten-impl (OBJ att-node)
Generic Function: fold-variables-impl OBJ VARS
Package

zenekindarl.pass

Source

pass.lisp (file)

Methods
Method: fold-variables-impl (OBJ att-variable) VARS
Method: fold-variables-impl (OBJ att-node) VARS
Generic Function: http-escape OBJ SEXP
Package

zenekindarl.backend

Source

backend.lisp (file)

Methods
Method: http-escape (OBJ att-variable) SEXP
Method: http-escape (OBJ att-string) SEXP
Method: http-escape OBJ SEXP
Method: http-escape (OBJ att-leaf) SEXP
Generic Function: pop-scope BACKEND
Package

zenekindarl.backend

Source

backend.lisp (file)

Methods
Method: pop-scope BACKEND
Generic Function: push-scope BACKEND
Package

zenekindarl.backend

Source

backend.lisp (file)

Methods
Method: push-scope BACKEND
Generic Function: remove-progn-impl OBJ
Package

zenekindarl.pass

Source

pass.lisp (file)

Methods
Method: remove-progn-impl (OBJ att-progn)
Method: remove-progn-impl (OBJ att-node)
Generic Function: scopes OBJECT
Generic Function: (setf scopes) NEW-VALUE OBJECT
Package

zenekindarl.backend

Methods
Method: scopes (BACKEND backend)

automatically generated reader method

Source

backend.lisp (file)

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

automatically generated writer method

Source

backend.lisp (file)

Generic Function: string-of OBJECT
Generic Function: (setf string-of) NEW-VALUE OBJECT
Package

zenekindarl.backend.sequence

Methods
Method: string-of (STRING-BACKEND string-backend)

automatically generated reader method

Source

sequence.lisp (file)

Method: (setf string-of) NEW-VALUE (STRING-BACKEND string-backend)

automatically generated writer method

Source

sequence.lisp (file)

Generic Function: traverse-node FUNC OBJ
Package

zenekindarl.pass

Source

pass.lisp (file)

Methods
Method: traverse-node FUNC (OBJ att-progn)
Method: traverse-node FUNC (OBJ att-if)
Method: traverse-node FUNC (OBJ att-output)
Method: traverse-node FUNC (OBJ att-loop)
Method: traverse-node FUNC (OBJ att-repeat)
Method: traverse-node FUNC (OBJ att-node)

Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Structures

Structure: token ()
Package

zenekindarl.token

Source

token.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct slots
Slot: start
Type

integer

Initform

0

Readers

token-start (function)

Writers

(setf token-start) (function)

Slot: end
Type

integer

Initform

0

Readers

token-end (function)

Writers

(setf token-end) (function)

Slot: template
Readers

token-template (function)

Writers

(setf token-template) (function)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   M   Z  
Index Entry  Section

F
File, Lisp, zenekindarl.asd: The zenekindarl<dot>asd file
File, Lisp, zenekindarl/src/att.lisp: The zenekindarl/src/att<dot>lisp file
File, Lisp, zenekindarl/src/backend.lisp: The zenekindarl/src/backend<dot>lisp file
File, Lisp, zenekindarl/src/be/fast-io.lisp: The zenekindarl/src/be/fast-io<dot>lisp file
File, Lisp, zenekindarl/src/be/sequence.lisp: The zenekindarl/src/be/sequence<dot>lisp file
File, Lisp, zenekindarl/src/be/stream.lisp: The zenekindarl/src/be/stream<dot>lisp file
File, Lisp, zenekindarl/src/le/default.lisp: The zenekindarl/src/le/default<dot>lisp file
File, Lisp, zenekindarl/src/lexer.lisp: The zenekindarl/src/lexer<dot>lisp file
File, Lisp, zenekindarl/src/parse.lisp: The zenekindarl/src/parse<dot>lisp file
File, Lisp, zenekindarl/src/parser.lisp: The zenekindarl/src/parser<dot>lisp file
File, Lisp, zenekindarl/src/pass.lisp: The zenekindarl/src/pass<dot>lisp file
File, Lisp, zenekindarl/src/token.lisp: The zenekindarl/src/token<dot>lisp file
File, Lisp, zenekindarl/src/util.lisp: The zenekindarl/src/util<dot>lisp file
File, Lisp, zenekindarl/src/zenekindarl.lisp: The zenekindarl/src/zenekindarl<dot>lisp file

L
Lisp File, zenekindarl.asd: The zenekindarl<dot>asd file
Lisp File, zenekindarl/src/att.lisp: The zenekindarl/src/att<dot>lisp file
Lisp File, zenekindarl/src/backend.lisp: The zenekindarl/src/backend<dot>lisp file
Lisp File, zenekindarl/src/be/fast-io.lisp: The zenekindarl/src/be/fast-io<dot>lisp file
Lisp File, zenekindarl/src/be/sequence.lisp: The zenekindarl/src/be/sequence<dot>lisp file
Lisp File, zenekindarl/src/be/stream.lisp: The zenekindarl/src/be/stream<dot>lisp file
Lisp File, zenekindarl/src/le/default.lisp: The zenekindarl/src/le/default<dot>lisp file
Lisp File, zenekindarl/src/lexer.lisp: The zenekindarl/src/lexer<dot>lisp file
Lisp File, zenekindarl/src/parse.lisp: The zenekindarl/src/parse<dot>lisp file
Lisp File, zenekindarl/src/parser.lisp: The zenekindarl/src/parser<dot>lisp file
Lisp File, zenekindarl/src/pass.lisp: The zenekindarl/src/pass<dot>lisp file
Lisp File, zenekindarl/src/token.lisp: The zenekindarl/src/token<dot>lisp file
Lisp File, zenekindarl/src/util.lisp: The zenekindarl/src/util<dot>lisp file
Lisp File, zenekindarl/src/zenekindarl.lisp: The zenekindarl/src/zenekindarl<dot>lisp file

M
Module, zenekindarl/src: The zenekindarl/src module
Module, zenekindarl/src/be: The zenekindarl/src/be module
Module, zenekindarl/src/le: The zenekindarl/src/le module

Z
zenekindarl.asd: The zenekindarl<dot>asd file
zenekindarl/src: The zenekindarl/src module
zenekindarl/src/att.lisp: The zenekindarl/src/att<dot>lisp file
zenekindarl/src/backend.lisp: The zenekindarl/src/backend<dot>lisp file
zenekindarl/src/be: The zenekindarl/src/be module
zenekindarl/src/be/fast-io.lisp: The zenekindarl/src/be/fast-io<dot>lisp file
zenekindarl/src/be/sequence.lisp: The zenekindarl/src/be/sequence<dot>lisp file
zenekindarl/src/be/stream.lisp: The zenekindarl/src/be/stream<dot>lisp file
zenekindarl/src/le: The zenekindarl/src/le module
zenekindarl/src/le/default.lisp: The zenekindarl/src/le/default<dot>lisp file
zenekindarl/src/lexer.lisp: The zenekindarl/src/lexer<dot>lisp file
zenekindarl/src/parse.lisp: The zenekindarl/src/parse<dot>lisp file
zenekindarl/src/parser.lisp: The zenekindarl/src/parser<dot>lisp file
zenekindarl/src/pass.lisp: The zenekindarl/src/pass<dot>lisp file
zenekindarl/src/token.lisp: The zenekindarl/src/token<dot>lisp file
zenekindarl/src/util.lisp: The zenekindarl/src/util<dot>lisp file
zenekindarl/src/zenekindarl.lisp: The zenekindarl/src/zenekindarl<dot>lisp file

Jump to:   F   L   M   Z  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (   =   ?  
A   B   C   E   F   G   H   I   L   M   N   O   P   R   S   T   V  
Index Entry  Section

(
(setf arg): Exported generic functions
(setf arg): Exported generic functions
(setf auto-escape): Exported generic functions
(setf auto-escape): Exported generic functions
(setf body): Exported generic functions
(setf body): Exported generic functions
(setf body): Exported generic functions
(setf buffer-of): Exported generic functions
(setf buffer-of): Exported generic functions
(setf cond-clause): Exported generic functions
(setf cond-clause): Exported generic functions
(setf else-clause): Exported generic functions
(setf else-clause): Exported generic functions
(setf gensym-string): Exported generic functions
(setf gensym-string): Exported generic functions
(setf loop-seq): Exported generic functions
(setf loop-seq): Exported generic functions
(setf loop-var): Exported generic functions
(setf loop-var): Exported generic functions
(setf nodes): Exported generic functions
(setf nodes): Exported generic functions
(setf path): Exported generic functions
(setf path): Exported generic functions
(setf repeat-times): Exported generic functions
(setf repeat-times): Exported generic functions
(setf repeat-var): Exported generic functions
(setf repeat-var): Exported generic functions
(setf scopes): Internal generic functions
(setf scopes): Internal generic functions
(setf sexp): Exported generic functions
(setf sexp): Exported generic functions
(setf stream-of): Exported generic functions
(setf stream-of): Exported generic functions
(setf string-of): Internal generic functions
(setf string-of): Internal generic functions
(setf symbols): Exported generic functions
(setf symbols): Exported generic functions
(setf then-clause): Exported generic functions
(setf then-clause): Exported generic functions
(setf token-auto-escape): Exported functions
(setf token-cond-clause): Exported functions
(setf token-end): Exported functions
(setf token-include-template): Exported functions
(setf token-insert-string): Exported functions
(setf token-loop-sym): Exported functions
(setf token-repeat-sym): Exported functions
(setf token-seq): Exported functions
(setf token-start): Exported functions
(setf token-str): Exported functions
(setf token-template): Exported functions
(setf token-times): Exported functions
(setf token-value): Exported functions
(setf value): Exported generic functions
(setf value): Exported generic functions
(setf value): Exported generic functions
(setf varsym): Exported generic functions
(setf varsym): Exported generic functions
(setf vartype): Exported generic functions
(setf vartype): Exported generic functions

=
=control-if: Internal functions
=control-include: Internal functions
=control-insert: Internal functions
=control-loop: Internal functions
=control-repeat: Internal functions
=control-variable: Internal functions
=template: Exported functions
=template-string: Internal functions

?
?token-else: Internal functions
?token-end: Internal functions
?token-if: Internal functions
?token-include: Internal functions
?token-insert: Internal functions
?token-loop: Internal functions
?token-repeat: Internal functions
?token-string: Internal functions
?token-variable: Internal functions

A
add-to-scope: Internal generic functions
add-to-scope: Internal generic functions
append-att-node: Internal functions
append-att-node-aux: Internal generic functions
append-att-node-aux: Internal generic functions
append-att-node-aux: Internal generic functions
append-att-node-aux: Internal generic functions
append-att-node-aux: Internal generic functions
append-att-node-aux: Internal generic functions
append-att-node-aux: Internal generic functions
append-att-node-aux: Internal generic functions
append-sequence-impl: Internal generic functions
append-sequence-impl: Internal generic functions
append-sequence-impl: Internal generic functions
append-sequence-pass: Exported functions
apply-passes: Exported functions
arg: Exported generic functions
arg: Exported generic functions
att-constant: Exported functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-equal: Exported generic functions
att-eval: Exported functions
att-gensym: Exported functions
att-if: Exported functions
att-include: Exported functions
att-loop: Exported functions
att-nil: Exported functions
att-output: Exported functions
att-progn: Exported functions
att-repeat: Exported functions
att-string: Exported functions
att-variable: Exported functions
auto-escape: Exported generic functions
auto-escape: Exported generic functions

B
body: Exported generic functions
body: Exported generic functions
body: Exported generic functions
buffer-of: Exported generic functions
buffer-of: Exported generic functions

C
compile-template-file: Exported functions
compile-template-string: Exported functions
cond-clause: Exported generic functions
cond-clause: Exported generic functions
copy-token: Internal functions
copy-token-else: Internal functions
copy-token-end: Internal functions
copy-token-if: Internal functions
copy-token-include: Internal functions
copy-token-insert: Internal functions
copy-token-loop: Internal functions
copy-token-repeat: Internal functions
copy-token-string: Internal functions
copy-token-variable: Internal functions

E
else-clause: Exported generic functions
else-clause: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-code: Exported generic functions
emit-lambda: Exported generic functions
emit-lambda: Exported generic functions
emit-lambda: Exported generic functions
emit-lambda: Exported generic functions
emit-lambda: Exported generic functions
emit-lambda: Exported generic functions
emit-lambda: Exported generic functions
emit-parameters: Exported generic functions
emit-parameters: Exported generic functions

F
find-from-scope: Internal generic functions
find-from-scope: Internal generic functions
flatten-impl: Internal generic functions
flatten-impl: Internal generic functions
flatten-impl: Internal generic functions
flatten-pass: Exported functions
fold-variables-impl: Internal generic functions
fold-variables-impl: Internal generic functions
fold-variables-impl: Internal generic functions
fold-variables-pass: Exported functions
Function, (setf token-auto-escape): Exported functions
Function, (setf token-cond-clause): Exported functions
Function, (setf token-end): Exported functions
Function, (setf token-include-template): Exported functions
Function, (setf token-insert-string): Exported functions
Function, (setf token-loop-sym): Exported functions
Function, (setf token-repeat-sym): Exported functions
Function, (setf token-seq): Exported functions
Function, (setf token-start): Exported functions
Function, (setf token-str): Exported functions
Function, (setf token-template): Exported functions
Function, (setf token-times): Exported functions
Function, (setf token-value): Exported functions
Function, =control-if: Internal functions
Function, =control-include: Internal functions
Function, =control-insert: Internal functions
Function, =control-loop: Internal functions
Function, =control-repeat: Internal functions
Function, =control-variable: Internal functions
Function, =template: Exported functions
Function, =template-string: Internal functions
Function, ?token-else: Internal functions
Function, ?token-end: Internal functions
Function, ?token-if: Internal functions
Function, ?token-include: Internal functions
Function, ?token-insert: Internal functions
Function, ?token-loop: Internal functions
Function, ?token-repeat: Internal functions
Function, ?token-string: Internal functions
Function, ?token-variable: Internal functions
Function, append-att-node: Internal functions
Function, append-sequence-pass: Exported functions
Function, apply-passes: Exported functions
Function, att-constant: Exported functions
Function, att-eval: Exported functions
Function, att-gensym: Exported functions
Function, att-if: Exported functions
Function, att-include: Exported functions
Function, att-loop: Exported functions
Function, att-nil: Exported functions
Function, att-output: Exported functions
Function, att-progn: Exported functions
Function, att-repeat: Exported functions
Function, att-string: Exported functions
Function, att-variable: Exported functions
Function, compile-template-file: Exported functions
Function, compile-template-string: Exported functions
Function, copy-token: Internal functions
Function, copy-token-else: Internal functions
Function, copy-token-end: Internal functions
Function, copy-token-if: Internal functions
Function, copy-token-include: Internal functions
Function, copy-token-insert: Internal functions
Function, copy-token-loop: Internal functions
Function, copy-token-repeat: Internal functions
Function, copy-token-string: Internal functions
Function, copy-token-variable: Internal functions
Function, flatten-pass: Exported functions
Function, fold-variables-pass: Exported functions
Function, id: Internal functions
Function, make-token: Internal functions
Function, make-token-else: Exported functions
Function, make-token-end: Exported functions
Function, make-token-if: Exported functions
Function, make-token-include: Exported functions
Function, make-token-insert: Exported functions
Function, make-token-loop: Exported functions
Function, make-token-repeat: Exported functions
Function, make-token-string: Exported functions
Function, make-token-variable: Exported functions
Function, octets: Exported functions
Function, parse-template-file: Exported functions
Function, parse-template-string: Exported functions
Function, read-out: Internal functions
Function, remove-progn-pass: Exported functions
Function, render: Exported functions
Function, render-file: Exported functions
Function, s/=template: Internal functions
Function, token-auto-escape: Exported functions
Function, token-cond-clause: Exported functions
Function, token-else-p: Exported functions
Function, token-end: Exported functions
Function, token-end-p: Exported functions
Function, token-if-p: Exported functions
Function, token-include-p: Exported functions
Function, token-include-template: Exported functions
Function, token-insert-p: Exported functions
Function, token-insert-string: Exported functions
Function, token-loop-p: Exported functions
Function, token-loop-sym: Exported functions
Function, token-p: Internal functions
Function, token-repeat-p: Exported functions
Function, token-repeat-sym: Exported functions
Function, token-seq: Exported functions
Function, token-start: Exported functions
Function, token-str: Exported functions
Function, token-string-p: Exported functions
Function, token-template: Exported functions
Function, token-times: Exported functions
Function, token-value: Exported functions
Function, token-variable-p: Exported functions
Function, tokenize: Internal functions
Function, tokenize-else: Internal functions
Function, tokenize-end: Internal functions
Function, tokenize-if: Internal functions
Function, tokenize-include: Internal functions
Function, tokenize-insert: Internal functions
Function, tokenize-loop: Internal functions
Function, tokenize-repeat: Internal functions
Function, tokenize-variable: Internal functions
Function, tokens: Internal functions

G
Generic Function, (setf arg): Exported generic functions
Generic Function, (setf auto-escape): Exported generic functions
Generic Function, (setf body): Exported generic functions
Generic Function, (setf buffer-of): Exported generic functions
Generic Function, (setf cond-clause): Exported generic functions
Generic Function, (setf else-clause): Exported generic functions
Generic Function, (setf gensym-string): Exported generic functions
Generic Function, (setf loop-seq): Exported generic functions
Generic Function, (setf loop-var): Exported generic functions
Generic Function, (setf nodes): Exported generic functions
Generic Function, (setf path): Exported generic functions
Generic Function, (setf repeat-times): Exported generic functions
Generic Function, (setf repeat-var): Exported generic functions
Generic Function, (setf scopes): Internal generic functions
Generic Function, (setf sexp): Exported generic functions
Generic Function, (setf stream-of): Exported generic functions
Generic Function, (setf string-of): Internal generic functions
Generic Function, (setf symbols): Exported generic functions
Generic Function, (setf then-clause): Exported generic functions
Generic Function, (setf value): Exported generic functions
Generic Function, (setf varsym): Exported generic functions
Generic Function, (setf vartype): Exported generic functions
Generic Function, add-to-scope: Internal generic functions
Generic Function, append-att-node-aux: Internal generic functions
Generic Function, append-sequence-impl: Internal generic functions
Generic Function, arg: Exported generic functions
Generic Function, att-equal: Exported generic functions
Generic Function, auto-escape: Exported generic functions
Generic Function, body: Exported generic functions
Generic Function, buffer-of: Exported generic functions
Generic Function, cond-clause: Exported generic functions
Generic Function, else-clause: Exported generic functions
Generic Function, emit-code: Exported generic functions
Generic Function, emit-lambda: Exported generic functions
Generic Function, emit-parameters: Exported generic functions
Generic Function, find-from-scope: Internal generic functions
Generic Function, flatten-impl: Internal generic functions
Generic Function, fold-variables-impl: Internal generic functions
Generic Function, gensym-string: Exported generic functions
Generic Function, http-escape: Internal generic functions
Generic Function, lex: Exported generic functions
Generic Function, loop-seq: Exported generic functions
Generic Function, loop-var: Exported generic functions
Generic Function, make-backend: Exported generic functions
Generic Function, nodes: Exported generic functions
Generic Function, path: Exported generic functions
Generic Function, pop-scope: Internal generic functions
Generic Function, push-scope: Internal generic functions
Generic Function, remove-progn-impl: Internal generic functions
Generic Function, repeat-times: Exported generic functions
Generic Function, repeat-var: Exported generic functions
Generic Function, scopes: Internal generic functions
Generic Function, sexp: Exported generic functions
Generic Function, stream-of: Exported generic functions
Generic Function, string-of: Internal generic functions
Generic Function, symbols: Exported generic functions
Generic Function, then-clause: Exported generic functions
Generic Function, traverse-node: Internal generic functions
Generic Function, value: Exported generic functions
Generic Function, varsym: Exported generic functions
Generic Function, vartype: Exported generic functions
gensym-string: Exported generic functions
gensym-string: Exported generic functions

H
http-escape: Internal generic functions
http-escape: Internal generic functions
http-escape: Internal generic functions
http-escape: Internal generic functions
http-escape: Internal generic functions

I
id: Internal functions

L
lex: Exported generic functions
lex: Exported generic functions
loop-seq: Exported generic functions
loop-seq: Exported generic functions
loop-var: Exported generic functions
loop-var: Exported generic functions

M
make-backend: Exported generic functions
make-backend: Exported generic functions
make-backend: Exported generic functions
make-backend: Exported generic functions
make-backend: Exported generic functions
make-backend: Exported generic functions
make-token: Internal functions
make-token-else: Exported functions
make-token-end: Exported functions
make-token-if: Exported functions
make-token-include: Exported functions
make-token-insert: Exported functions
make-token-loop: Exported functions
make-token-repeat: Exported functions
make-token-string: Exported functions
make-token-variable: Exported functions
Method, (setf arg): Exported generic functions
Method, (setf auto-escape): Exported generic functions
Method, (setf body): Exported generic functions
Method, (setf body): Exported generic functions
Method, (setf buffer-of): Exported generic functions
Method, (setf cond-clause): Exported generic functions
Method, (setf else-clause): Exported generic functions
Method, (setf gensym-string): Exported generic functions
Method, (setf loop-seq): Exported generic functions
Method, (setf loop-var): Exported generic functions
Method, (setf nodes): Exported generic functions
Method, (setf path): Exported generic functions
Method, (setf repeat-times): Exported generic functions
Method, (setf repeat-var): Exported generic functions
Method, (setf scopes): Internal generic functions
Method, (setf sexp): Exported generic functions
Method, (setf stream-of): Exported generic functions
Method, (setf string-of): Internal generic functions
Method, (setf symbols): Exported generic functions
Method, (setf then-clause): Exported generic functions
Method, (setf value): Exported generic functions
Method, (setf value): Exported generic functions
Method, (setf varsym): Exported generic functions
Method, (setf vartype): Exported generic functions
Method, add-to-scope: Internal generic functions
Method, append-att-node-aux: Internal generic functions
Method, append-att-node-aux: Internal generic functions
Method, append-att-node-aux: Internal generic functions
Method, append-att-node-aux: Internal generic functions
Method, append-att-node-aux: Internal generic functions
Method, append-att-node-aux: Internal generic functions
Method, append-att-node-aux: Internal generic functions
Method, append-sequence-impl: Internal generic functions
Method, append-sequence-impl: Internal generic functions
Method, arg: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, att-equal: Exported generic functions
Method, auto-escape: Exported generic functions
Method, body: Exported generic functions
Method, body: Exported generic functions
Method, buffer-of: Exported generic functions
Method, cond-clause: Exported generic functions
Method, else-clause: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-code: Exported generic functions
Method, emit-lambda: Exported generic functions
Method, emit-lambda: Exported generic functions
Method, emit-lambda: Exported generic functions
Method, emit-lambda: Exported generic functions
Method, emit-lambda: Exported generic functions
Method, emit-lambda: Exported generic functions
Method, emit-parameters: Exported generic functions
Method, find-from-scope: Internal generic functions
Method, flatten-impl: Internal generic functions
Method, flatten-impl: Internal generic functions
Method, fold-variables-impl: Internal generic functions
Method, fold-variables-impl: Internal generic functions
Method, gensym-string: Exported generic functions
Method, http-escape: Internal generic functions
Method, http-escape: Internal generic functions
Method, http-escape: Internal generic functions
Method, http-escape: Internal generic functions
Method, lex: Exported generic functions
Method, loop-seq: Exported generic functions
Method, loop-var: Exported generic functions
Method, make-backend: Exported generic functions
Method, make-backend: Exported generic functions
Method, make-backend: Exported generic functions
Method, make-backend: Exported generic functions
Method, make-backend: Exported generic functions
Method, nodes: Exported generic functions
Method, path: Exported generic functions
Method, pop-scope: Internal generic functions
Method, push-scope: Internal generic functions
Method, remove-progn-impl: Internal generic functions
Method, remove-progn-impl: Internal generic functions
Method, repeat-times: Exported generic functions
Method, repeat-var: Exported generic functions
Method, scopes: Internal generic functions
Method, sexp: Exported generic functions
Method, stream-of: Exported generic functions
Method, string-of: Internal generic functions
Method, symbols: Exported generic functions
Method, then-clause: Exported generic functions
Method, traverse-node: Internal generic functions
Method, traverse-node: Internal generic functions
Method, traverse-node: Internal generic functions
Method, traverse-node: Internal generic functions
Method, traverse-node: Internal generic functions
Method, traverse-node: Internal generic functions
Method, value: Exported generic functions
Method, value: Exported generic functions
Method, varsym: Exported generic functions
Method, vartype: Exported generic functions

N
nodes: Exported generic functions
nodes: Exported generic functions

O
octets: Exported functions

P
parse-template-file: Exported functions
parse-template-string: Exported functions
path: Exported generic functions
path: Exported generic functions
pop-scope: Internal generic functions
pop-scope: Internal generic functions
push-scope: Internal generic functions
push-scope: Internal generic functions

R
read-out: Internal functions
remove-progn-impl: Internal generic functions
remove-progn-impl: Internal generic functions
remove-progn-impl: Internal generic functions
remove-progn-pass: Exported functions
render: Exported functions
render-file: Exported functions
repeat-times: Exported generic functions
repeat-times: Exported generic functions
repeat-var: Exported generic functions
repeat-var: Exported generic functions

S
s/=template: Internal functions
scopes: Internal generic functions
scopes: Internal generic functions
sexp: Exported generic functions
sexp: Exported generic functions
stream-of: Exported generic functions
stream-of: Exported generic functions
string-of: Internal generic functions
string-of: Internal generic functions
symbols: Exported generic functions
symbols: Exported generic functions

T
then-clause: Exported generic functions
then-clause: Exported generic functions
token-auto-escape: Exported functions
token-cond-clause: Exported functions
token-else-p: Exported functions
token-end: Exported functions
token-end-p: Exported functions
token-if-p: Exported functions
token-include-p: Exported functions
token-include-template: Exported functions
token-insert-p: Exported functions
token-insert-string: Exported functions
token-loop-p: Exported functions
token-loop-sym: Exported functions
token-p: Internal functions
token-repeat-p: Exported functions
token-repeat-sym: Exported functions
token-seq: Exported functions
token-start: Exported functions
token-str: Exported functions
token-string-p: Exported functions
token-template: Exported functions
token-times: Exported functions
token-value: Exported functions
token-variable-p: Exported functions
tokenize: Internal functions
tokenize-else: Internal functions
tokenize-end: Internal functions
tokenize-if: Internal functions
tokenize-include: Internal functions
tokenize-insert: Internal functions
tokenize-loop: Internal functions
tokenize-repeat: Internal functions
tokenize-variable: Internal functions
tokens: Internal functions
traverse-node: Internal generic functions
traverse-node: Internal generic functions
traverse-node: Internal generic functions
traverse-node: Internal generic functions
traverse-node: Internal generic functions
traverse-node: Internal generic functions
traverse-node: Internal generic functions

V
value: Exported generic functions
value: Exported generic functions
value: Exported generic functions
varsym: Exported generic functions
varsym: Exported generic functions
vartype: Exported generic functions
vartype: Exported generic functions

Jump to:   (   =   ?  
A   B   C   E   F   G   H   I   L   M   N   O   P   R   S   T   V  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
A   B   C   E   G   I   L   N   P   R   S   T   V  
Index Entry  Section

*
*necessary-passes*: Internal special variables
*optimizing-passes*: Exported special variables

A
arg: Exported classes
auto-escape: Exported structures
auto-escape: Exported classes
auto-escape: Exported classes
auto-escape: Exported classes

B
body: Exported classes
body: Exported classes
buffer%: Exported classes

C
cond-clause: Exported structures
cond-clause: Exported classes

E
else-clause: Exported classes
end: Internal structures

G
gensym-string: Exported classes

I
include-template: Exported structures
insert-string: Exported structures

L
loop-seq: Exported classes
loop-sym: Exported structures
loop-var: Exported classes

N
nodes: Exported classes

P
path: Exported classes

R
repeat-sym: Exported structures
repeat-times: Exported classes
repeat-var: Exported classes

S
scopes: Exported classes
seq: Exported structures
sexp: Exported classes
Slot, arg: Exported classes
Slot, auto-escape: Exported structures
Slot, auto-escape: Exported classes
Slot, auto-escape: Exported classes
Slot, auto-escape: Exported classes
Slot, body: Exported classes
Slot, body: Exported classes
Slot, buffer%: Exported classes
Slot, cond-clause: Exported structures
Slot, cond-clause: Exported classes
Slot, else-clause: Exported classes
Slot, end: Internal structures
Slot, gensym-string: Exported classes
Slot, include-template: Exported structures
Slot, insert-string: Exported structures
Slot, loop-seq: Exported classes
Slot, loop-sym: Exported structures
Slot, loop-var: Exported classes
Slot, nodes: Exported classes
Slot, path: Exported classes
Slot, repeat-sym: Exported structures
Slot, repeat-times: Exported classes
Slot, repeat-var: Exported classes
Slot, scopes: Exported classes
Slot, seq: Exported structures
Slot, sexp: Exported classes
Slot, start: Internal structures
Slot, str: Exported structures
Slot, stream%: Exported classes
Slot, string: Exported classes
Slot, symbols: Exported classes
Slot, template: Internal structures
Slot, then-clause: Exported classes
Slot, times: Exported structures
Slot, value: Exported structures
Slot, value: Exported classes
Slot, value: Exported classes
Slot, varsym: Exported classes
Slot, vartype: Exported classes
Special Variable, *necessary-passes*: Internal special variables
Special Variable, *optimizing-passes*: Exported special variables
start: Internal structures
str: Exported structures
stream%: Exported classes
string: Exported classes
symbols: Exported classes

T
template: Internal structures
then-clause: Exported classes
times: Exported structures

V
value: Exported structures
value: Exported classes
value: Exported classes
varsym: Exported classes
vartype: Exported classes

Jump to:   *  
A   B   C   E   G   I   L   N   P   R   S   T   V  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   B   C   F   O   P   S   T   Z  
Index Entry  Section

A
att-constant: Exported classes
att-control: Exported classes
att-eval: Exported classes
att-gensym: Exported classes
att-if: Exported classes
att-include: Exported classes
att-leaf: Exported classes
att-loop: Exported classes
att-nil: Exported classes
att-node: Exported classes
att-output: Exported classes
att-progn: Exported classes
att-repeat: Exported classes
att-string: Exported classes
att-variable: Exported classes

B
backend: Exported classes

C
Class, att-constant: Exported classes
Class, att-control: Exported classes
Class, att-eval: Exported classes
Class, att-gensym: Exported classes
Class, att-if: Exported classes
Class, att-include: Exported classes
Class, att-leaf: Exported classes
Class, att-loop: Exported classes
Class, att-nil: Exported classes
Class, att-node: Exported classes
Class, att-output: Exported classes
Class, att-progn: Exported classes
Class, att-repeat: Exported classes
Class, att-string: Exported classes
Class, att-variable: Exported classes
Class, backend: Exported classes
Class, fast-io-backend: Exported classes
Class, octet-backend: Exported classes
Class, octet-stream-backend: Exported classes
Class, stream-backend: Exported classes
Class, string-backend: Exported classes

F
fast-io-backend: Exported classes

O
octet-backend: Exported classes
octet-stream-backend: Exported classes
octets: Exported types

P
Package, zenekindarl: The zenekindarl package
Package, zenekindarl.att: The zenekindarl<dot>att package
Package, zenekindarl.backend: The zenekindarl<dot>backend package
Package, zenekindarl.backend.fast-io: The zenekindarl<dot>backend<dot>fast-io package
Package, zenekindarl.backend.sequence: The zenekindarl<dot>backend<dot>sequence package
Package, zenekindarl.backend.stream: The zenekindarl<dot>backend<dot>stream package
Package, zenekindarl.lexer: The zenekindarl<dot>lexer package
Package, zenekindarl.lexer.default: The zenekindarl<dot>lexer<dot>default package
Package, zenekindarl.parse: The zenekindarl<dot>parse package
Package, zenekindarl.parser: The zenekindarl<dot>parser package
Package, zenekindarl.pass: The zenekindarl<dot>pass package
Package, zenekindarl.token: The zenekindarl<dot>token package
Package, zenekindarl.util: The zenekindarl<dot>util package

S
stream-backend: Exported classes
string-backend: Exported classes
Structure, token: Internal structures
Structure, token-else: Exported structures
Structure, token-end: Exported structures
Structure, token-if: Exported structures
Structure, token-include: Exported structures
Structure, token-insert: Exported structures
Structure, token-loop: Exported structures
Structure, token-repeat: Exported structures
Structure, token-string: Exported structures
Structure, token-variable: Exported structures
System, zenekindarl: The zenekindarl system

T
token: Internal structures
token-else: Exported structures
token-end: Exported structures
token-if: Exported structures
token-include: Exported structures
token-insert: Exported structures
token-loop: Exported structures
token-repeat: Exported structures
token-string: Exported structures
token-variable: Exported structures
Type, octets: Exported types

Z
zenekindarl: The zenekindarl system
zenekindarl: The zenekindarl package
zenekindarl.att: The zenekindarl<dot>att package
zenekindarl.backend: The zenekindarl<dot>backend package
zenekindarl.backend.fast-io: The zenekindarl<dot>backend<dot>fast-io package
zenekindarl.backend.sequence: The zenekindarl<dot>backend<dot>sequence package
zenekindarl.backend.stream: The zenekindarl<dot>backend<dot>stream package
zenekindarl.lexer: The zenekindarl<dot>lexer package
zenekindarl.lexer.default: The zenekindarl<dot>lexer<dot>default package
zenekindarl.parse: The zenekindarl<dot>parse package
zenekindarl.parser: The zenekindarl<dot>parser package
zenekindarl.pass: The zenekindarl<dot>pass package
zenekindarl.token: The zenekindarl<dot>token package
zenekindarl.util: The zenekindarl<dot>util package

Jump to:   A   B   C   F   O   P   S   T   Z