The clip Reference Manual

Table of Contents

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

The clip Reference Manual

This is the clip Reference Manual, version 0.6.0, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 03:41:13 2018 GMT+0.


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

1 Introduction

About Clip

Clip is an attempt at a templating library that allows you to write templates in a way that is both accessible to direct webdesign and flexible. The main idea is to incorporate transformation commands into an HTML file through tags and attributes. Clip is heavily dependant on Plump and lQuery.

How To

Load Clip through ASDF or Quicklisp.

(ql:quickload :clip)

To process a template, simply call PROCESS:

(clip:process #p"my-template.ctml")

You may also pass in pure strings or plump nodes. Most likely you will want to include some kind of data in your template. Data in Clip is managed through a central CLIPBOARD. The additional arguments you pass to PROCESS are entered into the initial clipboard like a plist (key and value alternating).

Depending on the current tag environment and how the template is processed at the time these values can come into play. Most of the time, entering the name as passed into PROCESS in the template as an attribute value will then evaluate to the according value using RESOLVE-VALUE. In the case of a symbol this then delegates to CLIP, which returns the value stored in the clipboard.

The value returned by PROCESS is the node you passed into it. You can parse this back into a string using PLUMP:SERIALIZE or lQuery's WRITE-TO-FILE.

Standard Tags

If you specify attributes that are not known on a standard tag, a warning of type UNKNOWN-ATTRIBUTE is signalled. If you do not specify a required attribute on a standard tag, an error of type MISSING-ATTRIBUTE is signalled.

Standard Attributes

Extending Clip

You can define new tag and attribute processors with the macros DEFINE-TAG-PROCESSOR and DEFINE-ATTRIBUTE-PROCESSOR. For tag processors you will usually want to make sure to call PROCESS-ATTRIBUTES and PROCESS-CHILDREN to ensure that tags and attributes within are properly processed. To retrieve values most of the time you need to use RESOLVE-VALUE (or its shorthand RESOLVE-ATTRIBUTE) unless you want to whip up your own system for one reason or another. All tags that you define will automatically be prefixed with C: in order to help highlighting template tags and ensure that there are no collisions with existing tags.

Editor Support

The Emacs extension Web-Mode(version 9.0.77+) provides syntax highlighting for Clip templates. In order for it to recognise the templates, use the .ctml file extension. A huge thanks goes to Bois Francois-Xavier for adding the support.

Tutorials

These are short tutorials to help explaining the effects of each tag and to illustrate some basic templating techniques. The examples will only work with Clip>=0.5.1 and lQuery>=3.1.1 .

###Updating a node with values

(clip:process-to-string
 "<span lquery=\"(text text) (add-class class)\" />"
 :text "Hi!" :class "clip-text")

Explanation: The LQUERY attribute allows you to perform lQuery operations on the node it is an attribute of. In this case, the TEXT function sets the text of the node to the value of TEXT, which we told Clip to be "Hi!". Similarly for ADD-CLASS. Any non-keyword symbol within the template is automatically resolved to a field on the current clipboard. You may think of the clipboard as a form of lexical environment for the template, which we currently set to have the variables TEXT and CLASS bound. The default CLIPBOARD object is special in the sense that it does not differentiate between accessing it with keywords, symbols or strings and is case-insensitive. This makes it easier to access in templates.

Please see the lQuery documentation for all possible node manipulation functions.

Populating from a list

(clip:process-to-string
 "<ol iterate=\"todo-list\"><li lquery=\"(text *)\"></li></ol>"
 :todo-list '("Write tutorials" "Make tiramisu" "Visit grandma"))

The ITERATE attribute goes over the list or vector of elements its attribute-value resolves to and uses each item as the current clipboard for the iteration element. Since in this case these values themselves are direct strings we cannot retrieve further values from them and instead need to use * to refer to the entire clipboard.

Conditionals

(clip:process-to-string
 "<ul iterate=\"users\">
  <li><c:if test=\"anonymous\"><c:then>Username Hidden</c:then><c:else lquery=\"(text username)\"/></c:if></li>
</ul>"
 :users '((:username "Some Guy" :anonymous T) (:username "Some Other Guy" :anonymous NIL) (:username "You" :anonymous NIL)))

Clip offers a couple of constructs to perform conditionals. These constructs are C:WHEN C:UNLESS and C:IF, after their CL equivalents. Each take an attribute called TEST that has to resolve to a non-NIL value to be taken as true. In the case of C:IF, three special local child tags are used: C:THEN, C:ELSE and C:TEST. The C:TEST tag can be used as an alternative to the test attribute. The other two should be self-explanatory. Note that none of the child-tags or attributes of an unchosen branch are processed.

Bindings

(clip:process-to-string
 "<c:using value=\"num\">
  <c:let orig=\"*\" double=\"(* * 2)\" square=\"(expt * 2)\" root=\"(sqrt *)\">
    <span lquery=\"(text (list orig double square root))\" />
  </c:let>
</c:using>"
 :num 2)

In order to manipulate the clipboard bindings you can use the C:USING and C:LET special tags. C:USING replaces the clipboard environment with what the value of its VALUE attribute resolves to. C:LET on the other hand creates a new CLIPBOARD object, setting the specified symbol/value pairs from its attributes.

Clipboard Stack

(clip:process-to-string
 "<ul iterate=\"articles\">
  <li><article>
    <header><div class=\"author\" lquery=\"(text (** :author))\">AUTHOR</div></header>
    <section class=\"content\" lquery=\"(text *)\">CONTENT</section>
  </article></li>
</ul>"
 :author "Max Mastermind" :articles '("Whoa I am blogging!!" "I don't know what to write, sadface."))

Sometimes you need to refer to values in clipboards outside of the current binding. No worries, this is easy to do as the clipboards are organised using a stack. You can reach clipboards higher up in the stack using the asterisk symbols. Each asterisk more is one clipboard higher. Using the asterisk symbol as a variable returns the clipboard directly, using it as a function call is akin to doing (CLIP ** 'thing). In order to avoid clashing with the * multiplication function, the asterisk function shorthand is only active for two or more asterisks.

Function References

(defun seconds () (decode-universal-time (get-universal-time)))
(clip:process-to-string
 "<time lquery=\"(text (seconds))\">TIME</time>")

Whenever you require to use functions within clip documents, you need to be aware of the current value of *package*. As values that are resolved are first parsed using read, they are influenced by *package*. You can of course use fully qualified symbol names, but often times it is useful to bind the variable to the package you need to reduce verbosity.

You must also be aware of the special resolving for symbols used as function calls within standard resolvings. As mentioned in the previous section, symbols only consisting of asterisks are specially handled. Additionally, the symbols cl:quote, cl:function, cl:or, cl:and, cl:if, cl:when, and cl:unless are handled to work like their usual macro/special equivalents. Any other symbol is treated as follows: If a function's symbol with the same symbol-name is externalised from the clip package, the clip function is used. If not, the function named by the symbol in the symbol's package is used. This is done so that, no matter your package, you will always have access to functions like clip and clipboard. As an unfortunate side-effect of a symbol not knowing whether it was fully qualified or not, this means that even if you use the full symbol name with package in your template, as long as the name is external in clip, the clip function is used instead. You will have to use a combination of funcall and #' to circumvent this limitation..

Further Reading


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 clip

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://github.com/Shinmera/clip

License

Artistic

Description

An HTML templating engine using Plump.

Version

0.6.0

Dependencies
Source

clip.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 clip.asd

Location

clip.asd

Systems

clip (system)


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

3.1.2 clip/package.lisp

Parent

clip (system)

Location

package.lisp

Packages

clip


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

3.1.3 clip/toolkit.lisp

Dependency

package.lisp (file)

Parent

clip (system)

Location

toolkit.lisp

Internal Definitions

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

3.1.4 clip/conditions.lisp

Dependency

toolkit.lisp (file)

Parent

clip (system)

Location

conditions.lisp

Exported Definitions

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

3.1.5 clip/clipboard.lisp

Dependency

conditions.lisp (file)

Parent

clip (system)

Location

clipboard.lisp

Exported Definitions
Internal Definitions

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

3.1.6 clip/attr-processors.lisp

Dependency

clipboard.lisp (file)

Parent

clip (system)

Location

attr-processors.lisp

Exported Definitions
Internal Definitions

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

3.1.7 clip/tag-processors.lisp

Dependency

attr-processors.lisp (file)

Parent

clip (system)

Location

tag-processors.lisp

Exported Definitions
Internal Definitions

splice-into (function)


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

3.1.8 clip/processor.lisp

Dependency

tag-processors.lisp (file)

Parent

clip (system)

Location

processor.lisp

Exported Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 clip

Source

package.lisp (file)

Nickname

org.tymoonnext.clip

Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Special variables

Special Variable: *attribute-processors*

Global registry of attribute processors.

This has to be an EQUALP hash-table with the attribute name as keys and functions that accept two arguments (node attribute-value) as values. Binding this variable can be useful to establish local attributes.

Package

clip

Source

attr-processors.lisp (file)

Special Variable: *clipboard-stack*

Template storage stack. When new clipboards are bound, they are pushed onto the stack. Once the binding is left, they are popped off the stack again.

Package

clip

Source

clipboard.lisp (file)

Special Variable: *tag-processors*

Global registry of tag processors.

This has to be an EQUALP hash-table with the tag name as keys and functions that accept one argument (the node) as values. Binding this variable can be useful to establish local tags.

Package

clip

Source

tag-processors.lisp (file)

Special Variable: *target*

This variable is bound to whatever node is currently being processed.

Package

clip

Source

attr-processors.lisp (file)


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

5.1.2 Macros

Macro: define-attribute-processor ATTRIBUTE (NODE VALUE) &body BODY

Defines a new attribute processor.

ATTRIBTUE — A symbol or string that matches the attribute to process (case-insensitive) NODE — The current node is bound to this symbol.
VALUE — The value of the attribute is bound to this symbol.
BODY ::= form*

Package

clip

Source

attr-processors.lisp (file)

Macro: define-tag-processor TAG (NODE) &body BODY

Defines a new attribute processor.

TAG — A symbol or string that matches the tag name to process (case-insensitive) NODE — The node to process is bound to this symbol
BODY ::= form*

Package

clip

Source

tag-processors.lisp (file)

Macro: with-clipboard-bound (NEW-CLIPBOARD &rest FIELDS) &body BODY

Executes the body with the new clipboard on the *CLIPBOARD-STACK*.

If fields are provided, they are set on the NEW-CLIPBOARD in plist fashion as per consecutive SETF. This means that side-effects of an early field set affect later fields. The fields are evaluated before the NEW-CLIPBOARD is pushed onto the *CLIPBOARD-STACK*.

Package

clip

Source

clipboard.lisp (file)


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

5.1.3 Functions

Function: attribute-processor ATTRIBUTE

Returns the processor function for the requested attribute if one is registered. Otherwise returns NIL. See *ATTRIBUTE-PROCESSORS*.

Package

clip

Source

attr-processors.lisp (file)

Writer

(setf attribute-processor) (function)

Function: (setf attribute-processor) FUNC ATTRIBUTE

Sets the attribute-processor bound to the given attribute to the specified function. See *ATTRIBUTE-PROCESSORS*.

Package

clip

Source

attr-processors.lisp (file)

Reader

attribute-processor (function)

Function: check-attribute NODE ATTRIBUTE

Checks whether the given attribute is present on the node.

If it is, the attribute’s value is returned.
Otherwise, an error of type MISSING-ATTRIBUTE is signalled.

See MISSING-ATTRIBUTE

Package

clip

Source

conditions.lisp (file)

Function: check-no-unknown-attributes NODE &rest KNOWN-ATTRIBUTES

Checks whether there are any unknown attributes present on the node.

If an unknown attribute is present, a warning of type UNKNOWN-ATTRIBUTE is signalled. Otherwise, NIL is returned.

See UNKNOWN-ATTRIBUTE

Package

clip

Source

conditions.lisp (file)

Function: check-sole-attribute NODE ATTRIBUTE

Checks whether the given attribute is the only attribute on the node.

If it is not present, or not the only one, an error is signalled. Otherwise, the attribute’s value is returned.

See CHECK-NO-UNKNOWN-ATTRIBUTES
See CHECK-ATTRIBUTE

Package

clip

Source

conditions.lisp (file)

Function: clipboard FIELD

Shorthand for (CLIP (FIRST *CLIPBOARD-STACK*) FIELD)

Package

clip

Source

clipboard.lisp (file)

Writer

(setf clipboard) (function)

Function: (setf clipboard) VALUE FIELD

Shorthand for (SETF (CLIP (FIRST *CLIPBOARD-STACK*) FIELD) VALUE)

Package

clip

Source

clipboard.lisp (file)

Reader

clipboard (function)

Function: make-clipboard &rest FIELDS

Creates a new clipboard using the specified fields (like a plist).

Package

clip

Source

clipboard.lisp (file)

Function: parse-and-resolve VALUE

If the passed value is a STRING it is parsed using READ-FROM-STRING and subsequently passed to RESOLVE-VALUE. If it is not a string, the value itself is returned.

Package

clip

Source

clipboard.lisp (file)

Function: process TARGET &rest FIELDS

Processes all clip markup on the target with the given FIELDS used to initialise the clipboard.

Package

clip

Source

processor.lisp (file)

Function: process-attribute NODE ATTRIBUTE VALUE

Processes the specified attribute using the given value. If no attribute processor can be found, nothing is done. See *ATTRIBUTE-PROCESSORS*.

Package

clip

Source

attr-processors.lisp (file)

Function: process-attributes NODE

Processes all attributes on the node. See PROCESS-ATTRIBUTE.

Package

clip

Source

attr-processors.lisp (file)

Function: process-children NODE

Calls PROCESS-NODE on all childrens of the passed node.

This takes some care to make sure that splicing into the childrens array of the node is possible. However, note that inserting children before the node that is currently being processed will most likely lead to horrors. If such functionality is indeed ever needed (I hope not), this system needs to be rewritten to somehow be able to cope with such scenarios.

Package

clip

Source

tag-processors.lisp (file)

Function: process-node NODE

Processes the passed node.

Depending on type the following is done:
PLUMP:ELEMENT PROCESS-TAG is called.
PLUMP:NESTING-NODE PROCESS-CHILDREN is called.
PLUMP:NODE Nothing is done.
T An error is signalled.
Any call to this also increases the *TARGET-COUNTER* regardless of what is done.

Package

clip

Source

tag-processors.lisp (file)

Function: process-tag TAG NODE

Processes the specified node as the given tag.
If no tag processor can be found, PROCESS-ATTRIBUTES and PROCESS-CHILDREN is called. See *TAG-PROCESSORS*.

Package

clip

Source

tag-processors.lisp (file)

Function: process-to-string TARGET &rest FIELDS

Same as PROCESS, but automatically performs PLUMP:SERIALIZE on the result to a string.

Package

clip

Source

processor.lisp (file)

Function: resolve-attribute NODE ATTR

Shorthand to resolve the value of an attibute. See RESOLVE-VALUE.

Package

clip

Source

clipboard.lisp (file)

Function: tag-processor TAG

Returns the processor function for the requested tag if one is registered. Otherwise returns NIL. See *TAG-PROCESSORS*.

Package

clip

Source

tag-processors.lisp (file)

Writer

(setf tag-processor) (function)

Function: (setf tag-processor) FUNC TAG

Sets the tag-processor bound to the given tag-name to the specified function. See *TAG-PROCESSORS*.

Package

clip

Source

tag-processors.lisp (file)

Reader

tag-processor (function)


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

5.1.4 Generic functions

Generic Function: clip OBJECT FIELD

Generic object accessor.
If you want to get special treatment of objects or types, define your own methods on this.

Package

clip

Source

clipboard.lisp (file)

Writer

(setf clip) (generic function)

Methods
Method: clip (MODEL standard-object) FIELD

Generic slot accessor.

Method: clip (MODEL list) FIELD

Generic alist or plist accessor.

Method: clip (TABLE hash-table) FIELD

Generic hash-table accessor.

Method: clip (BOARD clipboard) FIELD

Accessor for the clipboard object.

Generic Function: (setf clip) VALUE OBJECT FIELD

Generic object setter.
If you want to get special treatment of objects or types, define your own methods on this.

Package

clip

Source

clipboard.lisp (file)

Reader

clip (generic function)

Methods
Method: (setf clip) VALUE (MODEL standard-object) FIELD
Method: (setf clip) VALUE (MODEL list) FIELD
Method: (setf clip) VALUE (TABLE hash-table) FIELD
Method: (setf clip) VALUE (BOARD clipboard) FIELD
Generic Function: resolve-value OBJECT

Attempts to resolve the object to a specific value.
This is usually used in combination with READ-FROM-STRING of an attribute value.

Package

clip

Source

clipboard.lisp (file)

Methods
Method: resolve-value (LIST list)

Handler for lists, aka function calls.

The function call is decided upon the CAR of the list. The following cases are handled:

QUOTE Returns the first argument
FUNCTION Returns the symbol-function of the first argument OR Simulated version of the OR macro.
AND Simulated version of the AND macro.

Otherwise the symbol is looked for in the :CLIP package and then the current *PACKAGE*. If found, the function is applied with all arguments of the list (which are first all individually passed to RESOLVE-VALUE too).

Method: resolve-value (SYMBOL symbol)

Handler for symbols.
If the symbol is EQL to ’* the *CLIPBOARD* is returned, If the symbol is a keyword the symbol itself is returned, otherwise the value of (CLIPBOARD SYMBOL) is returned.

Method: resolve-value OBJECT

Default fallback for unrecognized objects; simply returns it.


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

5.1.5 Conditions

Condition: attribute-condition ()

Superclass for all conditions related to problems with a node’s attribute.

See NODE-CONDITION

Package

clip

Source

conditions.lisp (file)

Direct superclasses

node-condition (condition)

Direct subclasses
Direct slots
Slot: attribute
Initargs

:attribute

Condition: clip-condition ()

Superclass for all conditions related to Clip.

Package

clip

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses

node-condition (condition)

Condition: missing-attribute ()

Condition signalled when a required attribute is missing.

See ATTRIBUTE-CONDITION

Package

clip

Source

conditions.lisp (file)

Direct superclasses
Condition: node-condition ()

Superclass for all conditions related to problems with a node.

See CLIP-CONDITION

Package

clip

Source

conditions.lisp (file)

Direct superclasses

clip-condition (condition)

Direct subclasses

attribute-condition (condition)

Direct slots
Slot: node
Initargs

:node

Condition: unknown-attribute ()

Condition signalled when an unknown attribute is present.

See ATTRIBUTE-CONDITION

Package

clip

Source

conditions.lisp (file)

Direct superclasses

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

5.1.6 Classes

Class: clipboard ()

Special class for clipboard environments. Use CLIPBOARD or CLIP to access and set values within. Field names are automatically transformed into strings as per STRING. Access is case-insensitive.

Package

clip

Source

clipboard.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: %clipboard-env
Initargs

:env

Initform

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

Readers

clipboard-env (generic function)

Writers

(setf clipboard-env) (generic function)


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *target-counter*

This counter is upped whenever process-node is called.

Package

clip

Source

attr-processors.lisp (file)


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

5.2.2 Functions

Function: concat LIST

Returns a space concatenated string of the passed list.

Package

clip

Source

toolkit.lisp (file)

Function: make-keyword NAME

Returns a keyword of the passed name.

Package

clip

Source

toolkit.lisp (file)

Function: replace-region STRING START END REPLACER
Package

clip

Source

attr-processors.lisp (file)

Function: splice-into NODE POS NEW-CHILDREN
Package

clip

Source

tag-processors.lisp (file)


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

5.2.3 Generic functions

Generic Function: clipboard-env OBJECT
Generic Function: (setf clipboard-env) NEW-VALUE OBJECT
Package

clip

Methods
Method: clipboard-env (CLIPBOARD clipboard)

automatically generated reader method

Source

clipboard.lisp (file)

Method: (setf clipboard-env) NEW-VALUE (CLIPBOARD clipboard)

automatically generated writer method

Source

clipboard.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
clip.asd: The clip<dot>asd file
clip/attr-processors.lisp: The clip/attr-processors<dot>lisp file
clip/clipboard.lisp: The clip/clipboard<dot>lisp file
clip/conditions.lisp: The clip/conditions<dot>lisp file
clip/package.lisp: The clip/package<dot>lisp file
clip/processor.lisp: The clip/processor<dot>lisp file
clip/tag-processors.lisp: The clip/tag-processors<dot>lisp file
clip/toolkit.lisp: The clip/toolkit<dot>lisp file

F
File, Lisp, clip.asd: The clip<dot>asd file
File, Lisp, clip/attr-processors.lisp: The clip/attr-processors<dot>lisp file
File, Lisp, clip/clipboard.lisp: The clip/clipboard<dot>lisp file
File, Lisp, clip/conditions.lisp: The clip/conditions<dot>lisp file
File, Lisp, clip/package.lisp: The clip/package<dot>lisp file
File, Lisp, clip/processor.lisp: The clip/processor<dot>lisp file
File, Lisp, clip/tag-processors.lisp: The clip/tag-processors<dot>lisp file
File, Lisp, clip/toolkit.lisp: The clip/toolkit<dot>lisp file

L
Lisp File, clip.asd: The clip<dot>asd file
Lisp File, clip/attr-processors.lisp: The clip/attr-processors<dot>lisp file
Lisp File, clip/clipboard.lisp: The clip/clipboard<dot>lisp file
Lisp File, clip/conditions.lisp: The clip/conditions<dot>lisp file
Lisp File, clip/package.lisp: The clip/package<dot>lisp file
Lisp File, clip/processor.lisp: The clip/processor<dot>lisp file
Lisp File, clip/tag-processors.lisp: The clip/tag-processors<dot>lisp file
Lisp File, clip/toolkit.lisp: The clip/toolkit<dot>lisp file

Jump to:   C   F   L  

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

A.2 Functions

Jump to:   (  
A   C   D   F   G   M   P   R   S   T   W  
Index Entry  Section

(
(setf attribute-processor): Exported functions
(setf clip): Exported generic functions
(setf clip): Exported generic functions
(setf clip): Exported generic functions
(setf clip): Exported generic functions
(setf clip): Exported generic functions
(setf clipboard): Exported functions
(setf clipboard-env): Internal generic functions
(setf clipboard-env): Internal generic functions
(setf tag-processor): Exported functions

A
attribute-processor: Exported functions

C
check-attribute: Exported functions
check-no-unknown-attributes: Exported functions
check-sole-attribute: Exported functions
clip: Exported generic functions
clip: Exported generic functions
clip: Exported generic functions
clip: Exported generic functions
clip: Exported generic functions
clipboard: Exported functions
clipboard-env: Internal generic functions
clipboard-env: Internal generic functions
concat: Internal functions

D
define-attribute-processor: Exported macros
define-tag-processor: Exported macros

F
Function, (setf attribute-processor): Exported functions
Function, (setf clipboard): Exported functions
Function, (setf tag-processor): Exported functions
Function, attribute-processor: Exported functions
Function, check-attribute: Exported functions
Function, check-no-unknown-attributes: Exported functions
Function, check-sole-attribute: Exported functions
Function, clipboard: Exported functions
Function, concat: Internal functions
Function, make-clipboard: Exported functions
Function, make-keyword: Internal functions
Function, parse-and-resolve: Exported functions
Function, process: Exported functions
Function, process-attribute: Exported functions
Function, process-attributes: Exported functions
Function, process-children: Exported functions
Function, process-node: Exported functions
Function, process-tag: Exported functions
Function, process-to-string: Exported functions
Function, replace-region: Internal functions
Function, resolve-attribute: Exported functions
Function, splice-into: Internal functions
Function, tag-processor: Exported functions

G
Generic Function, (setf clip): Exported generic functions
Generic Function, (setf clipboard-env): Internal generic functions
Generic Function, clip: Exported generic functions
Generic Function, clipboard-env: Internal generic functions
Generic Function, resolve-value: Exported generic functions

M
Macro, define-attribute-processor: Exported macros
Macro, define-tag-processor: Exported macros
Macro, with-clipboard-bound: Exported macros
make-clipboard: Exported functions
make-keyword: Internal functions
Method, (setf clip): Exported generic functions
Method, (setf clip): Exported generic functions
Method, (setf clip): Exported generic functions
Method, (setf clip): Exported generic functions
Method, (setf clipboard-env): Internal generic functions
Method, clip: Exported generic functions
Method, clip: Exported generic functions
Method, clip: Exported generic functions
Method, clip: Exported generic functions
Method, clipboard-env: Internal generic functions
Method, resolve-value: Exported generic functions
Method, resolve-value: Exported generic functions
Method, resolve-value: Exported generic functions

P
parse-and-resolve: Exported functions
process: Exported functions
process-attribute: Exported functions
process-attributes: Exported functions
process-children: Exported functions
process-node: Exported functions
process-tag: Exported functions
process-to-string: Exported functions

R
replace-region: Internal functions
resolve-attribute: Exported functions
resolve-value: Exported generic functions
resolve-value: Exported generic functions
resolve-value: Exported generic functions
resolve-value: Exported generic functions

S
splice-into: Internal functions

T
tag-processor: Exported functions

W
with-clipboard-bound: Exported macros

Jump to:   (  
A   C   D   F   G   M   P   R   S   T   W  

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

A.3 Variables

Jump to:   %   *  
A   N   S  
Index Entry  Section

%
%clipboard-env: Exported classes

*
*attribute-processors*: Exported special variables
*clipboard-stack*: Exported special variables
*tag-processors*: Exported special variables
*target*: Exported special variables
*target-counter*: Internal special variables

A
attribute: Exported conditions

N
node: Exported conditions

S
Slot, %clipboard-env: Exported classes
Slot, attribute: Exported conditions
Slot, node: Exported conditions
Special Variable, *attribute-processors*: Exported special variables
Special Variable, *clipboard-stack*: Exported special variables
Special Variable, *tag-processors*: Exported special variables
Special Variable, *target*: Exported special variables
Special Variable, *target-counter*: Internal special variables

Jump to:   %   *  
A   N   S  

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

A.4 Data types

Jump to:   A   C   M   N   P   S   U  
Index Entry  Section

A
attribute-condition: Exported conditions

C
Class, clipboard: Exported classes
clip: The clip system
clip: The clip package
clip-condition: Exported conditions
clipboard: Exported classes
Condition, attribute-condition: Exported conditions
Condition, clip-condition: Exported conditions
Condition, missing-attribute: Exported conditions
Condition, node-condition: Exported conditions
Condition, unknown-attribute: Exported conditions

M
missing-attribute: Exported conditions

N
node-condition: Exported conditions

P
Package, clip: The clip package

S
System, clip: The clip system

U
unknown-attribute: Exported conditions

Jump to:   A   C   M   N   P   S   U