-
-
Notifications
You must be signed in to change notification settings - Fork 21
/
about.html
400 lines (351 loc) · 159 KB
/
about.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
<!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta charset="utf-8"> <title>Plump</title> <meta name="viewport" content="width=device-width"> <meta name="description" content="An XML / XHTML / HTML parser that aims to be as lenient as possible."> <meta name="author" content="Nicolas Hafner <shinmera@tymoon.eu>"> <style type="text/css"> body{
max-width: 1024px;
margin: 0 auto 0 auto;
font-family: sans-serif;
color: #333333;
font-size: 14pt;
padding: 5px;
}
body>header{
display:flex;
align-items: center;
justify-content: center;
flex-direction: column;
max-width: 100%;
text-align: center;
}
body>header img{
max-width: 50%;
}
img{
max-width: 100%;
max-height: 100%;
}
code{
font-family: Consolas, Inconsolata, monospace;
}
a{
text-decoration: none;
color: #0055AA;
}
a img{
border: none;
}
#documentation{
text-align: justify;
}
#documentation pre{
margin-left: 20px;
overflow: auto;
}
#documentation img{
margin: 5px;
}
#symbol-index>ul{
list-style: none;
padding: 0;
}
#symbol-index .package>ul{
list-style: none;
padding: 0 0 0 10px;
}
#symbol-index .package .nicknames{
font-weight: normal;
}
#symbol-index .package h4{
display: inline-block;
margin: 0;
}
#symbol-index .package article{
margin: 0 0 15px 0;
}
#symbol-index .package article header{
font-size: 1.2em;
font-weight: normal;
}
#symbol-index .package .name{
margin-right: 5px;
}
#symbol-index .package .docstring{
margin: 0 0 0 15px;
white-space: pre-wrap;
font-size: 12pt;
}
@media (max-width: 800px){
body{font-size: 12pt;}
} </style> </head> <body> <header> <h1><img alt="plump" src="plump-logo.png"></h1> <span class="version">2.0.0</span> <p class="description">An XML / XHTML / HTML parser that aims to be as lenient as possible.</p> </header> <main> <article id="documentation"> <div><h2 id="what_is_plump?">What is Plump?</h2> <p>Plump is a parser for HTML/XML like documents, focusing on being lenient towards invalid markup. It can handle things like invalid attributes, bad closing tag order, unencoded entities, inexistent tag types, self-closing tags and so on. It parses documents to a class representation and offers a small set of DOM functions to manipulate it. You are free to change it to parse to your own classes though.</p> <h2 id="how_to">How To</h2> <p>Load Plump through Quicklisp or ASDF:</p> <pre><code>(ql:quickload :plump)
</code></pre> <p>Using the <code><a href="#PLUMP-PARSER:PARSE">PARSE</a></code> function, plump will transform a string, pathname or stream into a document:</p> <pre><code>(<a href="#PLUMP:PARSE">plump:parse</a> "<foo><bar this is=\"a thing\">baz</bar><span id=\"test\">oh my")
</code></pre> <p>This returns a root node. If you want to append a document to a root node (or any other node that accepts children) that you've made, you can pass it into the parse function. To return the document into a readable form, you can call <code><a href="#PLUMP-DOM:SERIALIZE">SERIALIZE</a></code>:</p> <pre><code>(<a href="#PLUMP:SERIALIZE">plump:serialize</a> *)
</code></pre> <p>Using the DOM you can easily traverse the document and change it:</p> <pre><code>(<a href="#PLUMP:REMOVE-CHILD">plump:remove-child</a> (<a href="#PLUMP:GET-ELEMENT-BY-ID">plump:get-element-by-id</a> ** "test"))
(<a href="#PLUMP:SERIALIZE">plump:serialize</a> ***)
</code></pre> <p>By default plump includes a few special tag dispatchers to catch HTML oddities like self-closing tags and fulltext-nodes. Especially the self-closing tags can lead to problems in XML documents. In order to parse without any HTML "tricks", you can simply do:</p> <pre><code>(<a href="http://l1sp.org/cl/let">let</a> (<a href="#PLUMP-PARSER:*TAG-DISPATCHERS*">(plump:*tag-dispatchers*</a> plump:*xml-tags*)) (<a href="#PLUMP:PARSE">plump:parse</a> "<link>foo</link>"))
</code></pre> <p>This will also influence the serialization. By default self-closing tags will be printed in "HTML-fashion," but if you require full XML support, the above should be the way to go. This behaviour is new in Plump2, as previously everything was always serialized in XML mode.</p> <h2 id="extending_plump">Extending Plump</h2> <p>If you want to handle a certain tag in a special way, you can write your own tag-dispatcher. For example comments, the doctype and self-closing tags are handled in this fashion. In order to properly hook in, you will have to learn to use Plump's lexer (see next section).</p> <pre><code>(<a href="#PLUMP:DEFINE-TAG-DISPATCHER">plump:define-tag-dispatcher</a> (my-dispatcher *tag-dispatchers*) (name)
(<a href="http://l1sp.org/cl/string-equal">string-equal</a> name "my-tag"))
(<a href="#PLUMP:DEFINE-TAG-PARSER">plump:define-tag-parser</a> my-dispatcher (name)
(<a href="http://l1sp.org/cl/let">let</a> ((attrs (<a href="#PLUMP:READ-ATTRIBUTES">plump:read-attributes</a>)))
(<a href="http://l1sp.org/cl/when">when</a> (<a href="http://l1sp.org/cl/char=">char=</a> (<a href="#PLUMP:CONSUME">plump:consume</a>) #\/)
(<a href="#PLUMP:CONSUME">plump:consume</a>)) ;; Consume closing
(<a href="http://l1sp.org/cl/make-instance">make-instance</a> 'my-tag :parent plump:*root* :attributes attrs)))
</code></pre> <p>If you don't want to disturb the standard Plump tag dispatchers list, you can define your own special variable to contain the dispatchers and bind <code><a href="#PLUMP-PARSER:*TAG-DISPATCHERS*">*tag-dispatchers*</a></code> to that during parsing, as shown for the XML example above. Shorthand macros exist to define self-closing or full-text tags:</p> <pre><code>(<a href="#PLUMP:DEFINE-SELF-CLOSING-ELEMENT">plump:define-self-closing-element</a> img *tag-dispatchers* *html-tags*)
(<a href="#PLUMP:DEFINE-FULLTEXT-ELEMENT">plump:define-fulltext-element</a> style *tag-dispatchers* *html-tags*)
</code></pre> <p>XML allows for script tags (like <code><?php ?></code>). By default Plump does not specify any special reading for any script tag. If an unhandled script tag is encountered, a warning is emitted and Plump will try to just read anything until <code>?></code> is encountered. For most script tags this probably will not suffice, as they might contain some form of escaped <code>?></code>. If you do want to use Plump to process script tags properly as well, you will have to define your own reader with <code><a href="#PLUMP-PARSER:DEFINE-PROCESSING-PARSER">define-processing-parser</a></code>. You can also use that macro to define a reader that outputs a more suitable format than a text tag.</p> <p>During parsing, all elements are created through <code>MAKE-*</code> functions like <code><a href="#PLUMP-DOM:MAKE-ROOT">MAKE-ROOT</a></code>, <code><a href="#PLUMP-DOM:MAKE-ELEMENT">MAKE-ELEMENT</a></code>, <code><a href="#PLUMP-DOM:MAKE-TEXT-NODE">MAKE-TEXT-NODE</a></code>, and so on. By overriding these functions you can instead delegate the parsing to your own DOM.</p> <p>If you subclass the DOM classes, you might want to define a method on <code><a href="#PLUMP-DOM:SERIALIZE-OBJECT">SERIALIZE-OBJECT</a></code> to produce the right output.</p> <h2 id="plump's_lexer">Plump's Lexer</h2> <p>Since parser generators are good for strict grammars and Plump needed to be fast and lenient, it comes with its own primitive reading/lexing mechanisms. All the lexer primitives are defined in <code>lexer.lisp</code> and you can leverage them for your own projects as well, if you so desire.</p> <p>In order to allow the lexing to work, you'll have to wrap your processing code in <code><a href="#PLUMP-LEXER:WITH-LEXER-ENVIRONMENT">with-lexer-environment</a></code>. You can then use functions like <code><a href="#PLUMP-LEXER:CONSUME">consume</a></code>, <code><a href="#PLUMP-LEXER:ADVANCE">advance</a></code>, <code><a href="#PLUMP-LEXER:UNREAD">unread</a></code>, <code><a href="#PLUMP-LEXER:PEEK">peek</a></code> and <code><a href="#PLUMP-LEXER:CONSUME-UNTIL">consume-until</a></code> to process the input.</p> <p><code><a href="#PLUMP-LEXER:MAKE-MATCHER">make-matcher</a></code> allows you to use a very simple language to define matching operations. This will evaluate to a function with no arguments that should return <code>T</code> if it matches and <code>NIL</code> otherwise. Combining matchers with <code><a href="#PLUMP-LEXER:CONSUME-UNTIL">consume-until</a></code> allows you to easily make sequence readers:</p> <pre><code>(<a href="#PLUMP:WITH-LEXER-ENVIRONMENT">plump:with-lexer-environment</a> ("<foo>")
(<a href="http://l1sp.org/cl/when">when</a> (<a href="http://l1sp.org/cl/char=">char=</a> #\< (<a href="#PLUMP:CONSUME">plump:consume</a>))
(<a href="#PLUMP:CONSUME-UNTIL">plump:consume-until</a> (<a href="#PLUMP:MAKE-MATCHER">plump:make-matcher</a> (is #\>)))))
</code></pre> <p>Available matcher constructs are <code><a href="http://l1sp.org/cl/not">not</a></code>, <code><a href="http://l1sp.org/cl/and">and</a></code>, <code><a href="http://l1sp.org/cl/or">or</a></code>, <code>is</code>, <code>in</code>, <code>next</code>, <code>prev</code>, <code>any</code>, and <code><a href="http://l1sp.org/cl/find">find</a></code>. <code><a href="#PLUMP-LEXER:DEFINE-MATCHER">define-matcher</a></code> allows you to associate keywords to matchers, which you can then use as a matcher rule in <code><a href="#PLUMP-LEXER:MAKE-MATCHER">make-matcher</a></code>. Regular symbols act as variables:</p> <pre><code>(<a href="http://l1sp.org/cl/let">let</a> ((find "baz"))
(<a href="#PLUMP:WITH-LEXER-ENVIRONMENT">plump:with-lexer-environment</a> ("foo bar baz")
(<a href="#PLUMP:CONSUME-UNTIL">plump:consume-until</a> (<a href="#PLUMP:MAKE-MATCHER">plump:make-matcher</a> (is find)))))
</code></pre> <h2 id="speed">Speed</h2> <p><img src="http://shinmera.tymoon.eu/public/plump-benchmark.png" alt="benchmark"></p> <p>If you know of other native-lisp libraries that beat Plump, please do let me know, I would be very interested!</p> <h2 id="see_also">See Also</h2> <ul> <li><a href="https://shinmera.github.io/lquery/">lQuery</a> Dissect and manipulate the DOM with jQuery-like commands.</li> <li><a href="https://shinmera.github.io/CLSS/">CLSS</a> Traverse the DOM by CSS selectors.</li> <li><a href="https://github.com/Shinmera/plump-tex">plump-tex</a> Serialize between TeX and the Plump DOM.</li> <li><a href="https://github.com/Shinmera/plump-sexp">plump-sexp</a> Serialize between SEXPrs and the Plump DOM.</li> </ul> </div> </article> <article id="copyright"> <h2>Copyright</h2> <span>plump</span> is licensed under the <span><a href="https://tldrlegal.com/search?q=Artistic">Artistic</a></span> license. © <span>Nicolas Hafner <shinmera@tymoon.eu></span> . This library can be obtained on <a href="https://github.com/Shinmera/plump">https://github.com/Shinmera/plump</a>. </article> <article id="symbol-index"> <h2>Package Index</h2> <ul><li class="package"> <h3> <a name="PLUMP-LEXER" href="#PLUMP-LEXER">PLUMP-LEXER</a> <span class="nicknames">(ORG.SHIRAKUMO.PLUMP.LEXER)</span> </h3> <ul><li> <a name="PLUMP-LEXER:*INDEX*"> </a> <article id="SPECIAL PLUMP-LEXER:*INDEX*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP-LEXER%3A%2AINDEX%2A">*INDEX*</a></code></h4> </header> <div class="docstring"><pre>Set to the current reading index.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:*LENGTH*"> </a> <article id="SPECIAL PLUMP-LEXER:*LENGTH*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP-LEXER%3A%2ALENGTH%2A">*LENGTH*</a></code></h4> </header> <div class="docstring"><pre>Set to the length of the string for bounds checking.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:*STRING*"> </a> <article id="SPECIAL PLUMP-LEXER:*STRING*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP-LEXER%3A%2ASTRING%2A">*STRING*</a></code></h4> </header> <div class="docstring"><pre>Contains the current string to lex.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:ADVANCE"> </a> <article id="FUNCTION PLUMP-LEXER:ADVANCE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AADVANCE">ADVANCE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Skips a chracter if possible.
Returns the new index or NIL.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:ADVANCE-N"> </a> <article id="FUNCTION PLUMP-LEXER:ADVANCE-N"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AADVANCE-N">ADVANCE-N</a></code></h4> <code class="qualifiers"></code> <code class="arguments">N</code><code>)</code> </header> <div class="docstring"><pre>Advances by N characters if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:CONSUME"> </a> <article id="FUNCTION PLUMP-LEXER:CONSUME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3ACONSUME">CONSUME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Consumes a single character if possible and returns it.
Otherwise returns NIL.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:CONSUME-UNTIL"> </a> <article id="FUNCTION PLUMP-LEXER:CONSUME-UNTIL"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3ACONSUME-UNTIL">CONSUME-UNTIL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code> </header> <div class="docstring"><pre>Consumes until the provided matcher function returns positively.
Returns the substring that was consumed.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-AND"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-AND"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-AND">MATCHER-AND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST MATCHERS</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that returns if all of the sub-expressions
return successfully. The last match is returned, if all.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-CHARACTER"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-CHARACTER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-CHARACTER">MATCHER-CHARACTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHARACTER</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that attempts to match the given character.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-FIND"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-FIND"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-FIND">MATCHER-FIND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that returns T if the character is found in the given list.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-NEXT"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-NEXT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-NEXT">MATCHER-NEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher environment that peeks ahead one farther.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-NOT"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-NOT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-NOT">MATCHER-NOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that inverts the result of the sub-expression.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-OR"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-OR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-OR">MATCHER-OR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST MATCHERS</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that returns successfully if any of the
sub-expressions return successfully. The first match is returned, if any.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-PREV"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-PREV"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-PREV">MATCHER-PREV</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher environment that peeks behind.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-RANGE"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-RANGE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-RANGE">MATCHER-RANGE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FROM TO</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher that checks a range according to the next character's CHAR-CODE.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-STRING"> </a> <article id="FUNCTION PLUMP-LEXER:MATCHER-STRING"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AMATCHER-STRING">MATCHER-STRING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STRING</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that attempts to match the given string.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:PEEK"> </a> <article id="FUNCTION PLUMP-LEXER:PEEK"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3APEEK">PEEK</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Returns the next character, if any.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:UNREAD"> </a> <article id="FUNCTION PLUMP-LEXER:UNREAD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AUNREAD">UNREAD</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Steps back a single character if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:UNREAD-N"> </a> <article id="FUNCTION PLUMP-LEXER:UNREAD-N"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-LEXER%3AUNREAD-N">UNREAD-N</a></code></h4> <code class="qualifiers"></code> <code class="arguments">N</code><code>)</code> </header> <div class="docstring"><pre>Steps back by N characters if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:DEFINE-MATCHER"> </a> <article id="MACRO PLUMP-LEXER:DEFINE-MATCHER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-LEXER%3ADEFINE-MATCHER">DEFINE-MATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME FORM</code><code>)</code> </header> <div class="docstring"><pre>Associates NAME as a keyword to the matcher form. You can then use the keyword in further matcher rules.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MAKE-MATCHER"> </a> <article id="MACRO PLUMP-LEXER:MAKE-MATCHER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-LEXER%3AMAKE-MATCHER">MAKE-MATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FORM</code><code>)</code> </header> <div class="docstring"><pre>Macro to create a matcher chain.</pre></div> </article> </li><li> <a name="PLUMP-LEXER:MATCHER-ANY"> </a> <article id="MACRO PLUMP-LEXER:MATCHER-ANY"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-LEXER%3AMATCHER-ANY">MATCHER-ANY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST IS</code><code>)</code> </header> <div class="docstring"><pre>Shorthand for (or (is a) (is b)..)</pre></div> </article> </li><li> <a name="PLUMP-LEXER:WITH-LEXER-ENVIRONMENT"> </a> <article id="MACRO PLUMP-LEXER:WITH-LEXER-ENVIRONMENT"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-LEXER%3AWITH-LEXER-ENVIRONMENT">WITH-LEXER-ENVIRONMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(STRING) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Sets up the required lexing environment for the given string.</pre></div> </article> </li></ul> </li><li class="package"> <h3> <a name="PLUMP-DOM" href="#PLUMP-DOM">PLUMP-DOM</a> <span class="nicknames">(ORG.SHIRAKUMO.PLUMP.DOM)</span> </h3> <ul><li> <a name="PLUMP-DOM:*ENTITY-MAP*"> </a> <article id="SPECIAL PLUMP-DOM:*ENTITY-MAP*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP-DOM%3A%2AENTITY-MAP%2A">*ENTITY-MAP*</a></code></h4> </header> <div class="docstring"><pre>String hash-table containing the entity names and mapping them to their respective characters.</pre></div> </article> </li><li> <a name="PLUMP-DOM:*STREAM*"> </a> <article id="SPECIAL PLUMP-DOM:*STREAM*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP-DOM%3A%2ASTREAM%2A">*STREAM*</a></code></h4> </header> <div class="docstring"><pre>The stream to serialize to during SERIALIZE-OBJECT.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CDATA"> </a> <article id="CLASS PLUMP-DOM:CDATA"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ACDATA">CDATA</a></code></h4> </header> <div class="docstring"><pre>XML CDATA section node.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CHILD-NODE"> </a> <article id="CLASS PLUMP-DOM:CHILD-NODE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ACHILD-NODE">CHILD-NODE</a></code></h4> </header> <div class="docstring"><pre>Node class that is a child and thus has a parent.</pre></div> </article> </li><li> <a name="PLUMP-DOM:COMMENT"> </a> <article id="CLASS PLUMP-DOM:COMMENT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ACOMMENT">COMMENT</a></code></h4> </header> <div class="docstring"><pre>Comment node that can only contain a single comment string.</pre></div> </article> </li><li> <a name="PLUMP-DOM:DOCTYPE"> </a> <article id="CLASS PLUMP-DOM:DOCTYPE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ADOCTYPE">DOCTYPE</a></code></h4> </header> <div class="docstring"><pre>Special DOM node for the doctype declaration.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ELEMENT"> </a> <article id="CLASS PLUMP-DOM:ELEMENT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3AELEMENT">ELEMENT</a></code></h4> </header> <div class="docstring"><pre>Standard DOM element/block including attributes, tag-name, parent and children.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FULLTEXT-ELEMENT"> </a> <article id="CLASS PLUMP-DOM:FULLTEXT-ELEMENT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3AFULLTEXT-ELEMENT">FULLTEXT-ELEMENT</a></code></h4> </header> <div class="docstring"><pre>Special DOM element that contains full, un-entitied text like SCRIPT and STYLE.</pre></div> </article> </li><li> <a name="PLUMP-DOM:NESTING-NODE"> </a> <article id="CLASS PLUMP-DOM:NESTING-NODE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ANESTING-NODE">NESTING-NODE</a></code></h4> </header> <div class="docstring"><pre>Node class that can contain child nodes.</pre></div> </article> </li><li> <a name="PLUMP-DOM:NODE"> </a> <article id="CLASS PLUMP-DOM:NODE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ANODE">NODE</a></code></h4> </header> <div class="docstring"><pre>Base DOM node class.</pre></div> </article> </li><li> <a name="PLUMP-DOM:PROCESSING-INSTRUCTION"> </a> <article id="CLASS PLUMP-DOM:PROCESSING-INSTRUCTION"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3APROCESSING-INSTRUCTION">PROCESSING-INSTRUCTION</a></code></h4> </header> <div class="docstring"><pre>XML processing instruction node.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ROOT"> </a> <article id="CLASS PLUMP-DOM:ROOT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3AROOT">ROOT</a></code></h4> </header> <div class="docstring"><pre>Root DOM node, practically equivalent to a "document".</pre></div> </article> </li><li> <a name="PLUMP-DOM:TEXT-NODE"> </a> <article id="CLASS PLUMP-DOM:TEXT-NODE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ATEXT-NODE">TEXT-NODE</a></code></h4> </header> <div class="docstring"><pre>Text node that can only contain a single text string.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TEXTUAL-NODE"> </a> <article id="CLASS PLUMP-DOM:TEXTUAL-NODE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3ATEXTUAL-NODE">TEXTUAL-NODE</a></code></h4> </header> <div class="docstring"><pre>Node class that represents a textual node and thus contains a TEXT field.</pre></div> </article> </li><li> <a name="PLUMP-DOM:XML-HEADER"> </a> <article id="CLASS PLUMP-DOM:XML-HEADER"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-DOM%3AXML-HEADER">XML-HEADER</a></code></h4> </header> <div class="docstring"><pre>XML header element</pre></div> </article> </li><li> <a name="PLUMP-DOM:DISCOURAGED-XML-CHARACTER"> </a> <article id="CONDITION PLUMP-DOM:DISCOURAGED-XML-CHARACTER"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20PLUMP-DOM%3ADISCOURAGED-XML-CHARACTER">DISCOURAGED-XML-CHARACTER</a></code></h4> </header> <div class="docstring"><pre>Warning signalled when a discouraged XML character is encountered during WRITE-ENCODE-CHAR.</pre></div> </article> </li><li> <a name="PLUMP-DOM:INVALID-XML-CHARACTER"> </a> <article id="CONDITION PLUMP-DOM:INVALID-XML-CHARACTER"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20PLUMP-DOM%3AINVALID-XML-CHARACTER">INVALID-XML-CHARACTER</a></code></h4> </header> <div class="docstring"><pre>Error signalled when an invalid XML character is encountered during WRITE-ENCODE-CHAR.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ATTRIBUTE"> </a> <article id="ACCESSOR PLUMP-DOM:ATTRIBUTE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3AATTRIBUTE">ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code> </header> <div class="docstring"><pre>Returns the asked attribute from the element
or NIL. If the attribute could not be found, the
second return value is set to NIL.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ATTRIBUTES"> </a> <article id="ACCESSOR PLUMP-DOM:ATTRIBUTES"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3AATTRIBUTES">ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns an EQUALP hash-table of the element's attributes.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CHILDREN"> </a> <article id="ACCESSOR PLUMP-DOM:CHILDREN"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3ACHILDREN">CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns a vector of child-nodes that are contained within the node.</pre></div> </article> </li><li> <a name="PLUMP-DOM:DOCTYPE"> </a> <article id="ACCESSOR PLUMP-DOM:DOCTYPE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3ADOCTYPE">DOCTYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns the doctype node's actual doctype string.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FAULTY-CHAR"> </a> <article id="ACCESSOR PLUMP-DOM:FAULTY-CHAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3AFAULTY-CHAR">FAULTY-CHAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code> </header> <div class="docstring"><pre>Returns the faulty char that caused the signal.</pre></div> </article> </li><li> <a name="PLUMP-DOM:PARENT"> </a> <article id="ACCESSOR PLUMP-DOM:PARENT"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3APARENT">PARENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns the node's parent that should contain this element as a child.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TAG-NAME"> </a> <article id="ACCESSOR PLUMP-DOM:TAG-NAME"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3ATAG-NAME">TAG-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns the element's tag name.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TEXT"> </a> <article id="ACCESSOR PLUMP-DOM:TEXT"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-DOM%3ATEXT">TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns the node's textual content.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ALLOWED-CHAR-P"> </a> <article id="FUNCTION PLUMP-DOM:ALLOWED-CHAR-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AALLOWED-CHAR-P">ALLOWED-CHAR-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the character is a permitted XML character.</pre></div> </article> </li><li> <a name="PLUMP-DOM:APPEND-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:APPEND-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AAPPEND-CHILD">APPEND-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT CHILD</code><code>)</code> </header> <div class="docstring"><pre>Appends the given child onto the parent's child list.
Returns the child.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CDATA-P"> </a> <article id="FUNCTION PLUMP-DOM:CDATA-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACDATA-P">CDATA-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type CDATA</pre></div> </article> </li><li> <a name="PLUMP-DOM:CHILD-ELEMENTS"> </a> <article id="FUNCTION PLUMP-DOM:CHILD-ELEMENTS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACHILD-ELEMENTS">CHILD-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NESTING-NODE</code><code>)</code> </header> <div class="docstring"><pre>Returns a new vector of children of the given node, filtered to elements.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CHILD-NODE-P"> </a> <article id="FUNCTION PLUMP-DOM:CHILD-NODE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACHILD-NODE-P">CHILD-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type CHILD-NODE</pre></div> </article> </li><li> <a name="PLUMP-DOM:CHILD-POSITION"> </a> <article id="FUNCTION PLUMP-DOM:CHILD-POSITION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACHILD-POSITION">CHILD-POSITION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the index of the child within its parent.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CLEAR"> </a> <article id="FUNCTION PLUMP-DOM:CLEAR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACLEAR">CLEAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NESTING-NODE</code><code>)</code> </header> <div class="docstring"><pre>Clears all children from the node.
Noe that the PARENT of all child elements is set to NIL.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CLONE-ATTRIBUTES"> </a> <article id="FUNCTION PLUMP-DOM:CLONE-ATTRIBUTES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACLONE-ATTRIBUTES">CLONE-ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>Clone the attribute map.
Note that keys and values are NOT copied/cloned.</pre></div> </article> </li><li> <a name="PLUMP-DOM:CLONE-CHILDREN"> </a> <article id="FUNCTION PLUMP-DOM:CLONE-CHILDREN"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACLONE-CHILDREN">CLONE-CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &OPTIONAL DEEP NEW-PARENT</code><code>)</code> </header> <div class="docstring"><pre>Clone the array of children.
If DEEP is non-NIL, each child is cloned as per (CLONE-NODE NODE T).
When copying deeply, you can also pass a NEW-PARENT to set on each child.</pre></div> </article> </li><li> <a name="PLUMP-DOM:COMMENT-P"> </a> <article id="FUNCTION PLUMP-DOM:COMMENT-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ACOMMENT-P">COMMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type COMMENT</pre></div> </article> </li><li> <a name="PLUMP-DOM:DECODE-ENTITIES"> </a> <article id="FUNCTION PLUMP-DOM:DECODE-ENTITIES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ADECODE-ENTITIES">DECODE-ENTITIES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &OPTIONAL REMOVE-INVALID</code><code>)</code> </header> <div class="docstring"><pre>Translates all entities in the text into their character counterparts if possible.
If an entity does not match, it is left in place unless REMOVE-INVALID is non-NIL.</pre></div> </article> </li><li> <a name="PLUMP-DOM:DISCOURAGED-CHAR-P"> </a> <article id="FUNCTION PLUMP-DOM:DISCOURAGED-CHAR-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ADISCOURAGED-CHAR-P">DISCOURAGED-CHAR-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the character is a discouraged XML character.</pre></div> </article> </li><li> <a name="PLUMP-DOM:DOCTYPE-P"> </a> <article id="FUNCTION PLUMP-DOM:DOCTYPE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ADOCTYPE-P">DOCTYPE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type DOCTYPE</pre></div> </article> </li><li> <a name="PLUMP-DOM:ELEMENT-P"> </a> <article id="FUNCTION PLUMP-DOM:ELEMENT-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AELEMENT-P">ELEMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type ELEMENT</pre></div> </article> </li><li> <a name="PLUMP-DOM:ELEMENT-POSITION"> </a> <article id="FUNCTION PLUMP-DOM:ELEMENT-POSITION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AELEMENT-POSITION">ELEMENT-POSITION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the index of the child within its parent, counting only elements.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ENCODE-ENTITIES"> </a> <article id="FUNCTION PLUMP-DOM:ENCODE-ENTITIES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AENCODE-ENTITIES">ENCODE-ENTITIES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &OPTIONAL STREAM</code><code>)</code> </header> <div class="docstring"><pre>Encodes the characters < > & " with their XML entity equivalents.
If no STREAM is given, it encodes to a new string.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ENSURE-ATTRIBUTE-MAP"> </a> <article id="FUNCTION PLUMP-DOM:ENSURE-ATTRIBUTE-MAP"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AENSURE-ATTRIBUTE-MAP">ENSURE-ATTRIBUTE-MAP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TABLE</code><code>)</code> </header> <div class="docstring"><pre>Ensures that the TABLE is suitable as an attribute-map.
If it is not, the table is copied into a proper attribute-map.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ENSURE-CHILD-ARRAY"> </a> <article id="FUNCTION PLUMP-DOM:ENSURE-CHILD-ARRAY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AENSURE-CHILD-ARRAY">ENSURE-CHILD-ARRAY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code> </header> <div class="docstring"><pre>If the ARRAY is suitable as a child-array, it is returned.
Otherwise the array's elements are copied over into a proper
child-array.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FAMILY"> </a> <article id="FUNCTION PLUMP-DOM:FAMILY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AFAMILY">FAMILY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the direct array of children of the parent of the given child.
Note that modifying this array directly modifies that of the parent.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FAMILY-ELEMENTS"> </a> <article id="FUNCTION PLUMP-DOM:FAMILY-ELEMENTS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AFAMILY-ELEMENTS">FAMILY-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the direct array of children elements of the parent of the given child.
Note that this is a copy of the array, modifying it is safe.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FIRST-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:FIRST-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AFIRST-CHILD">FIRST-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code> </header> <div class="docstring"><pre>Returns the first child within the parent or NIL
if the parent is empty.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FIRST-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:FIRST-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AFIRST-ELEMENT">FIRST-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code> </header> <div class="docstring"><pre>Returns the first child element within the parent or NIL
if the parent is empty. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:FULLTEXT-ELEMENT-P"> </a> <article id="FUNCTION PLUMP-DOM:FULLTEXT-ELEMENT-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AFULLTEXT-ELEMENT-P">FULLTEXT-ELEMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type FULLTEXT-ELEMENT</pre></div> </article> </li><li> <a name="PLUMP-DOM:GET-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP-DOM:GET-ATTRIBUTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AGET-ATTRIBUTE">GET-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code> </header> <div class="docstring"><pre>Synonymous to ATTRIBUTE.</pre></div> </article> </li><li> <a name="PLUMP-DOM:GET-ELEMENT-BY-ID"> </a> <article id="FUNCTION PLUMP-DOM:GET-ELEMENT-BY-ID"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AGET-ELEMENT-BY-ID">GET-ELEMENT-BY-ID</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE ID</code><code>)</code> </header> <div class="docstring"><pre>Searches the given node and returns the first
node at arbitrary depth that matches the given ID
attribute.</pre></div> </article> </li><li> <a name="PLUMP-DOM:GET-ELEMENTS-BY-TAG-NAME"> </a> <article id="FUNCTION PLUMP-DOM:GET-ELEMENTS-BY-TAG-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AGET-ELEMENTS-BY-TAG-NAME">GET-ELEMENTS-BY-TAG-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE TAG</code><code>)</code> </header> <div class="docstring"><pre>Searches the given node and returns an unordered
list of child nodes at arbitrary depth that match
the given tag.</pre></div> </article> </li><li> <a name="PLUMP-DOM:HAS-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP-DOM:HAS-ATTRIBUTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AHAS-ATTRIBUTE">HAS-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the provided attribute exists.</pre></div> </article> </li><li> <a name="PLUMP-DOM:HAS-CHILD-NODES"> </a> <article id="FUNCTION PLUMP-DOM:HAS-CHILD-NODES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AHAS-CHILD-NODES">HAS-CHILD-NODES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the node can contain children and
the child array is not empty.</pre></div> </article> </li><li> <a name="PLUMP-DOM:INSERT-AFTER"> </a> <article id="FUNCTION PLUMP-DOM:INSERT-AFTER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AINSERT-AFTER">INSERT-AFTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT NEW-CHILD</code><code>)</code> </header> <div class="docstring"><pre>Inserts the new-child after the given element in the parent's list.
Returns the new child.
Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-PUSH-EXTEND-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP-DOM:INSERT-BEFORE"> </a> <article id="FUNCTION PLUMP-DOM:INSERT-BEFORE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AINSERT-BEFORE">INSERT-BEFORE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT NEW-CHILD</code><code>)</code> </header> <div class="docstring"><pre>Inserts the new-child before the given element in the parent's list.
Returns the new child.
Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-PUSH-EXTEND-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP-DOM:LAST-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:LAST-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ALAST-CHILD">LAST-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code> </header> <div class="docstring"><pre>Returns the last child within the parent or NIL
if the parent is empty.</pre></div> </article> </li><li> <a name="PLUMP-DOM:LAST-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:LAST-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ALAST-ELEMENT">LAST-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code> </header> <div class="docstring"><pre>Returns the last child element within the parent or NIL
if the parent is empty. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-ATTRIBUTE-MAP"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-ATTRIBUTE-MAP"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-ATTRIBUTE-MAP">MAKE-ATTRIBUTE-MAP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&OPTIONAL (SIZE 0)</code><code>)</code> </header> <div class="docstring"><pre>Creates a map to contain attributes.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-CDATA"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-CDATA"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-CDATA">MAKE-CDATA</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &KEY (TEXT "")</code><code>)</code> </header> <div class="docstring"><pre>Creates an XML CDATA section under the parent.
Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-CHILD-ARRAY"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-CHILD-ARRAY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-CHILD-ARRAY">MAKE-CHILD-ARRAY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&OPTIONAL (SIZE 0)</code><code>)</code> </header> <div class="docstring"><pre>Creates an array to contain child elements</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-COMMENT"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-COMMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-COMMENT">MAKE-COMMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &OPTIONAL (TEXT "")</code><code>)</code> </header> <div class="docstring"><pre>Creates a new comment node under the parent.
Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-DOCTYPE"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-DOCTYPE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-DOCTYPE">MAKE-DOCTYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT DOCTYPE</code><code>)</code> </header> <div class="docstring"><pre>Creates a new doctype node under the parent.
Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-ELEMENT">MAKE-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT TAG &KEY (CHILDREN (MAKE-CHILD-ARRAY))
(ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code> </header> <div class="docstring"><pre>Creates a standard DOM element with the given tag name and parent.
Optionally a vector (with fill-pointer) containing children and an
attribute-map (a hash-table with equalp test) can be supplied.
Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-FULLTEXT-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-FULLTEXT-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-FULLTEXT-ELEMENT">MAKE-FULLTEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT TAG &KEY TEXT (ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code> </header> <div class="docstring"><pre>Creates a fulltext element under the parent.
Optionally a text and an attribute-map (a hash-table with equalp test)
can be supplied.
Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-PROCESSING-INSTRUCTION"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-PROCESSING-INSTRUCTION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-PROCESSING-INSTRUCTION">MAKE-PROCESSING-INSTRUCTION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &KEY NAME (TEXT "")</code><code>)</code> </header> <div class="docstring"><pre>Creates an XML processing instruction under the parent.
Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-ROOT"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-ROOT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-ROOT">MAKE-ROOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&OPTIONAL (CHILDREN (MAKE-CHILD-ARRAY))</code><code>)</code> </header> <div class="docstring"><pre>Creates a root node with the given children.
Children should be a vector with fill-pointer.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-TEXT-NODE"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-TEXT-NODE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-TEXT-NODE">MAKE-TEXT-NODE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &OPTIONAL (TEXT "")</code><code>)</code> </header> <div class="docstring"><pre>Creates a new text node under the parent.
Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:MAKE-XML-HEADER"> </a> <article id="FUNCTION PLUMP-DOM:MAKE-XML-HEADER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AMAKE-XML-HEADER">MAKE-XML-HEADER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &KEY (ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code> </header> <div class="docstring"><pre>Creates an XML header object under the parent.
Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP-DOM:NESTING-NODE-P"> </a> <article id="FUNCTION PLUMP-DOM:NESTING-NODE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ANESTING-NODE-P">NESTING-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type NESTING-NODE</pre></div> </article> </li><li> <a name="PLUMP-DOM:NEXT-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:NEXT-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ANEXT-ELEMENT">NEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the sibling element next to this one or NIL if
it is already last. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:NEXT-SIBLING"> </a> <article id="FUNCTION PLUMP-DOM:NEXT-SIBLING"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ANEXT-SIBLING">NEXT-SIBLING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the sibling next to this one or NIL if
it is already the last.</pre></div> </article> </li><li> <a name="PLUMP-DOM:NODE-P"> </a> <article id="FUNCTION PLUMP-DOM:NODE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ANODE-P">NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type NODE</pre></div> </article> </li><li> <a name="PLUMP-DOM:PREPEND-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:PREPEND-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3APREPEND-CHILD">PREPEND-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT CHILD</code><code>)</code> </header> <div class="docstring"><pre>Prepends the given child onto the parent's child list.
Returns the child.
Note that this operation is costly, see VECTOR-PUSH-EXTEND-FRONT</pre></div> </article> </li><li> <a name="PLUMP-DOM:PREVIOUS-ELEMENT"> </a> <article id="FUNCTION PLUMP-DOM:PREVIOUS-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3APREVIOUS-ELEMENT">PREVIOUS-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the sibling element next to this one or NIL if
it is already last. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:PREVIOUS-SIBLING"> </a> <article id="FUNCTION PLUMP-DOM:PREVIOUS-SIBLING"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3APREVIOUS-SIBLING">PREVIOUS-SIBLING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the sibling before this one or NIL if
it is already the first.</pre></div> </article> </li><li> <a name="PLUMP-DOM:PROCESSING-INSTRUCTION-P"> </a> <article id="FUNCTION PLUMP-DOM:PROCESSING-INSTRUCTION-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3APROCESSING-INSTRUCTION-P">PROCESSING-INSTRUCTION-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type PROCESSING-INSTRUCTION</pre></div> </article> </li><li> <a name="PLUMP-DOM:REMOVE-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP-DOM:REMOVE-ATTRIBUTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AREMOVE-ATTRIBUTE">REMOVE-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code> </header> <div class="docstring"><pre>Remove the specified attribute if it exists.
Returns NIL.</pre></div> </article> </li><li> <a name="PLUMP-DOM:REMOVE-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:REMOVE-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AREMOVE-CHILD">REMOVE-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Removes the child from its parent.
Returns the child.
Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-POP-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP-DOM:RENDER-TEXT"> </a> <article id="FUNCTION PLUMP-DOM:RENDER-TEXT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ARENDER-TEXT">RENDER-TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>"Renders" the text of this element and its children.
In effect the text is gathered from the component and all of
its children, but transforming the text in such a way that:
- All ASCII white space (Space, Tab, CR, LF) is converted into spaces.
- There are no consecutive spaces.
- There are no spaces at the beginning or end.
This is somewhat analogous to how the text will be shown to
the user when rendered by a browser. Hence, render-text.</pre></div> </article> </li><li> <a name="PLUMP-DOM:REPLACE-CHILD"> </a> <article id="FUNCTION PLUMP-DOM:REPLACE-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AREPLACE-CHILD">REPLACE-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OLD-CHILD NEW-CHILD</code><code>)</code> </header> <div class="docstring"><pre>Replace the old child with a new one.
Returns the old child.</pre></div> </article> </li><li> <a name="PLUMP-DOM:ROOT-P"> </a> <article id="FUNCTION PLUMP-DOM:ROOT-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AROOT-P">ROOT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type ROOT</pre></div> </article> </li><li> <a name="PLUMP-DOM:SERIALIZE"> </a> <article id="FUNCTION PLUMP-DOM:SERIALIZE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASERIALIZE">SERIALIZE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &OPTIONAL (STREAM T)</code><code>)</code> </header> <div class="docstring"><pre>Serializes NODE to STREAM.
STREAM can be a stream, T for *standard-output* or NIL to serialize to string.</pre></div> </article> </li><li> <a name="PLUMP-DOM:SET-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP-DOM:SET-ATTRIBUTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASET-ATTRIBUTE">SET-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE VALUE</code><code>)</code> </header> <div class="docstring"><pre>Synonymous to (SETF (ATTIBUTE ..) ..)</pre></div> </article> </li><li> <a name="PLUMP-DOM:SIBLING-ELEMENTS"> </a> <article id="FUNCTION PLUMP-DOM:SIBLING-ELEMENTS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASIBLING-ELEMENTS">SIBLING-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the array of sibling elements of the given child.
Note that this is a copy of the array, modifying it is safe.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP-DOM:SIBLINGS"> </a> <article id="FUNCTION PLUMP-DOM:SIBLINGS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASIBLINGS">SIBLINGS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the array of siblings of the given child.
Note that this is a copy of the array, modifying it is safe.</pre></div> </article> </li><li> <a name="PLUMP-DOM:SPLICE"> </a> <article id="FUNCTION PLUMP-DOM:SPLICE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASPLICE">SPLICE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code> </header> <div class="docstring"><pre>Splices the contents of element into the position of the element in its parent.
Returns the parent.
Note that this operation is potentially very costly.
See <a href="NIL">ARRAY-SHIFT</a></pre></div> </article> </li><li> <a name="PLUMP-DOM:STRIP"> </a> <article id="FUNCTION PLUMP-DOM:STRIP"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ASTRIP">STRIP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>Trim all text-nodes within NODE (at any depth) of leading and trailing whitespace.
If their TEXT should be an empty string after trimming, remove them.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TEXT-NODE-P"> </a> <article id="FUNCTION PLUMP-DOM:TEXT-NODE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ATEXT-NODE-P">TEXT-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type TEXT-NODE</pre></div> </article> </li><li> <a name="PLUMP-DOM:TEXTUAL-NODE-P"> </a> <article id="FUNCTION PLUMP-DOM:TEXTUAL-NODE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ATEXTUAL-NODE-P">TEXTUAL-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type TEXTUAL-NODE</pre></div> </article> </li><li> <a name="PLUMP-DOM:TRANSLATE-ENTITY"> </a> <article id="FUNCTION PLUMP-DOM:TRANSLATE-ENTITY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ATRANSLATE-ENTITY">TRANSLATE-ENTITY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &KEY (START 0) (END (LENGTH TEXT))</code><code>)</code> </header> <div class="docstring"><pre>Translates the given entity identifier (a name, #Dec or #xHex) into their respective strings if possible.
Otherwise returns NIL.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TRIM"> </a> <article id="FUNCTION PLUMP-DOM:TRIM"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3ATRIM">TRIM</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>Trim all text-nodes within NODE (at any depth) of leading and trailing whitespace.</pre></div> </article> </li><li> <a name="PLUMP-DOM:WRITE-ENCODE-CHAR"> </a> <article id="FUNCTION PLUMP-DOM:WRITE-ENCODE-CHAR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AWRITE-ENCODE-CHAR">WRITE-ENCODE-CHAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR STREAM</code><code>)</code> </header> <div class="docstring"><pre>Write and possibly encode the CHAR to STREAM.
This also properly handles detection of invalid or discouraged XML characters.
The following restarts are available in the case of a faulty character:
ABORT Do not output the faulty character at all.
USE-NEW-CHARACTER Output a replacement character instead.
CONTINUE Continue and output the faulty character anyway.
See <a href="#PLUMP-DOM:INVALID-XML-CHARACTER">INVALID-XML-CHARACTER</a>
See <a href="#PLUMP-DOM:DISCOURAGED-XML-CHARACTER">DISCOURAGED-XML-CHARACTER</a></pre></div> </article> </li><li> <a name="PLUMP-DOM:XML-HEADER-P"> </a> <article id="FUNCTION PLUMP-DOM:XML-HEADER-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-DOM%3AXML-HEADER-P">XML-HEADER-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type XML-HEADER</pre></div> </article> </li><li> <a name="PLUMP-DOM:CLONE-NODE"> </a> <article id="GENERIC PLUMP-DOM:CLONE-NODE"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP-DOM%3ACLONE-NODE">CLONE-NODE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &OPTIONAL DEEP</code><code>)</code> </header> <div class="docstring"><pre>Clone the given node, creating a new instance with the same contents.
If DEEP is non-NIL, the following applies:
The text of COMMENT and TEXT-NODEs is copied as per COPY-SEQ.
The children of NESTING-NODEs are copied as per (CLONE-CHILDREN CHILD T)</pre></div> </article> </li><li> <a name="PLUMP-DOM:SERIALIZE-OBJECT"> </a> <article id="GENERIC PLUMP-DOM:SERIALIZE-OBJECT"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP-DOM%3ASERIALIZE-OBJECT">SERIALIZE-OBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>Serialize the given node and print it to *stream*.</pre></div> </article> </li><li> <a name="PLUMP-DOM:TRAVERSE"> </a> <article id="GENERIC PLUMP-DOM:TRAVERSE"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP-DOM%3ATRAVERSE">TRAVERSE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE FUNCTION &KEY TEST</code><code>)</code> </header> <div class="docstring"><pre>Traverse the NODE and all its children recursively,
calling FUNCTION on the current node if calling TEST on the current node
returns a non-NIL value. It is safe to modify the child array of the
parent of each node passed to FUNCTION.
NODE is returned.</pre></div> </article> </li></ul> </li><li class="package"> <h3> <a name="PLUMP-PARSER" href="#PLUMP-PARSER">PLUMP-PARSER</a> <span class="nicknames">(ORG.SHIRAKUMO.PLUMP.PARSER)</span> </h3> <ul><li> <a name="PLUMP-PARSER:*ALL-TAG-DISPATCHERS*"> </a> <article id="SPECIAL PLUMP-PARSER:*ALL-TAG-DISPATCHERS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP-PARSER%3A%2AALL-TAG-DISPATCHERS%2A">*ALL-TAG-DISPATCHERS*</a></code></h4> </header> <div class="docstring"><pre>All defined tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP-PARSER:*HTML-TAGS*"> </a> <article id="SPECIAL PLUMP-PARSER:*HTML-TAGS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP-PARSER%3A%2AHTML-TAGS%2A">*HTML-TAGS*</a></code></h4> </header> <div class="docstring"><pre>List of HTML tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP-PARSER:*ROOT*"> </a> <article id="SPECIAL PLUMP-PARSER:*ROOT*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP-PARSER%3A%2AROOT%2A">*ROOT*</a></code></h4> </header> <div class="docstring"><pre>Object containing the current node to set as parent.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:*TAG-DISPATCHERS*"> </a> <article id="SPECIAL PLUMP-PARSER:*TAG-DISPATCHERS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP-PARSER%3A%2ATAG-DISPATCHERS%2A">*TAG-DISPATCHERS*</a></code></h4> </header> <div class="docstring"><pre>Active tag dispatcher functions</pre></div> </article> </li><li> <a name="PLUMP-PARSER:*XML-TAGS*"> </a> <article id="SPECIAL PLUMP-PARSER:*XML-TAGS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP-PARSER%3A%2AXML-TAGS%2A">*XML-TAGS*</a></code></h4> </header> <div class="docstring"><pre>List of XML tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP-PARSER:TAG-DISPATCHER"> </a> <article id="CLASS PLUMP-PARSER:TAG-DISPATCHER"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP-PARSER%3ATAG-DISPATCHER">TAG-DISPATCHER</a></code></h4> </header> <div class="docstring"><pre>Encapsulates the processing for a given tag.
See <a href="NIL">TAG-DISPATCHER-NAME</a>
See <a href="NIL">TAG-DISPATCHER-TEST</a>
See <a href="NIL">TAG-DISPATCHER-PARSER</a>
See <a href="NIL">TAG-DISPATCHER-PRINTER</a></pre></div> </article> </li><li> <a name="PLUMP-PARSER:PROCESSING-PARSER"> </a> <article id="ACCESSOR PLUMP-PARSER:PROCESSING-PARSER"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP-PARSER%3APROCESSING-PARSER">PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME</code><code>)</code> </header> <div class="docstring"><pre>Return the processing-parser function for PROCESS-NAME. SETF-able.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP-PARSER:READ-ATTRIBUTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-ATTRIBUTE">READ-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads an attribute and returns it as a key value cons.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-ATTRIBUTE-NAME"> </a> <article id="FUNCTION PLUMP-PARSER:READ-ATTRIBUTE-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-ATTRIBUTE-NAME">READ-ATTRIBUTE-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads an attribute name.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-ATTRIBUTE-VALUE"> </a> <article id="FUNCTION PLUMP-PARSER:READ-ATTRIBUTE-VALUE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-ATTRIBUTE-VALUE">READ-ATTRIBUTE-VALUE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads an attribute value, either enclosed in quotation marks or until a space or tag end.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-ATTRIBUTES"> </a> <article id="FUNCTION PLUMP-PARSER:READ-ATTRIBUTES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-ATTRIBUTES">READ-ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads as many attributes as possible from a tag and returns them as an attribute map.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-CHILDREN"> </a> <article id="FUNCTION PLUMP-PARSER:READ-CHILDREN"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-CHILDREN">READ-CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Read all children of the current *root* until the closing tag for *root* is encountered.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-NAME"> </a> <article id="FUNCTION PLUMP-PARSER:READ-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-NAME">READ-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads and returns a tag name.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-ROOT"> </a> <article id="FUNCTION PLUMP-PARSER:READ-ROOT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-ROOT">READ-ROOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&OPTIONAL (ROOT (MAKE-ROOT))</code><code>)</code> </header> <div class="docstring"><pre>Creates a root element and reads nodes into it.
Optionally uses the specified root to append child nodes to.
Returns the root.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-STANDARD-TAG"> </a> <article id="FUNCTION PLUMP-PARSER:READ-STANDARD-TAG"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-STANDARD-TAG">READ-STANDARD-TAG</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code> </header> <div class="docstring"><pre>Reads an arbitrary tag and returns it.
This recurses with READ-CHILDREN.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-TAG"> </a> <article id="FUNCTION PLUMP-PARSER:READ-TAG"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-TAG">READ-TAG</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Attempts to read a tag and dispatches or defaults to READ-STANDARD-TAG.
Returns the completed node if one can be read.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-TAG-CONTENTS"> </a> <article id="FUNCTION PLUMP-PARSER:READ-TAG-CONTENTS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-TAG-CONTENTS">READ-TAG-CONTENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads and returns all tag contents.
E.g. <foo bar baz> => bar baz</pre></div> </article> </li><li> <a name="PLUMP-PARSER:READ-TEXT"> </a> <article id="FUNCTION PLUMP-PARSER:READ-TEXT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREAD-TEXT">READ-TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads and returns a text-node.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:REMOVE-PROCESSING-PARSER"> </a> <article id="FUNCTION PLUMP-PARSER:REMOVE-PROCESSING-PARSER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREMOVE-PROCESSING-PARSER">REMOVE-PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME</code><code>)</code> </header> <div class="docstring"><pre>Remove the processing-parser for PROCESS-NAME.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:REMOVE-TAG-DISPATCHER"> </a> <article id="FUNCTION PLUMP-PARSER:REMOVE-TAG-DISPATCHER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3AREMOVE-TAG-DISPATCHER">REMOVE-TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME &OPTIONAL (LIST '*ALL-TAG-DISPATCHERS*)</code><code>)</code> </header> <div class="docstring"><pre>Removes the tag-dispatcher of the given name from the list.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:SLURP-STREAM"> </a> <article id="FUNCTION PLUMP-PARSER:SLURP-STREAM"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3ASLURP-STREAM">SLURP-STREAM</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STREAM</code><code>)</code> </header> <div class="docstring"><pre>Quickly slurps the stream's contents into an array with fill pointer.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:TAG-DISPATCHER"> </a> <article id="FUNCTION PLUMP-PARSER:TAG-DISPATCHER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP-PARSER%3ATAG-DISPATCHER">TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME &OPTIONAL (LIST *ALL-TAG-DISPATCHERS*)</code><code>)</code> </header> <div class="docstring"><pre>Accessor to the tag-dispatcher of the given name.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:PARSE"> </a> <article id="GENERIC PLUMP-PARSER:PARSE"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP-PARSER%3APARSE">PARSE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INPUT &KEY ROOT</code><code>)</code> </header> <div class="docstring"><pre>Parses the given input into a DOM representation.
By default, methods for STRING, PATHNAME and STREAM are defined.
If supplied, the given root is used to append children to as per READ-ROOT.
Returns the root.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-FULLTEXT-ELEMENT"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-FULLTEXT-ELEMENT"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-FULLTEXT-ELEMENT">DEFINE-FULLTEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TAG &REST LISTS</code><code>)</code> </header> <div class="docstring"><pre>Defines an element to be read as a full-text element.
This means that it cannot contain any child-nodes and everything up until its closing
tag is used as its text.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-PROCESSING-PARSER"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-PROCESSING-PARSER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-PROCESSING-PARSER">DEFINE-PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME NIL &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a new processing-instruction parser.
It is invoked if a processing-instruction (<?) with PROCESS-NAME is encountered.
The lexer will be at the point straight after reading in the PROCESS-NAME.
Expected return value is a string to use as the processing-instructions' TEXT.
The closing tag (?>) should NOT be consumed by a processing-parser.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-SELF-CLOSING-ELEMENT"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-SELF-CLOSING-ELEMENT"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-SELF-CLOSING-ELEMENT">DEFINE-SELF-CLOSING-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TAG &REST LISTS</code><code>)</code> </header> <div class="docstring"><pre>Defines an element that does not need to be closed with /> and cannot contain child nodes.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-TAG-DISPATCHER"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-TAG-DISPATCHER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-TAG-DISPATCHER">DEFINE-TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(NAME &REST LISTS) (TAGVAR) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a new tag dispatcher. It is invoked if TEST-FORM passes.
NAME --- Name to discern the dispatcher with.
LISTS --- Symbols of lists to which the dispatcher should be added.
TAGVAR --- Symbol bound to the tag name.
BODY --- Body forms describing the test to match the tag.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-TAG-PARSER"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-TAG-PARSER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-TAG-PARSER">DEFINE-TAG-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (TAGVAR) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines the parser function for a tag dispatcher.
NAME --- The name of the tag dispatcher. If one with this name
cannot be found, an error is signalled.
TAGVAR --- Symbol bound to the tag name.
BODY --- Body forms describing the tag parsing behaviour.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DEFINE-TAG-PRINTER"> </a> <article id="MACRO PLUMP-PARSER:DEFINE-TAG-PRINTER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADEFINE-TAG-PRINTER">DEFINE-TAG-PRINTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (NODEVAR) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines the printer function for a tag dispatcher.
NAME --- The name of the tag dispatcher. If one with this name
cannot be found, an error is signalled.
TAGVAR --- Symbol bound to the tag name.
BODY --- Body forms describing the printing behaviour. Write to
the stream bound to PLUMP-DOM:*STREAM*.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DO-TAG-PARSERS"> </a> <article id="MACRO PLUMP-PARSER:DO-TAG-PARSERS"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADO-TAG-PARSERS">DO-TAG-PARSERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(TEST PARSER &OPTIONAL RESULT-FORM) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Iterates over the current *TAG-DISPATCHERS*, binding the TEST and PARSER functions.
Returns RESULT-FORM's evaluated value.</pre></div> </article> </li><li> <a name="PLUMP-PARSER:DO-TAG-PRINTERS"> </a> <article id="MACRO PLUMP-PARSER:DO-TAG-PRINTERS"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP-PARSER%3ADO-TAG-PRINTERS">DO-TAG-PRINTERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(TEST PRINTER &OPTIONAL RESULT-FORM) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Iterates over the current *TAG-DISPATCHERS*, binding the TEST and PRINTER functions.
Returns RESULT-FORM's evaluated value.</pre></div> </article> </li></ul> </li><li class="package"> <h3> <a name="PLUMP" href="#PLUMP">PLUMP</a> <span class="nicknames">(ORG.SHIRAKUMO.PLUMP)</span> </h3> <ul><li> <a name="PLUMP:*ALL-TAG-DISPATCHERS*"> </a> <article id="SPECIAL PLUMP:*ALL-TAG-DISPATCHERS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AALL-TAG-DISPATCHERS%2A">*ALL-TAG-DISPATCHERS*</a></code></h4> </header> <div class="docstring"><pre>All defined tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP:*ENTITY-MAP*"> </a> <article id="SPECIAL PLUMP:*ENTITY-MAP*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AENTITY-MAP%2A">*ENTITY-MAP*</a></code></h4> </header> <div class="docstring"><pre>String hash-table containing the entity names and mapping them to their respective characters.</pre></div> </article> </li><li> <a name="PLUMP:*HTML-TAGS*"> </a> <article id="SPECIAL PLUMP:*HTML-TAGS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AHTML-TAGS%2A">*HTML-TAGS*</a></code></h4> </header> <div class="docstring"><pre>List of HTML tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP:*INDEX*"> </a> <article id="SPECIAL PLUMP:*INDEX*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AINDEX%2A">*INDEX*</a></code></h4> </header> <div class="docstring"><pre>Set to the current reading index.</pre></div> </article> </li><li> <a name="PLUMP:*LENGTH*"> </a> <article id="SPECIAL PLUMP:*LENGTH*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2ALENGTH%2A">*LENGTH*</a></code></h4> </header> <div class="docstring"><pre>Set to the length of the string for bounds checking.</pre></div> </article> </li><li> <a name="PLUMP:*ROOT*"> </a> <article id="SPECIAL PLUMP:*ROOT*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AROOT%2A">*ROOT*</a></code></h4> </header> <div class="docstring"><pre>Object containing the current node to set as parent.</pre></div> </article> </li><li> <a name="PLUMP:*STREAM*"> </a> <article id="SPECIAL PLUMP:*STREAM*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2ASTREAM%2A">*STREAM*</a></code></h4> </header> <div class="docstring"><pre>The stream to serialize to during SERIALIZE-OBJECT.</pre></div> </article> </li><li> <a name="PLUMP:*STRING*"> </a> <article id="SPECIAL PLUMP:*STRING*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2ASTRING%2A">*STRING*</a></code></h4> </header> <div class="docstring"><pre>Contains the current string to lex.</pre></div> </article> </li><li> <a name="PLUMP:*TAG-DISPATCHERS*"> </a> <article id="SPECIAL PLUMP:*TAG-DISPATCHERS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2ATAG-DISPATCHERS%2A">*TAG-DISPATCHERS*</a></code></h4> </header> <div class="docstring"><pre>Active tag dispatcher functions</pre></div> </article> </li><li> <a name="PLUMP:*XML-TAGS*"> </a> <article id="SPECIAL PLUMP:*XML-TAGS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20PLUMP%3A%2AXML-TAGS%2A">*XML-TAGS*</a></code></h4> </header> <div class="docstring"><pre>List of XML tag dispatchers</pre></div> </article> </li><li> <a name="PLUMP:CDATA"> </a> <article id="CLASS PLUMP:CDATA"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3ACDATA">CDATA</a></code></h4> </header> <div class="docstring"><pre>XML CDATA section node.</pre></div> </article> </li><li> <a name="PLUMP:CHILD-NODE"> </a> <article id="CLASS PLUMP:CHILD-NODE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3ACHILD-NODE">CHILD-NODE</a></code></h4> </header> <div class="docstring"><pre>Node class that is a child and thus has a parent.</pre></div> </article> </li><li> <a name="PLUMP:COMMENT"> </a> <article id="CLASS PLUMP:COMMENT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3ACOMMENT">COMMENT</a></code></h4> </header> <div class="docstring"><pre>Comment node that can only contain a single comment string.</pre></div> </article> </li><li> <a name="PLUMP:DOCTYPE"> </a> <article id="CLASS PLUMP:DOCTYPE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3ADOCTYPE">DOCTYPE</a></code></h4> </header> <div class="docstring"><pre>Special DOM node for the doctype declaration.</pre></div> </article> </li><li> <a name="PLUMP:ELEMENT"> </a> <article id="CLASS PLUMP:ELEMENT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3AELEMENT">ELEMENT</a></code></h4> </header> <div class="docstring"><pre>Standard DOM element/block including attributes, tag-name, parent and children.</pre></div> </article> </li><li> <a name="PLUMP:FULLTEXT-ELEMENT"> </a> <article id="CLASS PLUMP:FULLTEXT-ELEMENT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3AFULLTEXT-ELEMENT">FULLTEXT-ELEMENT</a></code></h4> </header> <div class="docstring"><pre>Special DOM element that contains full, un-entitied text like SCRIPT and STYLE.</pre></div> </article> </li><li> <a name="PLUMP:NESTING-NODE"> </a> <article id="CLASS PLUMP:NESTING-NODE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3ANESTING-NODE">NESTING-NODE</a></code></h4> </header> <div class="docstring"><pre>Node class that can contain child nodes.</pre></div> </article> </li><li> <a name="PLUMP:NODE"> </a> <article id="CLASS PLUMP:NODE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3ANODE">NODE</a></code></h4> </header> <div class="docstring"><pre>Base DOM node class.</pre></div> </article> </li><li> <a name="PLUMP:PROCESSING-INSTRUCTION"> </a> <article id="CLASS PLUMP:PROCESSING-INSTRUCTION"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3APROCESSING-INSTRUCTION">PROCESSING-INSTRUCTION</a></code></h4> </header> <div class="docstring"><pre>XML processing instruction node.</pre></div> </article> </li><li> <a name="PLUMP:ROOT"> </a> <article id="CLASS PLUMP:ROOT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3AROOT">ROOT</a></code></h4> </header> <div class="docstring"><pre>Root DOM node, practically equivalent to a "document".</pre></div> </article> </li><li> <a name="PLUMP:TAG-DISPATCHER"> </a> <article id="CLASS PLUMP:TAG-DISPATCHER"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3ATAG-DISPATCHER">TAG-DISPATCHER</a></code></h4> </header> <div class="docstring"><pre>Encapsulates the processing for a given tag.
See <a href="NIL">TAG-DISPATCHER-NAME</a>
See <a href="NIL">TAG-DISPATCHER-TEST</a>
See <a href="NIL">TAG-DISPATCHER-PARSER</a>
See <a href="NIL">TAG-DISPATCHER-PRINTER</a></pre></div> </article> </li><li> <a name="PLUMP:TEXT-NODE"> </a> <article id="CLASS PLUMP:TEXT-NODE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3ATEXT-NODE">TEXT-NODE</a></code></h4> </header> <div class="docstring"><pre>Text node that can only contain a single text string.</pre></div> </article> </li><li> <a name="PLUMP:TEXTUAL-NODE"> </a> <article id="CLASS PLUMP:TEXTUAL-NODE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3ATEXTUAL-NODE">TEXTUAL-NODE</a></code></h4> </header> <div class="docstring"><pre>Node class that represents a textual node and thus contains a TEXT field.</pre></div> </article> </li><li> <a name="PLUMP:XML-HEADER"> </a> <article id="CLASS PLUMP:XML-HEADER"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20PLUMP%3AXML-HEADER">XML-HEADER</a></code></h4> </header> <div class="docstring"><pre>XML header element</pre></div> </article> </li><li> <a name="PLUMP:DISCOURAGED-XML-CHARACTER"> </a> <article id="CONDITION PLUMP:DISCOURAGED-XML-CHARACTER"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20PLUMP%3ADISCOURAGED-XML-CHARACTER">DISCOURAGED-XML-CHARACTER</a></code></h4> </header> <div class="docstring"><pre>Warning signalled when a discouraged XML character is encountered during WRITE-ENCODE-CHAR.</pre></div> </article> </li><li> <a name="PLUMP:INVALID-XML-CHARACTER"> </a> <article id="CONDITION PLUMP:INVALID-XML-CHARACTER"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20PLUMP%3AINVALID-XML-CHARACTER">INVALID-XML-CHARACTER</a></code></h4> </header> <div class="docstring"><pre>Error signalled when an invalid XML character is encountered during WRITE-ENCODE-CHAR.</pre></div> </article> </li><li> <a name="PLUMP:ATTRIBUTE"> </a> <article id="ACCESSOR PLUMP:ATTRIBUTE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3AATTRIBUTE">ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code> </header> <div class="docstring"><pre>Returns the asked attribute from the element
or NIL. If the attribute could not be found, the
second return value is set to NIL.</pre></div> </article> </li><li> <a name="PLUMP:ATTRIBUTES"> </a> <article id="ACCESSOR PLUMP:ATTRIBUTES"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3AATTRIBUTES">ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns an EQUALP hash-table of the element's attributes.</pre></div> </article> </li><li> <a name="PLUMP:CHILDREN"> </a> <article id="ACCESSOR PLUMP:CHILDREN"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3ACHILDREN">CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns a vector of child-nodes that are contained within the node.</pre></div> </article> </li><li> <a name="PLUMP:DOCTYPE"> </a> <article id="ACCESSOR PLUMP:DOCTYPE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3ADOCTYPE">DOCTYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns the doctype node's actual doctype string.</pre></div> </article> </li><li> <a name="PLUMP:FAULTY-CHAR"> </a> <article id="ACCESSOR PLUMP:FAULTY-CHAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3AFAULTY-CHAR">FAULTY-CHAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code> </header> <div class="docstring"><pre>Returns the faulty char that caused the signal.</pre></div> </article> </li><li> <a name="PLUMP:PARENT"> </a> <article id="ACCESSOR PLUMP:PARENT"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3APARENT">PARENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns the node's parent that should contain this element as a child.</pre></div> </article> </li><li> <a name="PLUMP:PROCESSING-PARSER"> </a> <article id="ACCESSOR PLUMP:PROCESSING-PARSER"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3APROCESSING-PARSER">PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME</code><code>)</code> </header> <div class="docstring"><pre>Return the processing-parser function for PROCESS-NAME. SETF-able.</pre></div> </article> </li><li> <a name="PLUMP:TAG-NAME"> </a> <article id="ACCESSOR PLUMP:TAG-NAME"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3ATAG-NAME">TAG-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns the element's tag name.</pre></div> </article> </li><li> <a name="PLUMP:TEXT"> </a> <article id="ACCESSOR PLUMP:TEXT"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20PLUMP%3ATEXT">TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns the node's textual content.</pre></div> </article> </li><li> <a name="PLUMP:ADVANCE"> </a> <article id="FUNCTION PLUMP:ADVANCE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AADVANCE">ADVANCE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Skips a chracter if possible.
Returns the new index or NIL.</pre></div> </article> </li><li> <a name="PLUMP:ADVANCE-N"> </a> <article id="FUNCTION PLUMP:ADVANCE-N"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AADVANCE-N">ADVANCE-N</a></code></h4> <code class="qualifiers"></code> <code class="arguments">N</code><code>)</code> </header> <div class="docstring"><pre>Advances by N characters if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP:ALLOWED-CHAR-P"> </a> <article id="FUNCTION PLUMP:ALLOWED-CHAR-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AALLOWED-CHAR-P">ALLOWED-CHAR-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the character is a permitted XML character.</pre></div> </article> </li><li> <a name="PLUMP:APPEND-CHILD"> </a> <article id="FUNCTION PLUMP:APPEND-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AAPPEND-CHILD">APPEND-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT CHILD</code><code>)</code> </header> <div class="docstring"><pre>Appends the given child onto the parent's child list.
Returns the child.</pre></div> </article> </li><li> <a name="PLUMP:CDATA-P"> </a> <article id="FUNCTION PLUMP:CDATA-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACDATA-P">CDATA-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type CDATA</pre></div> </article> </li><li> <a name="PLUMP:CHILD-ELEMENTS"> </a> <article id="FUNCTION PLUMP:CHILD-ELEMENTS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACHILD-ELEMENTS">CHILD-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NESTING-NODE</code><code>)</code> </header> <div class="docstring"><pre>Returns a new vector of children of the given node, filtered to elements.</pre></div> </article> </li><li> <a name="PLUMP:CHILD-NODE-P"> </a> <article id="FUNCTION PLUMP:CHILD-NODE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACHILD-NODE-P">CHILD-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type CHILD-NODE</pre></div> </article> </li><li> <a name="PLUMP:CHILD-POSITION"> </a> <article id="FUNCTION PLUMP:CHILD-POSITION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACHILD-POSITION">CHILD-POSITION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the index of the child within its parent.</pre></div> </article> </li><li> <a name="PLUMP:CLEAR"> </a> <article id="FUNCTION PLUMP:CLEAR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACLEAR">CLEAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NESTING-NODE</code><code>)</code> </header> <div class="docstring"><pre>Clears all children from the node.
Noe that the PARENT of all child elements is set to NIL.</pre></div> </article> </li><li> <a name="PLUMP:CLONE-ATTRIBUTES"> </a> <article id="FUNCTION PLUMP:CLONE-ATTRIBUTES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACLONE-ATTRIBUTES">CLONE-ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>Clone the attribute map.
Note that keys and values are NOT copied/cloned.</pre></div> </article> </li><li> <a name="PLUMP:CLONE-CHILDREN"> </a> <article id="FUNCTION PLUMP:CLONE-CHILDREN"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACLONE-CHILDREN">CLONE-CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &OPTIONAL DEEP NEW-PARENT</code><code>)</code> </header> <div class="docstring"><pre>Clone the array of children.
If DEEP is non-NIL, each child is cloned as per (CLONE-NODE NODE T).
When copying deeply, you can also pass a NEW-PARENT to set on each child.</pre></div> </article> </li><li> <a name="PLUMP:COMMENT-P"> </a> <article id="FUNCTION PLUMP:COMMENT-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACOMMENT-P">COMMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type COMMENT</pre></div> </article> </li><li> <a name="PLUMP:CONSUME"> </a> <article id="FUNCTION PLUMP:CONSUME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACONSUME">CONSUME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Consumes a single character if possible and returns it.
Otherwise returns NIL.</pre></div> </article> </li><li> <a name="PLUMP:CONSUME-UNTIL"> </a> <article id="FUNCTION PLUMP:CONSUME-UNTIL"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ACONSUME-UNTIL">CONSUME-UNTIL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code> </header> <div class="docstring"><pre>Consumes until the provided matcher function returns positively.
Returns the substring that was consumed.</pre></div> </article> </li><li> <a name="PLUMP:DECODE-ENTITIES"> </a> <article id="FUNCTION PLUMP:DECODE-ENTITIES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ADECODE-ENTITIES">DECODE-ENTITIES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &OPTIONAL REMOVE-INVALID</code><code>)</code> </header> <div class="docstring"><pre>Translates all entities in the text into their character counterparts if possible.
If an entity does not match, it is left in place unless REMOVE-INVALID is non-NIL.</pre></div> </article> </li><li> <a name="PLUMP:DISCOURAGED-CHAR-P"> </a> <article id="FUNCTION PLUMP:DISCOURAGED-CHAR-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ADISCOURAGED-CHAR-P">DISCOURAGED-CHAR-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the character is a discouraged XML character.</pre></div> </article> </li><li> <a name="PLUMP:DOCTYPE-P"> </a> <article id="FUNCTION PLUMP:DOCTYPE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ADOCTYPE-P">DOCTYPE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type DOCTYPE</pre></div> </article> </li><li> <a name="PLUMP:ELEMENT-P"> </a> <article id="FUNCTION PLUMP:ELEMENT-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AELEMENT-P">ELEMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type ELEMENT</pre></div> </article> </li><li> <a name="PLUMP:ELEMENT-POSITION"> </a> <article id="FUNCTION PLUMP:ELEMENT-POSITION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AELEMENT-POSITION">ELEMENT-POSITION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the index of the child within its parent, counting only elements.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:ENCODE-ENTITIES"> </a> <article id="FUNCTION PLUMP:ENCODE-ENTITIES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AENCODE-ENTITIES">ENCODE-ENTITIES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &OPTIONAL STREAM</code><code>)</code> </header> <div class="docstring"><pre>Encodes the characters < > & " with their XML entity equivalents.
If no STREAM is given, it encodes to a new string.</pre></div> </article> </li><li> <a name="PLUMP:ENSURE-ATTRIBUTE-MAP"> </a> <article id="FUNCTION PLUMP:ENSURE-ATTRIBUTE-MAP"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AENSURE-ATTRIBUTE-MAP">ENSURE-ATTRIBUTE-MAP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TABLE</code><code>)</code> </header> <div class="docstring"><pre>Ensures that the TABLE is suitable as an attribute-map.
If it is not, the table is copied into a proper attribute-map.</pre></div> </article> </li><li> <a name="PLUMP:ENSURE-CHILD-ARRAY"> </a> <article id="FUNCTION PLUMP:ENSURE-CHILD-ARRAY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AENSURE-CHILD-ARRAY">ENSURE-CHILD-ARRAY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code> </header> <div class="docstring"><pre>If the ARRAY is suitable as a child-array, it is returned.
Otherwise the array's elements are copied over into a proper
child-array.</pre></div> </article> </li><li> <a name="PLUMP:FAMILY"> </a> <article id="FUNCTION PLUMP:FAMILY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AFAMILY">FAMILY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the direct array of children of the parent of the given child.
Note that modifying this array directly modifies that of the parent.</pre></div> </article> </li><li> <a name="PLUMP:FAMILY-ELEMENTS"> </a> <article id="FUNCTION PLUMP:FAMILY-ELEMENTS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AFAMILY-ELEMENTS">FAMILY-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the direct array of children elements of the parent of the given child.
Note that this is a copy of the array, modifying it is safe.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:FIRST-CHILD"> </a> <article id="FUNCTION PLUMP:FIRST-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AFIRST-CHILD">FIRST-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code> </header> <div class="docstring"><pre>Returns the first child within the parent or NIL
if the parent is empty.</pre></div> </article> </li><li> <a name="PLUMP:FIRST-ELEMENT"> </a> <article id="FUNCTION PLUMP:FIRST-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AFIRST-ELEMENT">FIRST-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code> </header> <div class="docstring"><pre>Returns the first child element within the parent or NIL
if the parent is empty. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:FULLTEXT-ELEMENT-P"> </a> <article id="FUNCTION PLUMP:FULLTEXT-ELEMENT-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AFULLTEXT-ELEMENT-P">FULLTEXT-ELEMENT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type FULLTEXT-ELEMENT</pre></div> </article> </li><li> <a name="PLUMP:GET-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP:GET-ATTRIBUTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AGET-ATTRIBUTE">GET-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code> </header> <div class="docstring"><pre>Synonymous to ATTRIBUTE.</pre></div> </article> </li><li> <a name="PLUMP:GET-ELEMENT-BY-ID"> </a> <article id="FUNCTION PLUMP:GET-ELEMENT-BY-ID"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AGET-ELEMENT-BY-ID">GET-ELEMENT-BY-ID</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE ID</code><code>)</code> </header> <div class="docstring"><pre>Searches the given node and returns the first
node at arbitrary depth that matches the given ID
attribute.</pre></div> </article> </li><li> <a name="PLUMP:GET-ELEMENTS-BY-TAG-NAME"> </a> <article id="FUNCTION PLUMP:GET-ELEMENTS-BY-TAG-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AGET-ELEMENTS-BY-TAG-NAME">GET-ELEMENTS-BY-TAG-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE TAG</code><code>)</code> </header> <div class="docstring"><pre>Searches the given node and returns an unordered
list of child nodes at arbitrary depth that match
the given tag.</pre></div> </article> </li><li> <a name="PLUMP:HAS-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP:HAS-ATTRIBUTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AHAS-ATTRIBUTE">HAS-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the provided attribute exists.</pre></div> </article> </li><li> <a name="PLUMP:HAS-CHILD-NODES"> </a> <article id="FUNCTION PLUMP:HAS-CHILD-NODES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AHAS-CHILD-NODES">HAS-CHILD-NODES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the node can contain children and
the child array is not empty.</pre></div> </article> </li><li> <a name="PLUMP:INSERT-AFTER"> </a> <article id="FUNCTION PLUMP:INSERT-AFTER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AINSERT-AFTER">INSERT-AFTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT NEW-CHILD</code><code>)</code> </header> <div class="docstring"><pre>Inserts the new-child after the given element in the parent's list.
Returns the new child.
Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-PUSH-EXTEND-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP:INSERT-BEFORE"> </a> <article id="FUNCTION PLUMP:INSERT-BEFORE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AINSERT-BEFORE">INSERT-BEFORE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT NEW-CHILD</code><code>)</code> </header> <div class="docstring"><pre>Inserts the new-child before the given element in the parent's list.
Returns the new child.
Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-PUSH-EXTEND-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP:LAST-CHILD"> </a> <article id="FUNCTION PLUMP:LAST-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ALAST-CHILD">LAST-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code> </header> <div class="docstring"><pre>Returns the last child within the parent or NIL
if the parent is empty.</pre></div> </article> </li><li> <a name="PLUMP:LAST-ELEMENT"> </a> <article id="FUNCTION PLUMP:LAST-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ALAST-ELEMENT">LAST-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code> </header> <div class="docstring"><pre>Returns the last child element within the parent or NIL
if the parent is empty. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-ATTRIBUTE-MAP"> </a> <article id="FUNCTION PLUMP:MAKE-ATTRIBUTE-MAP"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-ATTRIBUTE-MAP">MAKE-ATTRIBUTE-MAP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&OPTIONAL (SIZE 0)</code><code>)</code> </header> <div class="docstring"><pre>Creates a map to contain attributes.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-CDATA"> </a> <article id="FUNCTION PLUMP:MAKE-CDATA"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-CDATA">MAKE-CDATA</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &KEY (TEXT "")</code><code>)</code> </header> <div class="docstring"><pre>Creates an XML CDATA section under the parent.
Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-CHILD-ARRAY"> </a> <article id="FUNCTION PLUMP:MAKE-CHILD-ARRAY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-CHILD-ARRAY">MAKE-CHILD-ARRAY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&OPTIONAL (SIZE 0)</code><code>)</code> </header> <div class="docstring"><pre>Creates an array to contain child elements</pre></div> </article> </li><li> <a name="PLUMP:MAKE-COMMENT"> </a> <article id="FUNCTION PLUMP:MAKE-COMMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-COMMENT">MAKE-COMMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &OPTIONAL (TEXT "")</code><code>)</code> </header> <div class="docstring"><pre>Creates a new comment node under the parent.
Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-DOCTYPE"> </a> <article id="FUNCTION PLUMP:MAKE-DOCTYPE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-DOCTYPE">MAKE-DOCTYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT DOCTYPE</code><code>)</code> </header> <div class="docstring"><pre>Creates a new doctype node under the parent.
Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-ELEMENT"> </a> <article id="FUNCTION PLUMP:MAKE-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-ELEMENT">MAKE-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT TAG &KEY (CHILDREN (MAKE-CHILD-ARRAY))
(ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code> </header> <div class="docstring"><pre>Creates a standard DOM element with the given tag name and parent.
Optionally a vector (with fill-pointer) containing children and an
attribute-map (a hash-table with equalp test) can be supplied.
Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-FULLTEXT-ELEMENT"> </a> <article id="FUNCTION PLUMP:MAKE-FULLTEXT-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-FULLTEXT-ELEMENT">MAKE-FULLTEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT TAG &KEY TEXT (ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code> </header> <div class="docstring"><pre>Creates a fulltext element under the parent.
Optionally a text and an attribute-map (a hash-table with equalp test)
can be supplied.
Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-PROCESSING-INSTRUCTION"> </a> <article id="FUNCTION PLUMP:MAKE-PROCESSING-INSTRUCTION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-PROCESSING-INSTRUCTION">MAKE-PROCESSING-INSTRUCTION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &KEY NAME (TEXT "")</code><code>)</code> </header> <div class="docstring"><pre>Creates an XML processing instruction under the parent.
Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-ROOT"> </a> <article id="FUNCTION PLUMP:MAKE-ROOT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-ROOT">MAKE-ROOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&OPTIONAL (CHILDREN (MAKE-CHILD-ARRAY))</code><code>)</code> </header> <div class="docstring"><pre>Creates a root node with the given children.
Children should be a vector with fill-pointer.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-TEXT-NODE"> </a> <article id="FUNCTION PLUMP:MAKE-TEXT-NODE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-TEXT-NODE">MAKE-TEXT-NODE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &OPTIONAL (TEXT "")</code><code>)</code> </header> <div class="docstring"><pre>Creates a new text node under the parent.
Note that the node is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-XML-HEADER"> </a> <article id="FUNCTION PLUMP:MAKE-XML-HEADER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMAKE-XML-HEADER">MAKE-XML-HEADER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT &KEY (ATTRIBUTES (MAKE-ATTRIBUTE-MAP))</code><code>)</code> </header> <div class="docstring"><pre>Creates an XML header object under the parent.
Note that the element is automatically appended to the parent's child list.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-AND"> </a> <article id="FUNCTION PLUMP:MATCHER-AND"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-AND">MATCHER-AND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST MATCHERS</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that returns if all of the sub-expressions
return successfully. The last match is returned, if all.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-CHARACTER"> </a> <article id="FUNCTION PLUMP:MATCHER-CHARACTER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-CHARACTER">MATCHER-CHARACTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHARACTER</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that attempts to match the given character.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-FIND"> </a> <article id="FUNCTION PLUMP:MATCHER-FIND"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-FIND">MATCHER-FIND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that returns T if the character is found in the given list.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-NEXT"> </a> <article id="FUNCTION PLUMP:MATCHER-NEXT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-NEXT">MATCHER-NEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher environment that peeks ahead one farther.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-NOT"> </a> <article id="FUNCTION PLUMP:MATCHER-NOT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-NOT">MATCHER-NOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that inverts the result of the sub-expression.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-OR"> </a> <article id="FUNCTION PLUMP:MATCHER-OR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-OR">MATCHER-OR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST MATCHERS</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that returns successfully if any of the
sub-expressions return successfully. The first match is returned, if any.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-PREV"> </a> <article id="FUNCTION PLUMP:MATCHER-PREV"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-PREV">MATCHER-PREV</a></code></h4> <code class="qualifiers"></code> <code class="arguments">MATCHER</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher environment that peeks behind.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-RANGE"> </a> <article id="FUNCTION PLUMP:MATCHER-RANGE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-RANGE">MATCHER-RANGE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FROM TO</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher that checks a range according to the next character's CHAR-CODE.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-STRING"> </a> <article id="FUNCTION PLUMP:MATCHER-STRING"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AMATCHER-STRING">MATCHER-STRING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STRING</code><code>)</code> </header> <div class="docstring"><pre>Creates a matcher function that attempts to match the given string.</pre></div> </article> </li><li> <a name="PLUMP:NESTING-NODE-P"> </a> <article id="FUNCTION PLUMP:NESTING-NODE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ANESTING-NODE-P">NESTING-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type NESTING-NODE</pre></div> </article> </li><li> <a name="PLUMP:NEXT-ELEMENT"> </a> <article id="FUNCTION PLUMP:NEXT-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ANEXT-ELEMENT">NEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the sibling element next to this one or NIL if
it is already last. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:NEXT-SIBLING"> </a> <article id="FUNCTION PLUMP:NEXT-SIBLING"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ANEXT-SIBLING">NEXT-SIBLING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the sibling next to this one or NIL if
it is already the last.</pre></div> </article> </li><li> <a name="PLUMP:NODE-P"> </a> <article id="FUNCTION PLUMP:NODE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ANODE-P">NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type NODE</pre></div> </article> </li><li> <a name="PLUMP:PEEK"> </a> <article id="FUNCTION PLUMP:PEEK"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3APEEK">PEEK</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Returns the next character, if any.</pre></div> </article> </li><li> <a name="PLUMP:PREPEND-CHILD"> </a> <article id="FUNCTION PLUMP:PREPEND-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3APREPEND-CHILD">PREPEND-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT CHILD</code><code>)</code> </header> <div class="docstring"><pre>Prepends the given child onto the parent's child list.
Returns the child.
Note that this operation is costly, see VECTOR-PUSH-EXTEND-FRONT</pre></div> </article> </li><li> <a name="PLUMP:PREVIOUS-ELEMENT"> </a> <article id="FUNCTION PLUMP:PREVIOUS-ELEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3APREVIOUS-ELEMENT">PREVIOUS-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the sibling element next to this one or NIL if
it is already last. This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:PREVIOUS-SIBLING"> </a> <article id="FUNCTION PLUMP:PREVIOUS-SIBLING"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3APREVIOUS-SIBLING">PREVIOUS-SIBLING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the sibling before this one or NIL if
it is already the first.</pre></div> </article> </li><li> <a name="PLUMP:PROCESSING-INSTRUCTION-P"> </a> <article id="FUNCTION PLUMP:PROCESSING-INSTRUCTION-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3APROCESSING-INSTRUCTION-P">PROCESSING-INSTRUCTION-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type PROCESSING-INSTRUCTION</pre></div> </article> </li><li> <a name="PLUMP:READ-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP:READ-ATTRIBUTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-ATTRIBUTE">READ-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads an attribute and returns it as a key value cons.</pre></div> </article> </li><li> <a name="PLUMP:READ-ATTRIBUTE-NAME"> </a> <article id="FUNCTION PLUMP:READ-ATTRIBUTE-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-ATTRIBUTE-NAME">READ-ATTRIBUTE-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads an attribute name.</pre></div> </article> </li><li> <a name="PLUMP:READ-ATTRIBUTE-VALUE"> </a> <article id="FUNCTION PLUMP:READ-ATTRIBUTE-VALUE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-ATTRIBUTE-VALUE">READ-ATTRIBUTE-VALUE</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads an attribute value, either enclosed in quotation marks or until a space or tag end.</pre></div> </article> </li><li> <a name="PLUMP:READ-ATTRIBUTES"> </a> <article id="FUNCTION PLUMP:READ-ATTRIBUTES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-ATTRIBUTES">READ-ATTRIBUTES</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads as many attributes as possible from a tag and returns them as an attribute map.</pre></div> </article> </li><li> <a name="PLUMP:READ-CHILDREN"> </a> <article id="FUNCTION PLUMP:READ-CHILDREN"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-CHILDREN">READ-CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Read all children of the current *root* until the closing tag for *root* is encountered.</pre></div> </article> </li><li> <a name="PLUMP:READ-NAME"> </a> <article id="FUNCTION PLUMP:READ-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-NAME">READ-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads and returns a tag name.</pre></div> </article> </li><li> <a name="PLUMP:READ-ROOT"> </a> <article id="FUNCTION PLUMP:READ-ROOT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-ROOT">READ-ROOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&OPTIONAL (ROOT (MAKE-ROOT))</code><code>)</code> </header> <div class="docstring"><pre>Creates a root element and reads nodes into it.
Optionally uses the specified root to append child nodes to.
Returns the root.</pre></div> </article> </li><li> <a name="PLUMP:READ-STANDARD-TAG"> </a> <article id="FUNCTION PLUMP:READ-STANDARD-TAG"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-STANDARD-TAG">READ-STANDARD-TAG</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code> </header> <div class="docstring"><pre>Reads an arbitrary tag and returns it.
This recurses with READ-CHILDREN.</pre></div> </article> </li><li> <a name="PLUMP:READ-TAG"> </a> <article id="FUNCTION PLUMP:READ-TAG"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-TAG">READ-TAG</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Attempts to read a tag and dispatches or defaults to READ-STANDARD-TAG.
Returns the completed node if one can be read.</pre></div> </article> </li><li> <a name="PLUMP:READ-TAG-CONTENTS"> </a> <article id="FUNCTION PLUMP:READ-TAG-CONTENTS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-TAG-CONTENTS">READ-TAG-CONTENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads and returns all tag contents.
E.g. <foo bar baz> => bar baz</pre></div> </article> </li><li> <a name="PLUMP:READ-TEXT"> </a> <article id="FUNCTION PLUMP:READ-TEXT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREAD-TEXT">READ-TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Reads and returns a text-node.</pre></div> </article> </li><li> <a name="PLUMP:REMOVE-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP:REMOVE-ATTRIBUTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREMOVE-ATTRIBUTE">REMOVE-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE</code><code>)</code> </header> <div class="docstring"><pre>Remove the specified attribute if it exists.
Returns NIL.</pre></div> </article> </li><li> <a name="PLUMP:REMOVE-CHILD"> </a> <article id="FUNCTION PLUMP:REMOVE-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREMOVE-CHILD">REMOVE-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Removes the child from its parent.
Returns the child.
Note that this operation is potentially very costly.
See <a href="NIL">VECTOR-POP-POSITION</a></pre></div> </article> </li><li> <a name="PLUMP:REMOVE-PROCESSING-PARSER"> </a> <article id="FUNCTION PLUMP:REMOVE-PROCESSING-PARSER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREMOVE-PROCESSING-PARSER">REMOVE-PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME</code><code>)</code> </header> <div class="docstring"><pre>Remove the processing-parser for PROCESS-NAME.</pre></div> </article> </li><li> <a name="PLUMP:REMOVE-TAG-DISPATCHER"> </a> <article id="FUNCTION PLUMP:REMOVE-TAG-DISPATCHER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREMOVE-TAG-DISPATCHER">REMOVE-TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME &OPTIONAL (LIST '*ALL-TAG-DISPATCHERS*)</code><code>)</code> </header> <div class="docstring"><pre>Removes the tag-dispatcher of the given name from the list.</pre></div> </article> </li><li> <a name="PLUMP:RENDER-TEXT"> </a> <article id="FUNCTION PLUMP:RENDER-TEXT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ARENDER-TEXT">RENDER-TEXT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>"Renders" the text of this element and its children.
In effect the text is gathered from the component and all of
its children, but transforming the text in such a way that:
- All ASCII white space (Space, Tab, CR, LF) is converted into spaces.
- There are no consecutive spaces.
- There are no spaces at the beginning or end.
This is somewhat analogous to how the text will be shown to
the user when rendered by a browser. Hence, render-text.</pre></div> </article> </li><li> <a name="PLUMP:REPLACE-CHILD"> </a> <article id="FUNCTION PLUMP:REPLACE-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AREPLACE-CHILD">REPLACE-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OLD-CHILD NEW-CHILD</code><code>)</code> </header> <div class="docstring"><pre>Replace the old child with a new one.
Returns the old child.</pre></div> </article> </li><li> <a name="PLUMP:ROOT-P"> </a> <article id="FUNCTION PLUMP:ROOT-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AROOT-P">ROOT-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type ROOT</pre></div> </article> </li><li> <a name="PLUMP:SERIALIZE"> </a> <article id="FUNCTION PLUMP:SERIALIZE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASERIALIZE">SERIALIZE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &OPTIONAL (STREAM T)</code><code>)</code> </header> <div class="docstring"><pre>Serializes NODE to STREAM.
STREAM can be a stream, T for *standard-output* or NIL to serialize to string.</pre></div> </article> </li><li> <a name="PLUMP:SET-ATTRIBUTE"> </a> <article id="FUNCTION PLUMP:SET-ATTRIBUTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASET-ATTRIBUTE">SET-ATTRIBUTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT ATTRIBUTE VALUE</code><code>)</code> </header> <div class="docstring"><pre>Synonymous to (SETF (ATTIBUTE ..) ..)</pre></div> </article> </li><li> <a name="PLUMP:SIBLING-ELEMENTS"> </a> <article id="FUNCTION PLUMP:SIBLING-ELEMENTS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASIBLING-ELEMENTS">SIBLING-ELEMENTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the array of sibling elements of the given child.
Note that this is a copy of the array, modifying it is safe.
This excludes comments, text-nodes and the like.</pre></div> </article> </li><li> <a name="PLUMP:SIBLINGS"> </a> <article id="FUNCTION PLUMP:SIBLINGS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASIBLINGS">SIBLINGS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHILD</code><code>)</code> </header> <div class="docstring"><pre>Returns the array of siblings of the given child.
Note that this is a copy of the array, modifying it is safe.</pre></div> </article> </li><li> <a name="PLUMP:SLURP-STREAM"> </a> <article id="FUNCTION PLUMP:SLURP-STREAM"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASLURP-STREAM">SLURP-STREAM</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STREAM</code><code>)</code> </header> <div class="docstring"><pre>Quickly slurps the stream's contents into an array with fill pointer.</pre></div> </article> </li><li> <a name="PLUMP:SPLICE"> </a> <article id="FUNCTION PLUMP:SPLICE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASPLICE">SPLICE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ELEMENT</code><code>)</code> </header> <div class="docstring"><pre>Splices the contents of element into the position of the element in its parent.
Returns the parent.
Note that this operation is potentially very costly.
See <a href="NIL">ARRAY-SHIFT</a></pre></div> </article> </li><li> <a name="PLUMP:STRIP"> </a> <article id="FUNCTION PLUMP:STRIP"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ASTRIP">STRIP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>Trim all text-nodes within NODE (at any depth) of leading and trailing whitespace.
If their TEXT should be an empty string after trimming, remove them.</pre></div> </article> </li><li> <a name="PLUMP:TAG-DISPATCHER"> </a> <article id="FUNCTION PLUMP:TAG-DISPATCHER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ATAG-DISPATCHER">TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME &OPTIONAL (LIST *ALL-TAG-DISPATCHERS*)</code><code>)</code> </header> <div class="docstring"><pre>Accessor to the tag-dispatcher of the given name.</pre></div> </article> </li><li> <a name="PLUMP:TEXT-NODE-P"> </a> <article id="FUNCTION PLUMP:TEXT-NODE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ATEXT-NODE-P">TEXT-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type TEXT-NODE</pre></div> </article> </li><li> <a name="PLUMP:TEXTUAL-NODE-P"> </a> <article id="FUNCTION PLUMP:TEXTUAL-NODE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ATEXTUAL-NODE-P">TEXTUAL-NODE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type TEXTUAL-NODE</pre></div> </article> </li><li> <a name="PLUMP:TRANSLATE-ENTITY"> </a> <article id="FUNCTION PLUMP:TRANSLATE-ENTITY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ATRANSLATE-ENTITY">TRANSLATE-ENTITY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TEXT &KEY (START 0) (END (LENGTH TEXT))</code><code>)</code> </header> <div class="docstring"><pre>Translates the given entity identifier (a name, #Dec or #xHex) into their respective strings if possible.
Otherwise returns NIL.</pre></div> </article> </li><li> <a name="PLUMP:TRIM"> </a> <article id="FUNCTION PLUMP:TRIM"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3ATRIM">TRIM</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>Trim all text-nodes within NODE (at any depth) of leading and trailing whitespace.</pre></div> </article> </li><li> <a name="PLUMP:UNREAD"> </a> <article id="FUNCTION PLUMP:UNREAD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AUNREAD">UNREAD</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Steps back a single character if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP:UNREAD-N"> </a> <article id="FUNCTION PLUMP:UNREAD-N"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AUNREAD-N">UNREAD-N</a></code></h4> <code class="qualifiers"></code> <code class="arguments">N</code><code>)</code> </header> <div class="docstring"><pre>Steps back by N characters if possible.
Returns the new *INDEX*.</pre></div> </article> </li><li> <a name="PLUMP:WRITE-ENCODE-CHAR"> </a> <article id="FUNCTION PLUMP:WRITE-ENCODE-CHAR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AWRITE-ENCODE-CHAR">WRITE-ENCODE-CHAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR STREAM</code><code>)</code> </header> <div class="docstring"><pre>Write and possibly encode the CHAR to STREAM.
This also properly handles detection of invalid or discouraged XML characters.
The following restarts are available in the case of a faulty character:
ABORT Do not output the faulty character at all.
USE-NEW-CHARACTER Output a replacement character instead.
CONTINUE Continue and output the faulty character anyway.
See <a href="#PLUMP-DOM:INVALID-XML-CHARACTER">INVALID-XML-CHARACTER</a>
See <a href="#PLUMP-DOM:DISCOURAGED-XML-CHARACTER">DISCOURAGED-XML-CHARACTER</a></pre></div> </article> </li><li> <a name="PLUMP:XML-HEADER-P"> </a> <article id="FUNCTION PLUMP:XML-HEADER-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20PLUMP%3AXML-HEADER-P">XML-HEADER-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the given OBJECT is of type XML-HEADER</pre></div> </article> </li><li> <a name="PLUMP:CLONE-NODE"> </a> <article id="GENERIC PLUMP:CLONE-NODE"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP%3ACLONE-NODE">CLONE-NODE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE &OPTIONAL DEEP</code><code>)</code> </header> <div class="docstring"><pre>Clone the given node, creating a new instance with the same contents.
If DEEP is non-NIL, the following applies:
The text of COMMENT and TEXT-NODEs is copied as per COPY-SEQ.
The children of NESTING-NODEs are copied as per (CLONE-CHILDREN CHILD T)</pre></div> </article> </li><li> <a name="PLUMP:PARSE"> </a> <article id="GENERIC PLUMP:PARSE"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP%3APARSE">PARSE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INPUT &KEY ROOT</code><code>)</code> </header> <div class="docstring"><pre>Parses the given input into a DOM representation.
By default, methods for STRING, PATHNAME and STREAM are defined.
If supplied, the given root is used to append children to as per READ-ROOT.
Returns the root.</pre></div> </article> </li><li> <a name="PLUMP:SERIALIZE-OBJECT"> </a> <article id="GENERIC PLUMP:SERIALIZE-OBJECT"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP%3ASERIALIZE-OBJECT">SERIALIZE-OBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE</code><code>)</code> </header> <div class="docstring"><pre>Serialize the given node and print it to *stream*.</pre></div> </article> </li><li> <a name="PLUMP:TRAVERSE"> </a> <article id="GENERIC PLUMP:TRAVERSE"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20PLUMP%3ATRAVERSE">TRAVERSE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NODE FUNCTION &KEY TEST</code><code>)</code> </header> <div class="docstring"><pre>Traverse the NODE and all its children recursively,
calling FUNCTION on the current node if calling TEST on the current node
returns a non-NIL value. It is safe to modify the child array of the
parent of each node passed to FUNCTION.
NODE is returned.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-FULLTEXT-ELEMENT"> </a> <article id="MACRO PLUMP:DEFINE-FULLTEXT-ELEMENT"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-FULLTEXT-ELEMENT">DEFINE-FULLTEXT-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TAG &REST LISTS</code><code>)</code> </header> <div class="docstring"><pre>Defines an element to be read as a full-text element.
This means that it cannot contain any child-nodes and everything up until its closing
tag is used as its text.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-MATCHER"> </a> <article id="MACRO PLUMP:DEFINE-MATCHER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-MATCHER">DEFINE-MATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME FORM</code><code>)</code> </header> <div class="docstring"><pre>Associates NAME as a keyword to the matcher form. You can then use the keyword in further matcher rules.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-PROCESSING-PARSER"> </a> <article id="MACRO PLUMP:DEFINE-PROCESSING-PARSER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-PROCESSING-PARSER">DEFINE-PROCESSING-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PROCESS-NAME NIL &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a new processing-instruction parser.
It is invoked if a processing-instruction (<?) with PROCESS-NAME is encountered.
The lexer will be at the point straight after reading in the PROCESS-NAME.
Expected return value is a string to use as the processing-instructions' TEXT.
The closing tag (?>) should NOT be consumed by a processing-parser.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-SELF-CLOSING-ELEMENT"> </a> <article id="MACRO PLUMP:DEFINE-SELF-CLOSING-ELEMENT"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-SELF-CLOSING-ELEMENT">DEFINE-SELF-CLOSING-ELEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TAG &REST LISTS</code><code>)</code> </header> <div class="docstring"><pre>Defines an element that does not need to be closed with /> and cannot contain child nodes.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-TAG-DISPATCHER"> </a> <article id="MACRO PLUMP:DEFINE-TAG-DISPATCHER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-TAG-DISPATCHER">DEFINE-TAG-DISPATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(NAME &REST LISTS) (TAGVAR) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a new tag dispatcher. It is invoked if TEST-FORM passes.
NAME --- Name to discern the dispatcher with.
LISTS --- Symbols of lists to which the dispatcher should be added.
TAGVAR --- Symbol bound to the tag name.
BODY --- Body forms describing the test to match the tag.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-TAG-PARSER"> </a> <article id="MACRO PLUMP:DEFINE-TAG-PARSER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-TAG-PARSER">DEFINE-TAG-PARSER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (TAGVAR) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines the parser function for a tag dispatcher.
NAME --- The name of the tag dispatcher. If one with this name
cannot be found, an error is signalled.
TAGVAR --- Symbol bound to the tag name.
BODY --- Body forms describing the tag parsing behaviour.</pre></div> </article> </li><li> <a name="PLUMP:DEFINE-TAG-PRINTER"> </a> <article id="MACRO PLUMP:DEFINE-TAG-PRINTER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADEFINE-TAG-PRINTER">DEFINE-TAG-PRINTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (NODEVAR) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines the printer function for a tag dispatcher.
NAME --- The name of the tag dispatcher. If one with this name
cannot be found, an error is signalled.
TAGVAR --- Symbol bound to the tag name.
BODY --- Body forms describing the printing behaviour. Write to
the stream bound to PLUMP-DOM:*STREAM*.</pre></div> </article> </li><li> <a name="PLUMP:DO-TAG-PARSERS"> </a> <article id="MACRO PLUMP:DO-TAG-PARSERS"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADO-TAG-PARSERS">DO-TAG-PARSERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(TEST PARSER &OPTIONAL RESULT-FORM) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Iterates over the current *TAG-DISPATCHERS*, binding the TEST and PARSER functions.
Returns RESULT-FORM's evaluated value.</pre></div> </article> </li><li> <a name="PLUMP:DO-TAG-PRINTERS"> </a> <article id="MACRO PLUMP:DO-TAG-PRINTERS"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3ADO-TAG-PRINTERS">DO-TAG-PRINTERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(TEST PRINTER &OPTIONAL RESULT-FORM) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Iterates over the current *TAG-DISPATCHERS*, binding the TEST and PRINTER functions.
Returns RESULT-FORM's evaluated value.</pre></div> </article> </li><li> <a name="PLUMP:MAKE-MATCHER"> </a> <article id="MACRO PLUMP:MAKE-MATCHER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3AMAKE-MATCHER">MAKE-MATCHER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FORM</code><code>)</code> </header> <div class="docstring"><pre>Macro to create a matcher chain.</pre></div> </article> </li><li> <a name="PLUMP:MATCHER-ANY"> </a> <article id="MACRO PLUMP:MATCHER-ANY"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3AMATCHER-ANY">MATCHER-ANY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST IS</code><code>)</code> </header> <div class="docstring"><pre>Shorthand for (or (is a) (is b)..)</pre></div> </article> </li><li> <a name="PLUMP:WITH-LEXER-ENVIRONMENT"> </a> <article id="MACRO PLUMP:WITH-LEXER-ENVIRONMENT"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20PLUMP%3AWITH-LEXER-ENVIRONMENT">WITH-LEXER-ENVIRONMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(STRING) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Sets up the required lexing environment for the given string.</pre></div> </article> </li></ul> </li></ul> </article> </main> </body> </html>