1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 /*
6 * Licensed to the Apache Software Foundation (ASF) under one
7 * or more contributor license agreements. See the NOTICE file
8 * distributed with this work for additional information
9 * regarding copyright ownership. The ASF licenses this file
10 * to you under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
21 */
22 /*
23 * $Id: ToHTMLStream.java,v 1.2.4.1 2005/09/15 08:15:26 suresh_emailid Exp $
24 */
25 package com.sun.org.apache.xml.internal.serializer;
26
27 import java.io.IOException;
28 import java.io.OutputStream;
29 import java.io.UnsupportedEncodingException;
30 import java.util.Properties;
31
32 import javax.xml.transform.Result;
33
34 import com.sun.org.apache.xml.internal.serializer.utils.MsgKey;
35 import com.sun.org.apache.xml.internal.serializer.utils.Utils;
36 import org.xml.sax.Attributes;
37 import org.xml.sax.SAXException;
38
39 /**
40 * This serializer takes a series of SAX or
41 * SAX-like events and writes its output
42 * to the given stream.
43 *
44 * This class is not a public API, it is public
45 * because it is used from another package.
46 *
47 * @xsl.usage internal
48 */
49 public final class ToHTMLStream extends ToStream
50 {
51
52 /** This flag is set while receiving events from the DTD */
53 protected boolean m_inDTD = false;
54
55 /** True if the current element is a block element. (seems like
56 * this needs to be a stack. -sb). */
57 private boolean m_inBlockElem = false;
58
59 /**
60 * Map that tells which XML characters should have special treatment, and it
61 * provides character to entity name lookup.
62 */
63 private static final CharInfo m_htmlcharInfo =
64 // new CharInfo(CharInfo.HTML_ENTITIES_RESOURCE);
65 CharInfo.getCharInfoInternal(CharInfo.HTML_ENTITIES_RESOURCE, Method.HTML);
66
67 /** A digital search trie for fast, case insensitive lookup of ElemDesc objects. */
68 static final Trie m_elementFlags = new Trie();
69
70 static {
71 initTagReference(m_elementFlags);
72 }
73 static void initTagReference(Trie m_elementFlags) {
74
75 // HTML 4.0 loose DTD
76 m_elementFlags.put("BASEFONT", new ElemDesc(0 | ElemDesc.EMPTY));
77 m_elementFlags.put(
78 "FRAME",
79 new ElemDesc(0 | ElemDesc.EMPTY | ElemDesc.BLOCK));
80 m_elementFlags.put("FRAMESET", new ElemDesc(0 | ElemDesc.BLOCK));
81 m_elementFlags.put("NOFRAMES", new ElemDesc(0 | ElemDesc.BLOCK));
82 m_elementFlags.put(
83 "ISINDEX",
84 new ElemDesc(0 | ElemDesc.EMPTY | ElemDesc.BLOCK));
85 m_elementFlags.put(
86 "APPLET",
87 new ElemDesc(0 | ElemDesc.WHITESPACESENSITIVE));
88 m_elementFlags.put("CENTER", new ElemDesc(0 | ElemDesc.BLOCK));
89 m_elementFlags.put("DIR", new ElemDesc(0 | ElemDesc.BLOCK));
90 m_elementFlags.put("MENU", new ElemDesc(0 | ElemDesc.BLOCK));
91
92 // HTML 4.0 strict DTD
93 m_elementFlags.put("TT", new ElemDesc(0 | ElemDesc.FONTSTYLE));
94 m_elementFlags.put("I", new ElemDesc(0 | ElemDesc.FONTSTYLE));
95 m_elementFlags.put("B", new ElemDesc(0 | ElemDesc.FONTSTYLE));
96 m_elementFlags.put("BIG", new ElemDesc(0 | ElemDesc.FONTSTYLE));
97 m_elementFlags.put("SMALL", new ElemDesc(0 | ElemDesc.FONTSTYLE));
98 m_elementFlags.put("EM", new ElemDesc(0 | ElemDesc.PHRASE));
99 m_elementFlags.put("STRONG", new ElemDesc(0 | ElemDesc.PHRASE));
100 m_elementFlags.put("DFN", new ElemDesc(0 | ElemDesc.PHRASE));
101 m_elementFlags.put("CODE", new ElemDesc(0 | ElemDesc.PHRASE));
102 m_elementFlags.put("SAMP", new ElemDesc(0 | ElemDesc.PHRASE));
103 m_elementFlags.put("KBD", new ElemDesc(0 | ElemDesc.PHRASE));
104 m_elementFlags.put("VAR", new ElemDesc(0 | ElemDesc.PHRASE));
105 m_elementFlags.put("CITE", new ElemDesc(0 | ElemDesc.PHRASE));
106 m_elementFlags.put("ABBR", new ElemDesc(0 | ElemDesc.PHRASE));
107 m_elementFlags.put("ACRONYM", new ElemDesc(0 | ElemDesc.PHRASE));
108 m_elementFlags.put(
109 "SUP",
110 new ElemDesc(0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL));
111 m_elementFlags.put(
112 "SUB",
113 new ElemDesc(0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL));
114 m_elementFlags.put(
115 "SPAN",
116 new ElemDesc(0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL));
117 m_elementFlags.put(
118 "BDO",
119 new ElemDesc(0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL));
120 m_elementFlags.put(
121 "BR",
122 new ElemDesc(
123 0
124 | ElemDesc.SPECIAL
125 | ElemDesc.ASPECIAL
126 | ElemDesc.EMPTY
127 | ElemDesc.BLOCK));
128 m_elementFlags.put("BODY", new ElemDesc(0 | ElemDesc.BLOCK));
129 m_elementFlags.put(
130 "ADDRESS",
131 new ElemDesc(
132 0
133 | ElemDesc.BLOCK
134 | ElemDesc.BLOCKFORM
135 | ElemDesc.BLOCKFORMFIELDSET));
136 m_elementFlags.put(
137 "DIV",
138 new ElemDesc(
139 0
140 | ElemDesc.BLOCK
141 | ElemDesc.BLOCKFORM
142 | ElemDesc.BLOCKFORMFIELDSET));
143 m_elementFlags.put("A", new ElemDesc(0 | ElemDesc.SPECIAL));
144 m_elementFlags.put(
145 "MAP",
146 new ElemDesc(
147 0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL | ElemDesc.BLOCK));
148 m_elementFlags.put(
149 "AREA",
150 new ElemDesc(0 | ElemDesc.EMPTY | ElemDesc.BLOCK));
151 m_elementFlags.put(
152 "LINK",
153 new ElemDesc(
154 0 | ElemDesc.HEADMISC | ElemDesc.EMPTY | ElemDesc.BLOCK));
155 m_elementFlags.put(
156 "IMG",
157 new ElemDesc(
158 0
159 | ElemDesc.SPECIAL
160 | ElemDesc.ASPECIAL
161 | ElemDesc.EMPTY
162 | ElemDesc.WHITESPACESENSITIVE));
163 m_elementFlags.put(
164 "OBJECT",
165 new ElemDesc(
166 0
167 | ElemDesc.SPECIAL
168 | ElemDesc.ASPECIAL
169 | ElemDesc.HEADMISC
170 | ElemDesc.WHITESPACESENSITIVE));
171 m_elementFlags.put("PARAM", new ElemDesc(0 | ElemDesc.EMPTY));
172 m_elementFlags.put(
173 "HR",
174 new ElemDesc(
175 0
176 | ElemDesc.BLOCK
177 | ElemDesc.BLOCKFORM
178 | ElemDesc.BLOCKFORMFIELDSET
179 | ElemDesc.EMPTY));
180 m_elementFlags.put(
181 "P",
182 new ElemDesc(
183 0
184 | ElemDesc.BLOCK
185 | ElemDesc.BLOCKFORM
186 | ElemDesc.BLOCKFORMFIELDSET));
187 m_elementFlags.put(
188 "H1",
189 new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));
190 m_elementFlags.put(
191 "H2",
192 new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));
193 m_elementFlags.put(
194 "H3",
195 new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));
196 m_elementFlags.put(
197 "H4",
198 new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));
199 m_elementFlags.put(
200 "H5",
201 new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));
202 m_elementFlags.put(
203 "H6",
204 new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));
205 m_elementFlags.put(
206 "PRE",
207 new ElemDesc(0 | ElemDesc.PREFORMATTED | ElemDesc.BLOCK));
208 m_elementFlags.put(
209 "Q",
210 new ElemDesc(0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL));
211 m_elementFlags.put(
212 "BLOCKQUOTE",
213 new ElemDesc(
214 0
215 | ElemDesc.BLOCK
216 | ElemDesc.BLOCKFORM
217 | ElemDesc.BLOCKFORMFIELDSET));
218 m_elementFlags.put("INS", new ElemDesc(0));
219 m_elementFlags.put("DEL", new ElemDesc(0));
220 m_elementFlags.put(
221 "DL",
222 new ElemDesc(
223 0
224 | ElemDesc.BLOCK
225 | ElemDesc.BLOCKFORM
226 | ElemDesc.BLOCKFORMFIELDSET));
227 m_elementFlags.put("DT", new ElemDesc(0 | ElemDesc.BLOCK));
228 m_elementFlags.put("DD", new ElemDesc(0 | ElemDesc.BLOCK));
229 m_elementFlags.put(
230 "OL",
231 new ElemDesc(0 | ElemDesc.LIST | ElemDesc.BLOCK));
232 m_elementFlags.put(
233 "UL",
234 new ElemDesc(0 | ElemDesc.LIST | ElemDesc.BLOCK));
235 m_elementFlags.put("LI", new ElemDesc(0 | ElemDesc.BLOCK));
236 m_elementFlags.put("FORM", new ElemDesc(0 | ElemDesc.BLOCK));
237 m_elementFlags.put("LABEL", new ElemDesc(0 | ElemDesc.FORMCTRL));
238 m_elementFlags.put(
239 "INPUT",
240 new ElemDesc(
241 0 | ElemDesc.FORMCTRL | ElemDesc.INLINELABEL | ElemDesc.EMPTY));
242 m_elementFlags.put(
243 "SELECT",
244 new ElemDesc(0 | ElemDesc.FORMCTRL | ElemDesc.INLINELABEL));
245 m_elementFlags.put("OPTGROUP", new ElemDesc(0));
246 m_elementFlags.put("OPTION", new ElemDesc(0));
247 m_elementFlags.put(
248 "TEXTAREA",
249 new ElemDesc(0 | ElemDesc.FORMCTRL | ElemDesc.INLINELABEL));
250 m_elementFlags.put(
251 "FIELDSET",
252 new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM));
253 m_elementFlags.put("LEGEND", new ElemDesc(0));
254 m_elementFlags.put(
255 "BUTTON",
256 new ElemDesc(0 | ElemDesc.FORMCTRL | ElemDesc.INLINELABEL));
257 m_elementFlags.put(
258 "TABLE",
259 new ElemDesc(
260 0
261 | ElemDesc.BLOCK
262 | ElemDesc.BLOCKFORM
263 | ElemDesc.BLOCKFORMFIELDSET));
264 m_elementFlags.put("CAPTION", new ElemDesc(0 | ElemDesc.BLOCK));
265 m_elementFlags.put("THEAD", new ElemDesc(0 | ElemDesc.BLOCK));
266 m_elementFlags.put("TFOOT", new ElemDesc(0 | ElemDesc.BLOCK));
267 m_elementFlags.put("TBODY", new ElemDesc(0 | ElemDesc.BLOCK));
268 m_elementFlags.put("COLGROUP", new ElemDesc(0 | ElemDesc.BLOCK));
269 m_elementFlags.put(
270 "COL",
271 new ElemDesc(0 | ElemDesc.EMPTY | ElemDesc.BLOCK));
272 m_elementFlags.put("TR", new ElemDesc(0 | ElemDesc.BLOCK));
273 m_elementFlags.put("TH", new ElemDesc(0));
274 m_elementFlags.put("TD", new ElemDesc(0));
275 m_elementFlags.put(
276 "HEAD",
277 new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.HEADELEM));
278 m_elementFlags.put("TITLE", new ElemDesc(0 | ElemDesc.BLOCK));
279 m_elementFlags.put(
280 "BASE",
281 new ElemDesc(0 | ElemDesc.EMPTY | ElemDesc.BLOCK));
282 m_elementFlags.put(
283 "META",
284 new ElemDesc(
285 0 | ElemDesc.HEADMISC | ElemDesc.EMPTY | ElemDesc.BLOCK));
286 m_elementFlags.put(
287 "STYLE",
288 new ElemDesc(
289 0 | ElemDesc.HEADMISC | ElemDesc.RAW | ElemDesc.BLOCK));
290 m_elementFlags.put(
291 "SCRIPT",
292 new ElemDesc(
293 0
294 | ElemDesc.SPECIAL
295 | ElemDesc.ASPECIAL
296 | ElemDesc.HEADMISC
297 | ElemDesc.RAW));
298 m_elementFlags.put(
299 "NOSCRIPT",
300 new ElemDesc(
301 0
302 | ElemDesc.BLOCK
303 | ElemDesc.BLOCKFORM
304 | ElemDesc.BLOCKFORMFIELDSET));
305 m_elementFlags.put("HTML", new ElemDesc(0 | ElemDesc.BLOCK));
306
307 // From "John Ky" <hand@syd.speednet.com.au
308 // Transitional Document Type Definition ()
309 // file:///C:/Documents%20and%20Settings/sboag.BOAG600E/My%20Documents/html/sgml/loosedtd.html#basefont
310 m_elementFlags.put("FONT", new ElemDesc(0 | ElemDesc.FONTSTYLE));
311
312 // file:///C:/Documents%20and%20Settings/sboag.BOAG600E/My%20Documents/html/present/graphics.html#edef-STRIKE
313 m_elementFlags.put("S", new ElemDesc(0 | ElemDesc.FONTSTYLE));
314 m_elementFlags.put("STRIKE", new ElemDesc(0 | ElemDesc.FONTSTYLE));
315
316 // file:///C:/Documents%20and%20Settings/sboag.BOAG600E/My%20Documents/html/present/graphics.html#edef-U
317 m_elementFlags.put("U", new ElemDesc(0 | ElemDesc.FONTSTYLE));
318
319 // From "John Ky" <hand@syd.speednet.com.au
320 m_elementFlags.put("NOBR", new ElemDesc(0 | ElemDesc.FONTSTYLE));
321
322 // HTML 4.0, section 16.5
323 m_elementFlags.put(
324 "IFRAME",
325 new ElemDesc(
326 0
327 | ElemDesc.BLOCK
328 | ElemDesc.BLOCKFORM
329 | ElemDesc.BLOCKFORMFIELDSET));
330
331 // Netscape 4 extension
332 m_elementFlags.put(
333 "LAYER",
334 new ElemDesc(
335 0
336 | ElemDesc.BLOCK
337 | ElemDesc.BLOCKFORM
338 | ElemDesc.BLOCKFORMFIELDSET));
339 // Netscape 4 extension
340 m_elementFlags.put(
341 "ILAYER",
342 new ElemDesc(
343 0
344 | ElemDesc.BLOCK
345 | ElemDesc.BLOCKFORM
346 | ElemDesc.BLOCKFORMFIELDSET));
347
348
349 // NOW FOR ATTRIBUTE INFORMATION . . .
350 ElemDesc elemDesc;
351
352
353 // ----------------------------------------------
354 elemDesc = (ElemDesc) m_elementFlags.get("a");
355 elemDesc.setAttr("HREF", ElemDesc.ATTRURL);
356 elemDesc.setAttr("NAME", ElemDesc.ATTRURL);
357
358 // ----------------------------------------------
359 elemDesc = (ElemDesc) m_elementFlags.get("area");
360 elemDesc.setAttr("HREF", ElemDesc.ATTRURL);
361 elemDesc.setAttr("NOHREF", ElemDesc.ATTREMPTY);
362
363 // ----------------------------------------------
364 elemDesc = (ElemDesc) m_elementFlags.get("base");
365 elemDesc.setAttr("HREF", ElemDesc.ATTRURL);
366
367 // ----------------------------------------------
368 elemDesc = (ElemDesc) m_elementFlags.get("button");
369 elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
370
371 // ----------------------------------------------
372 elemDesc = (ElemDesc) m_elementFlags.get("blockquote");
373 elemDesc.setAttr("CITE", ElemDesc.ATTRURL);
374
375 // ----------------------------------------------
376 elemDesc = (ElemDesc) m_elementFlags.get("del");
377 elemDesc.setAttr("CITE", ElemDesc.ATTRURL);
378
379 // ----------------------------------------------
380 elemDesc = (ElemDesc) m_elementFlags.get("dir");
381 elemDesc.setAttr("COMPACT", ElemDesc.ATTREMPTY);
382
383 // ----------------------------------------------
384
385 elemDesc = (ElemDesc) m_elementFlags.get("div");
386 elemDesc.setAttr("SRC", ElemDesc.ATTRURL); // Netscape 4 extension
387 elemDesc.setAttr("NOWRAP", ElemDesc.ATTREMPTY); // Internet-Explorer extension
388
389 // ----------------------------------------------
390 elemDesc = (ElemDesc) m_elementFlags.get("dl");
391 elemDesc.setAttr("COMPACT", ElemDesc.ATTREMPTY);
392
393 // ----------------------------------------------
394 elemDesc = (ElemDesc) m_elementFlags.get("form");
395 elemDesc.setAttr("ACTION", ElemDesc.ATTRURL);
396
397 // ----------------------------------------------
398 // Attribution to: "Voytenko, Dimitry" <DVoytenko@SECTORBASE.COM>
399 elemDesc = (ElemDesc) m_elementFlags.get("frame");
400 elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
401 elemDesc.setAttr("LONGDESC", ElemDesc.ATTRURL);
402 elemDesc.setAttr("NORESIZE",ElemDesc.ATTREMPTY);
403
404 // ----------------------------------------------
405 elemDesc = (ElemDesc) m_elementFlags.get("head");
406 elemDesc.setAttr("PROFILE", ElemDesc.ATTRURL);
407
408 // ----------------------------------------------
409 elemDesc = (ElemDesc) m_elementFlags.get("hr");
410 elemDesc.setAttr("NOSHADE", ElemDesc.ATTREMPTY);
411
412 // ----------------------------------------------
413 // HTML 4.0, section 16.5
414 elemDesc = (ElemDesc) m_elementFlags.get("iframe");
415 elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
416 elemDesc.setAttr("LONGDESC", ElemDesc.ATTRURL);
417
418 // ----------------------------------------------
419 // Netscape 4 extension
420 elemDesc = (ElemDesc) m_elementFlags.get("ilayer");
421 elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
422
423 // ----------------------------------------------
424 elemDesc = (ElemDesc) m_elementFlags.get("img");
425 elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
426 elemDesc.setAttr("LONGDESC", ElemDesc.ATTRURL);
427 elemDesc.setAttr("USEMAP", ElemDesc.ATTRURL);
428 elemDesc.setAttr("ISMAP", ElemDesc.ATTREMPTY);
429
430 // ----------------------------------------------
431 elemDesc = (ElemDesc) m_elementFlags.get("input");
432 elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
433 elemDesc.setAttr("USEMAP", ElemDesc.ATTRURL);
434 elemDesc.setAttr("CHECKED", ElemDesc.ATTREMPTY);
435 elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
436 elemDesc.setAttr("ISMAP", ElemDesc.ATTREMPTY);
437 elemDesc.setAttr("READONLY", ElemDesc.ATTREMPTY);
438
439 // ----------------------------------------------
440 elemDesc = (ElemDesc) m_elementFlags.get("ins");
441 elemDesc.setAttr("CITE", ElemDesc.ATTRURL);
442
443 // ----------------------------------------------
444 // Netscape 4 extension
445 elemDesc = (ElemDesc) m_elementFlags.get("layer");
446 elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
447
448 // ----------------------------------------------
449 elemDesc = (ElemDesc) m_elementFlags.get("link");
450 elemDesc.setAttr("HREF", ElemDesc.ATTRURL);
451
452 // ----------------------------------------------
453 elemDesc = (ElemDesc) m_elementFlags.get("menu");
454 elemDesc.setAttr("COMPACT", ElemDesc.ATTREMPTY);
455
456 // ----------------------------------------------
457 elemDesc = (ElemDesc) m_elementFlags.get("object");
458 elemDesc.setAttr("CLASSID", ElemDesc.ATTRURL);
459 elemDesc.setAttr("CODEBASE", ElemDesc.ATTRURL);
460 elemDesc.setAttr("DATA", ElemDesc.ATTRURL);
461 elemDesc.setAttr("ARCHIVE", ElemDesc.ATTRURL);
462 elemDesc.setAttr("USEMAP", ElemDesc.ATTRURL);
463 elemDesc.setAttr("DECLARE", ElemDesc.ATTREMPTY);
464
465 // ----------------------------------------------
466 elemDesc = (ElemDesc) m_elementFlags.get("ol");
467 elemDesc.setAttr("COMPACT", ElemDesc.ATTREMPTY);
468
469 // ----------------------------------------------
470 elemDesc = (ElemDesc) m_elementFlags.get("optgroup");
471 elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
472
473 // ----------------------------------------------
474 elemDesc = (ElemDesc) m_elementFlags.get("option");
475 elemDesc.setAttr("SELECTED", ElemDesc.ATTREMPTY);
476 elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
477
478 // ----------------------------------------------
479 elemDesc = (ElemDesc) m_elementFlags.get("q");
480 elemDesc.setAttr("CITE", ElemDesc.ATTRURL);
481
482 // ----------------------------------------------
483 elemDesc = (ElemDesc) m_elementFlags.get("script");
484 elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
485 elemDesc.setAttr("FOR", ElemDesc.ATTRURL);
486 elemDesc.setAttr("DEFER", ElemDesc.ATTREMPTY);
487
488 // ----------------------------------------------
489 elemDesc = (ElemDesc) m_elementFlags.get("select");
490 elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
491 elemDesc.setAttr("MULTIPLE", ElemDesc.ATTREMPTY);
492
493 // ----------------------------------------------
494 elemDesc = (ElemDesc) m_elementFlags.get("table");
495 elemDesc.setAttr("NOWRAP", ElemDesc.ATTREMPTY); // Internet-Explorer extension
496
497 // ----------------------------------------------
498 elemDesc = (ElemDesc) m_elementFlags.get("td");
499 elemDesc.setAttr("NOWRAP", ElemDesc.ATTREMPTY);
500
501 // ----------------------------------------------
502 elemDesc = (ElemDesc) m_elementFlags.get("textarea");
503 elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
504 elemDesc.setAttr("READONLY", ElemDesc.ATTREMPTY);
505
506 // ----------------------------------------------
507 elemDesc = (ElemDesc) m_elementFlags.get("th");
508 elemDesc.setAttr("NOWRAP", ElemDesc.ATTREMPTY);
509
510 // ----------------------------------------------
511 // The nowrap attribute of a tr element is both
512 // a Netscape and Internet-Explorer extension
513 elemDesc = (ElemDesc) m_elementFlags.get("tr");
514 elemDesc.setAttr("NOWRAP", ElemDesc.ATTREMPTY);
515
516 // ----------------------------------------------
517 elemDesc = (ElemDesc) m_elementFlags.get("ul");
518 elemDesc.setAttr("COMPACT", ElemDesc.ATTREMPTY);
519 }
520
521 /**
522 * Dummy element for elements not found.
523 */
524 static private final ElemDesc m_dummy = new ElemDesc(0 | ElemDesc.BLOCK);
525
526 /** True if URLs should be specially escaped with the %xx form. */
527 private boolean m_specialEscapeURLs = true;
528
529 /** True if the META tag should be omitted. */
530 private boolean m_omitMetaTag = false;
531
532 /**
533 * Tells if the formatter should use special URL escaping.
534 *
535 * @param bool True if URLs should be specially escaped with the %xx form.
536 */
537 public void setSpecialEscapeURLs(boolean bool)
538 {
539 m_specialEscapeURLs = bool;
540 }
541
542 /**
543 * Tells if the formatter should omit the META tag.
544 *
545 * @param bool True if the META tag should be omitted.
546 */
547 public void setOmitMetaTag(boolean bool)
548 {
549 m_omitMetaTag = bool;
550 }
551
552 /**
553 * Specifies an output format for this serializer. It the
554 * serializer has already been associated with an output format,
555 * it will switch to the new format. This method should not be
556 * called while the serializer is in the process of serializing
557 * a document.
558 *
559 * This method can be called multiple times before starting
560 * the serialization of a particular result-tree. In principle
561 * all serialization parameters can be changed, with the exception
562 * of method="html" (it must be method="html" otherwise we
563 * shouldn't even have a ToHTMLStream object here!)
564 *
565 * @param format The output format or serialzation parameters
566 * to use.
567 */
568 public void setOutputFormat(Properties format)
569 {
570
571 m_specialEscapeURLs =
572 OutputPropertyUtils.getBooleanProperty(
573 OutputPropertiesFactory.S_USE_URL_ESCAPING,
574 format);
575
576 m_omitMetaTag =
577 OutputPropertyUtils.getBooleanProperty(
578 OutputPropertiesFactory.S_OMIT_META_TAG,
579 format);
580
581 super.setOutputFormat(format);
582 }
583
584 /**
585 * Tells if the formatter should use special URL escaping.
586 *
587 * @return True if URLs should be specially escaped with the %xx form.
588 */
589 private final boolean getSpecialEscapeURLs()
590 {
591 return m_specialEscapeURLs;
592 }
593
594 /**
595 * Tells if the formatter should omit the META tag.
596 *
597 * @return True if the META tag should be omitted.
598 */
599 private final boolean getOmitMetaTag()
600 {
601 return m_omitMetaTag;
602 }
603
604 /**
605 * Get a description of the given element.
606 *
607 * @param name non-null name of element, case insensitive.
608 *
609 * @return non-null reference to ElemDesc, which may be m_dummy if no
610 * element description matches the given name.
611 */
612 public static final ElemDesc getElemDesc(String name)
613 {
614 /* this method used to return m_dummy when name was null
615 * but now it doesn't check and and requires non-null name.
616 */
617 Object obj = m_elementFlags.get(name);
618 if (null != obj)
619 return (ElemDesc)obj;
620 return m_dummy;
621 }
622
623 /**
624 * A Trie that is just a copy of the "static" one.
625 * We need this one to be able to use the faster, but not thread-safe
626 * method Trie.get2(name)
627 */
628 private Trie m_htmlInfo = new Trie(m_elementFlags);
629 /**
630 * Calls to this method could be replaced with calls to
631 * getElemDesc(name), but this one should be faster.
632 */
633 private ElemDesc getElemDesc2(String name)
634 {
635 Object obj = m_htmlInfo.get2(name);
636 if (null != obj)
637 return (ElemDesc)obj;
638 return m_dummy;
639 }
640
641 /**
642 * Default constructor.
643 */
644 public ToHTMLStream()
645 {
646
647 super();
648 m_charInfo = m_htmlcharInfo;
649 // initialize namespaces
650 m_prefixMap = new NamespaceMappings();
651
652 }
653
654 /** The name of the current element. */
655 // private String m_currentElementName = null;
656
657 /**
658 * Receive notification of the beginning of a document.
659 *
660 * @throws org.xml.sax.SAXException Any SAX exception, possibly
661 * wrapping another exception.
662 *
663 * @throws org.xml.sax.SAXException
664 */
665 protected void startDocumentInternal() throws org.xml.sax.SAXException
666 {
667 super.startDocumentInternal();
668
669 m_needToCallStartDocument = false;
670 m_needToOutputDocTypeDecl = true;
671 m_startNewLine = false;
672 setOmitXMLDeclaration(true);
673
674 if (true == m_needToOutputDocTypeDecl)
675 {
676 String doctypeSystem = getDoctypeSystem();
677 String doctypePublic = getDoctypePublic();
678 if ((null != doctypeSystem) || (null != doctypePublic))
679 {
680 final java.io.Writer writer = m_writer;
681 try
682 {
683 writer.write("<!DOCTYPE html");
684
685 if (null != doctypePublic)
686 {
687 writer.write(" PUBLIC \"");
688 writer.write(doctypePublic);
689 writer.write('"');
690 }
691
692 if (null != doctypeSystem)
693 {
694 if (null == doctypePublic)
695 writer.write(" SYSTEM \"");
696 else
697 writer.write(" \"");
698
699 writer.write(doctypeSystem);
700 writer.write('"');
701 }
702
703 writer.write('>');
704 outputLineSep();
705 }
706 catch(IOException e)
707 {
708 throw new SAXException(e);
709 }
710 }
711 }
712
713 m_needToOutputDocTypeDecl = false;
714 }
715
716 /**
717 * Receive notification of the end of a document.
718 *
719 * @throws org.xml.sax.SAXException Any SAX exception, possibly
720 * wrapping another exception.
721 *
722 * @throws org.xml.sax.SAXException
723 */
724 public final void endDocument() throws org.xml.sax.SAXException
725 {
726
727 flushPending();
728 if (m_doIndent && !m_isprevtext)
729 {
730 try
731 {
732 outputLineSep();
733 }
734 catch(IOException e)
735 {
736 throw new SAXException(e);
737 }
738 }
739
740 flushWriter();
741 if (m_tracer != null)
742 super.fireEndDoc();
743 }
744
745 /**
746 * Receive notification of the beginning of an element.
747 *
748 *
749 * @param namespaceURI
750 * @param localName
751 * @param name The element type name.
752 * @param atts The attributes attached to the element, if any.
753 * @throws org.xml.sax.SAXException Any SAX exception, possibly
754 * wrapping another exception.
755 * @see #endElement
756 * @see org.xml.sax.AttributeList
757 */
758 public void startElement(
759 String namespaceURI,
760 String localName,
761 String name,
762 Attributes atts)
763 throws org.xml.sax.SAXException
764 {
765
766 ElemContext elemContext = m_elemContext;
767
768 // clean up any pending things first
769 if (elemContext.m_startTagOpen)
770 {
771 closeStartTag();
772 elemContext.m_startTagOpen = false;
773 }
774 else if (m_cdataTagOpen)
775 {
776 closeCDATA();
777 m_cdataTagOpen = false;
778 }
779 else if (m_needToCallStartDocument)
780 {
781 startDocumentInternal();
782 m_needToCallStartDocument = false;
783 }
784
785
786 // if this element has a namespace then treat it like XML
787 if (null != namespaceURI && namespaceURI.length() > 0)
788 {
789 super.startElement(namespaceURI, localName, name, atts);
790
791 return;
792 }
793
794 try
795 {
796 // getElemDesc2(name) is faster than getElemDesc(name)
797 ElemDesc elemDesc = getElemDesc2(name);
798 int elemFlags = elemDesc.getFlags();
799
800 // deal with indentation issues first
801 if (m_doIndent)
802 {
803
804 boolean isBlockElement = (elemFlags & ElemDesc.BLOCK) != 0;
805 if (m_ispreserve)
806 m_ispreserve = false;
807 else if (
808 (null != elemContext.m_elementName)
809 && (!m_inBlockElem
810 || isBlockElement) /* && !isWhiteSpaceSensitive */
811 )
812 {
813 m_startNewLine = true;
814
815 indent();
816
817 }
818 m_inBlockElem = !isBlockElement;
819 }
820
821 // save any attributes for later processing
822 if (atts != null)
823 addAttributes(atts);
824
825 m_isprevtext = false;
826 final java.io.Writer writer = m_writer;
827 writer.write('<');
828 writer.write(name);
829
830
831
832 if (m_tracer != null)
833 firePseudoAttributes();
834
835 if ((elemFlags & ElemDesc.EMPTY) != 0)
836 {
837 // an optimization for elements which are expected
838 // to be empty.
839 m_elemContext = elemContext.push();
840 /* XSLTC sometimes calls namespaceAfterStartElement()
841 * so we need to remember the name
842 */
843 m_elemContext.m_elementName = name;
844 m_elemContext.m_elementDesc = elemDesc;
845 return;
846 }
847 else
848 {
849 elemContext = elemContext.push(namespaceURI,localName,name);
850 m_elemContext = elemContext;
851 elemContext.m_elementDesc = elemDesc;
852 elemContext.m_isRaw = (elemFlags & ElemDesc.RAW) != 0;
853 }
854
855
856 if ((elemFlags & ElemDesc.HEADELEM) != 0)
857 {
858 // This is the <HEAD> element, do some special processing
859 closeStartTag();
860 elemContext.m_startTagOpen = false;
861 if (!m_omitMetaTag)
862 {
863 if (m_doIndent)
864 indent();
865 writer.write(
866 "<META http-equiv=\"Content-Type\" content=\"text/html; charset=");
867 String encoding = getEncoding();
868 String encode = Encodings.getMimeEncoding(encoding);
869 writer.write(encode);
870 writer.write("\">");
871 }
872 }
873 }
874 catch (IOException e)
875 {
876 throw new SAXException(e);
877 }
878 }
879
880 /**
881 * Receive notification of the end of an element.
882 *
883 *
884 * @param namespaceURI
885 * @param localName
886 * @param name The element type name
887 * @throws org.xml.sax.SAXException Any SAX exception, possibly
888 * wrapping another exception.
889 */
890 public final void endElement(
891 final String namespaceURI,
892 final String localName,
893 final String name)
894 throws org.xml.sax.SAXException
895 {
896 // deal with any pending issues
897 if (m_cdataTagOpen)
898 closeCDATA();
899
900 // if the element has a namespace, treat it like XML, not HTML
901 if (null != namespaceURI && namespaceURI.length() > 0)
902 {
903 super.endElement(namespaceURI, localName, name);
904
905 return;
906 }
907
908 try
909 {
910
911 ElemContext elemContext = m_elemContext;
912 final ElemDesc elemDesc = elemContext.m_elementDesc;
913 final int elemFlags = elemDesc.getFlags();
914 final boolean elemEmpty = (elemFlags & ElemDesc.EMPTY) != 0;
915
916 // deal with any indentation issues
917 if (m_doIndent)
918 {
919 final boolean isBlockElement = (elemFlags&ElemDesc.BLOCK) != 0;
920 boolean shouldIndent = false;
921
922 if (m_ispreserve)
923 {
924 m_ispreserve = false;
925 }
926 else if (m_doIndent && (!m_inBlockElem || isBlockElement))
927 {
928 m_startNewLine = true;
929 shouldIndent = true;
930 }
931 if (!elemContext.m_startTagOpen && shouldIndent)
932 indent(elemContext.m_currentElemDepth - 1);
933 m_inBlockElem = !isBlockElement;
934 }
935
936 final java.io.Writer writer = m_writer;
937 if (!elemContext.m_startTagOpen)
938 {
939 writer.write("</");
940 writer.write(name);
941 writer.write('>');
942 }
943 else
944 {
945 // the start-tag open when this method was called,
946 // so we need to process it now.
947
948 if (m_tracer != null)
949 super.fireStartElem(name);
950
951 // the starting tag was still open when we received this endElement() call
952 // so we need to process any gathered attributes NOW, before they go away.
953 int nAttrs = m_attributes.getLength();
954 if (nAttrs > 0)
955 {
956 processAttributes(m_writer, nAttrs);
957 // clear attributes object for re-use with next element
958 m_attributes.clear();
959 }
960 if (!elemEmpty)
961 {
962 // As per Dave/Paul recommendation 12/06/2000
963 // if (shouldIndent)
964 // writer.write('>');
965 // indent(m_currentIndent);
966
967 writer.write("></");
968 writer.write(name);
969 writer.write('>');
970 }
971 else
972 {
973 writer.write('>');
974 }
975 }
976
977 // clean up because the element has ended
978 if ((elemFlags & ElemDesc.WHITESPACESENSITIVE) != 0)
979 m_ispreserve = true;
980 m_isprevtext = false;
981
982 // fire off the end element event
983 if (m_tracer != null)
984 super.fireEndElem(name);
985
986 // OPTIMIZE-EMPTY
987 if (elemEmpty)
988 {
989 // a quick exit if the HTML element had no children.
990 // This block of code can be removed if the corresponding block of code
991 // in startElement() also labeled with "OPTIMIZE-EMPTY" is also removed
992 m_elemContext = elemContext.m_prev;
993 return;
994 }
995
996 // some more clean because the element has ended.
997 if (!elemContext.m_startTagOpen)
998 {
999 if (m_doIndent && !m_preserves.isEmpty())
1000 m_preserves.pop();
1001 }
1002 m_elemContext = elemContext.m_prev;
1003 // m_isRawStack.pop();
1004 }
1005 catch (IOException e)
1006 {
1007 throw new SAXException(e);
1008 }
1009 }
1010
1011 /**
1012 * Process an attribute.
1013 * @param writer The writer to write the processed output to.
1014 * @param name The name of the attribute.
1015 * @param value The value of the attribute.
1016 * @param elemDesc The description of the HTML element
1017 * that has this attribute.
1018 *
1019 * @throws org.xml.sax.SAXException
1020 */
1021 protected void processAttribute(
1022 java.io.Writer writer,
1023 String name,
1024 String value,
1025 ElemDesc elemDesc)
1026 throws IOException
1027 {
1028 writer.write(' ');
1029
1030 if ( ((value.length() == 0) || value.equalsIgnoreCase(name))
1031 && elemDesc != null
1032 && elemDesc.isAttrFlagSet(name, ElemDesc.ATTREMPTY))
1033 {
1034 writer.write(name);
1035 }
1036 else
1037 {
1038 // %REVIEW% %OPT%
1039 // Two calls to single-char write may NOT
1040 // be more efficient than one to string-write...
1041 writer.write(name);
1042 writer.write("=\"");
1043 if ( elemDesc != null
1044 && elemDesc.isAttrFlagSet(name, ElemDesc.ATTRURL))
1045 writeAttrURI(writer, value, m_specialEscapeURLs);
1046 else
1047 writeAttrString(writer, value, this.getEncoding());
1048 writer.write('"');
1049
1050 }
1051 }
1052
1053 /**
1054 * Tell if a character is an ASCII digit.
1055 */
1056 private boolean isASCIIDigit(char c)
1057 {
1058 return (c >= '0' && c <= '9');
1059 }
1060
1061 /**
1062 * Make an integer into an HH hex value.
1063 * Does no checking on the size of the input, since this
1064 * is only meant to be used locally by writeAttrURI.
1065 *
1066 * @param i must be a value less than 255.
1067 *
1068 * @return should be a two character string.
1069 */
1070 private static String makeHHString(int i)
1071 {
1072 String s = Integer.toHexString(i).toUpperCase();
1073 if (s.length() == 1)
1074 {
1075 s = "0" + s;
1076 }
1077 return s;
1078 }
1079
1080 /**
1081 * Dmitri Ilyin: Makes sure if the String is HH encoded sign.
1082 * @param str must be 2 characters long
1083 *
1084 * @return true or false
1085 */
1086 private boolean isHHSign(String str)
1087 {
1088 boolean sign = true;
1089 try
1090 {
1091 char r = (char) Integer.parseInt(str, 16);
1092 }
1093 catch (NumberFormatException e)
1094 {
1095 sign = false;
1096 }
1097 return sign;
1098 }
1099
1100 /**
1101 * Write the specified <var>string</var> after substituting non ASCII characters,
1102 * with <CODE>%HH</CODE>, where HH is the hex of the byte value.
1103 *
1104 * @param string String to convert to XML format.
1105 * @param doURLEscaping True if we should try to encode as
1106 * per http://www.ietf.org/rfc/rfc2396.txt.
1107 *
1108 * @throws org.xml.sax.SAXException if a bad surrogate pair is detected.
1109 */
1110 public void writeAttrURI(
1111 final java.io.Writer writer, String string, boolean doURLEscaping)
1112 throws IOException
1113 {
1114 // http://www.ietf.org/rfc/rfc2396.txt says:
1115 // A URI is always in an "escaped" form, since escaping or unescaping a
1116 // completed URI might change its semantics. Normally, the only time
1117 // escape encodings can safely be made is when the URI is being created
1118 // from its component parts; each component may have its own set of
1119 // characters that are reserved, so only the mechanism responsible for
1120 // generating or interpreting that component can determine whether or
1121 // not escaping a character will change its semantics. Likewise, a URI
1122 // must be separated into its components before the escaped characters
1123 // within those components can be safely decoded.
1124 //
1125 // ...So we do our best to do limited escaping of the URL, without
1126 // causing damage. If the URL is already properly escaped, in theory, this
1127 // function should not change the string value.
1128
1129 final int end = string.length();
1130 if (end > m_attrBuff.length)
1131 {
1132 m_attrBuff = new char[end*2 + 1];
1133 }
1134 string.getChars(0,end, m_attrBuff, 0);
1135 final char[] chars = m_attrBuff;
1136
1137 int cleanStart = 0;
1138 int cleanLength = 0;
1139
1140
1141 char ch = 0;
1142 for (int i = 0; i < end; i++)
1143 {
1144 ch = chars[i];
1145
1146 if ((ch < 32) || (ch > 126))
1147 {
1148 if (cleanLength > 0)
1149 {
1150 writer.write(chars, cleanStart, cleanLength);
1151 cleanLength = 0;
1152 }
1153 if (doURLEscaping)
1154 {
1155 // Encode UTF16 to UTF8.
1156 // Reference is Unicode, A Primer, by Tony Graham.
1157 // Page 92.
1158
1159 // Note that Kay doesn't escape 0x20...
1160 // if(ch == 0x20) // Not sure about this... -sb
1161 // {
1162 // writer.write(ch);
1163 // }
1164 // else
1165 if (ch <= 0x7F)
1166 {
1167 writer.write('%');
1168 writer.write(makeHHString(ch));
1169 }
1170 else if (ch <= 0x7FF)
1171 {
1172 // Clear low 6 bits before rotate, put high 4 bits in low byte,
1173 // and set two high bits.
1174 int high = (ch >> 6) | 0xC0;
1175 int low = (ch & 0x3F) | 0x80;
1176 // First 6 bits, + high bit
1177 writer.write('%');
1178 writer.write(makeHHString(high));
1179 writer.write('%');
1180 writer.write(makeHHString(low));
1181 }
1182 else if (Encodings.isHighUTF16Surrogate(ch)) // high surrogate
1183 {
1184 // I'm sure this can be done in 3 instructions, but I choose
1185 // to try and do it exactly like it is done in the book, at least
1186 // until we are sure this is totally clean. I don't think performance
1187 // is a big issue with this particular function, though I could be
1188 // wrong. Also, the stuff below clearly does more masking than
1189 // it needs to do.
1190
1191 // Clear high 6 bits.
1192 int highSurrogate = ((int) ch) & 0x03FF;
1193
1194 // Middle 4 bits (wwww) + 1
1195 // "Note that the value of wwww from the high surrogate bit pattern
1196 // is incremented to make the uuuuu bit pattern in the scalar value
1197 // so the surrogate pair don't address the BMP."
1198 int wwww = ((highSurrogate & 0x03C0) >> 6);
1199 int uuuuu = wwww + 1;
1200
1201 // next 4 bits
1202 int zzzz = (highSurrogate & 0x003C) >> 2;
1203
1204 // low 2 bits
1205 int yyyyyy = ((highSurrogate & 0x0003) << 4) & 0x30;
1206
1207 // Get low surrogate character.
1208 ch = chars[++i];
1209
1210 // Clear high 6 bits.
1211 int lowSurrogate = ((int) ch) & 0x03FF;
1212
1213 // put the middle 4 bits into the bottom of yyyyyy (byte 3)
1214 yyyyyy = yyyyyy | ((lowSurrogate & 0x03C0) >> 6);
1215
1216 // bottom 6 bits.
1217 int xxxxxx = (lowSurrogate & 0x003F);
1218
1219 int byte1 = 0xF0 | (uuuuu >> 2); // top 3 bits of uuuuu
1220 int byte2 =
1221 0x80 | (((uuuuu & 0x03) << 4) & 0x30) | zzzz;
1222 int byte3 = 0x80 | yyyyyy;
1223 int byte4 = 0x80 | xxxxxx;
1224
1225 writer.write('%');
1226 writer.write(makeHHString(byte1));
1227 writer.write('%');
1228 writer.write(makeHHString(byte2));
1229 writer.write('%');
1230 writer.write(makeHHString(byte3));
1231 writer.write('%');
1232 writer.write(makeHHString(byte4));
1233 }
1234 else
1235 {
1236 int high = (ch >> 12) | 0xE0; // top 4 bits
1237 int middle = ((ch & 0x0FC0) >> 6) | 0x80;
1238 // middle 6 bits
1239 int low = (ch & 0x3F) | 0x80;
1240 // First 6 bits, + high bit
1241 writer.write('%');
1242 writer.write(makeHHString(high));
1243 writer.write('%');
1244 writer.write(makeHHString(middle));
1245 writer.write('%');
1246 writer.write(makeHHString(low));
1247 }
1248
1249 }
1250 else if (escapingNotNeeded(ch))
1251 {
1252 writer.write(ch);
1253 }
1254 else
1255 {
1256 writer.write("&#");
1257 writer.write(Integer.toString(ch));
1258 writer.write(';');
1259 }
1260 // In this character range we have first written out any previously accumulated
1261 // "clean" characters, then processed the current more complicated character,
1262 // which may have incremented "i".
1263 // We now we reset the next possible clean character.
1264 cleanStart = i + 1;
1265 }
1266 // Since http://www.ietf.org/rfc/rfc2396.txt refers to the URI grammar as
1267 // not allowing quotes in the URI proper syntax, nor in the fragment
1268 // identifier, we believe that it's OK to double escape quotes.
1269 else if (ch == '"')
1270 {
1271 // If the character is a '%' number number, try to avoid double-escaping.
1272 // There is a question if this is legal behavior.
1273
1274 // Dmitri Ilyin: to check if '%' number number is invalid. It must be checked if %xx is a sign, that would be encoded
1275 // The encoded signes are in Hex form. So %xx my be in form %3C that is "<" sign. I will try to change here a little.
1276
1277 // if( ((i+2) < len) && isASCIIDigit(stringArray[i+1]) && isASCIIDigit(stringArray[i+2]) )
1278
1279 // We are no longer escaping '%'
1280
1281 if (cleanLength > 0)
1282 {
1283 writer.write(chars, cleanStart, cleanLength);
1284 cleanLength = 0;
1285 }
1286
1287
1288 // Mike Kay encodes this as ", so he may know something I don't?
1289 if (doURLEscaping)
1290 writer.write("%22");
1291 else
1292 writer.write("""); // we have to escape this, I guess.
1293
1294 // We have written out any clean characters, then the escaped '%' and now we
1295 // We now we reset the next possible clean character.
1296 cleanStart = i + 1;
1297 }
1298 else if (ch == '&')
1299 {
1300 // HTML 4.01 reads, "Authors should use "&" (ASCII decimal 38)
1301 // instead of "&" to avoid confusion with the beginning of a character
1302 // reference (entity reference open delimiter).
1303 if (cleanLength > 0)
1304 {
1305 writer.write(chars, cleanStart, cleanLength);
1306 cleanLength = 0;
1307 }
1308 writer.write("&");
1309 cleanStart = i + 1;
1310 }
1311 else
1312 {
1313 // no processing for this character, just count how
1314 // many characters in a row that we have that need no processing
1315 cleanLength++;
1316 }
1317 }
1318
1319 // are there any clean characters at the end of the array
1320 // that we haven't processed yet?
1321 if (cleanLength > 1)
1322 {
1323 // if the whole string can be written out as-is do so
1324 // otherwise write out the clean chars at the end of the
1325 // array
1326 if (cleanStart == 0)
1327 writer.write(string);
1328 else
1329 writer.write(chars, cleanStart, cleanLength);
1330 }
1331 else if (cleanLength == 1)
1332 {
1333 // a little optimization for 1 clean character
1334 // (we could have let the previous if(...) handle them all)
1335 writer.write(ch);
1336 }
1337 }
1338
1339 /**
1340 * Writes the specified <var>string</var> after substituting <VAR>specials</VAR>,
1341 * and UTF-16 surrogates for character references <CODE>&#xnn</CODE>.
1342 *
1343 * @param string String to convert to XML format.
1344 * @param encoding CURRENTLY NOT IMPLEMENTED.
1345 *
1346 * @throws org.xml.sax.SAXException
1347 */
1348 public void writeAttrString(
1349 final java.io.Writer writer, String string, String encoding)
1350 throws IOException
1351 {
1352 final int end = string.length();
1353 if (end > m_attrBuff.length)
1354 {
1355 m_attrBuff = new char[end * 2 + 1];
1356 }
1357 string.getChars(0, end, m_attrBuff, 0);
1358 final char[] chars = m_attrBuff;
1359
1360
1361
1362 int cleanStart = 0;
1363 int cleanLength = 0;
1364
1365 char ch = 0;
1366 for (int i = 0; i < end; i++)
1367 {
1368 ch = chars[i];
1369
1370 // System.out.println("SPECIALSSIZE: "+SPECIALSSIZE);
1371 // System.out.println("ch: "+(int)ch);
1372 // System.out.println("m_maxCharacter: "+(int)m_maxCharacter);
1373 // System.out.println("m_attrCharsMap[ch]: "+(int)m_attrCharsMap[ch]);
1374 if (escapingNotNeeded(ch) && (!m_charInfo.isSpecialAttrChar(ch)))
1375 {
1376 cleanLength++;
1377 }
1378 else if ('<' == ch || '>' == ch)
1379 {
1380 cleanLength++; // no escaping in this case, as specified in 15.2
1381 }
1382 else if (
1383 ('&' == ch) && ((i + 1) < end) && ('{' == chars[i + 1]))
1384 {
1385 cleanLength++; // no escaping in this case, as specified in 15.2
1386 }
1387 else
1388 {
1389 if (cleanLength > 0)
1390 {
1391 writer.write(chars,cleanStart,cleanLength);
1392 cleanLength = 0;
1393 }
1394 int pos = accumDefaultEntity(writer, ch, i, chars, end, false, true);
1395
1396 if (i != pos)
1397 {
1398 i = pos - 1;
1399 }
1400 else
1401 {
1402 if (Encodings.isHighUTF16Surrogate(ch))
1403 {
1404
1405 writeUTF16Surrogate(ch, chars, i, end);
1406 i++; // two input characters processed
1407 // this increments by one and the for()
1408 // loop itself increments by another one.
1409 }
1410
1411 // The next is kind of a hack to keep from escaping in the case
1412 // of Shift_JIS and the like.
1413
1414 /*
1415 else if ((ch < m_maxCharacter) && (m_maxCharacter == 0xFFFF)
1416 && (ch != 160))
1417 {
1418 writer.write(ch); // no escaping in this case
1419 }
1420 else
1421 */
1422 String outputStringForChar = m_charInfo.getOutputStringForChar(ch);
1423 if (null != outputStringForChar)
1424 {
1425 writer.write(outputStringForChar);
1426 }
1427 else if (escapingNotNeeded(ch))
1428 {
1429 writer.write(ch); // no escaping in this case
1430 }
1431 else
1432 {
1433 writer.write("&#");
1434 writer.write(Integer.toString(ch));
1435 writer.write(';');
1436 }
1437 }
1438 cleanStart = i + 1;
1439 }
1440 } // end of for()
1441
1442 // are there any clean characters at the end of the array
1443 // that we haven't processed yet?
1444 if (cleanLength > 1)
1445 {
1446 // if the whole string can be written out as-is do so
1447 // otherwise write out the clean chars at the end of the
1448 // array
1449 if (cleanStart == 0)
1450 writer.write(string);
1451 else
1452 writer.write(chars, cleanStart, cleanLength);
1453 }
1454 else if (cleanLength == 1)
1455 {
1456 // a little optimization for 1 clean character
1457 // (we could have let the previous if(...) handle them all)
1458 writer.write(ch);
1459 }
1460 }
1461
1462
1463
1464 /**
1465 * Receive notification of character data.
1466 *
1467 * <p>The Parser will call this method to report each chunk of
1468 * character data. SAX parsers may return all contiguous character
1469 * data in a single chunk, or they may split it into several
1470 * chunks; however, all of the characters in any single event
1471 * must come from the same external entity, so that the Locator
1472 * provides useful information.</p>
1473 *
1474 * <p>The application must not attempt to read from the array
1475 * outside of the specified range.</p>
1476 *
1477 * <p>Note that some parsers will report whitespace using the
1478 * ignorableWhitespace() method rather than this one (validating
1479 * parsers must do so).</p>
1480 *
1481 * @param chars The characters from the XML document.
1482 * @param start The start position in the array.
1483 * @param length The number of characters to read from the array.
1484 * @throws org.xml.sax.SAXException Any SAX exception, possibly
1485 * wrapping another exception.
1486 * @see #ignorableWhitespace
1487 * @see org.xml.sax.Locator
1488 *
1489 * @throws org.xml.sax.SAXException
1490 */
1491 public final void characters(char chars[], int start, int length)
1492 throws org.xml.sax.SAXException
1493 {
1494
1495 if (m_elemContext.m_isRaw)
1496 {
1497 try
1498 {
1499 if (m_elemContext.m_startTagOpen)
1500 {
1501 closeStartTag();
1502 m_elemContext.m_startTagOpen = false;
1503 }
1504 m_ispreserve = true;
1505
1506 // With m_ispreserve just set true it looks like shouldIndent()
1507 // will always return false, so drop any possible indentation.
1508 // if (shouldIndent())
1509 // indent();
1510
1511 // writer.write("<![CDATA[");
1512 // writer.write(chars, start, length);
1513 writeNormalizedChars(chars, start, length, false, m_lineSepUse);
1514
1515 // writer.write("]]>");
1516
1517 // time to generate characters event
1518 if (m_tracer != null)
1519 super.fireCharEvent(chars, start, length);
1520
1521 return;
1522 }
1523 catch (IOException ioe)
1524 {
1525 throw new org.xml.sax.SAXException(
1526 Utils.messages.createMessage(
1527 MsgKey.ER_OIERROR,
1528 null),
1529 ioe);
1530 //"IO error", ioe);
1531 }
1532 }
1533 else
1534 {
1535 super.characters(chars, start, length);
1536 }
1537 }
1538
1539 /**
1540 * Receive notification of cdata.
1541 *
1542 * <p>The Parser will call this method to report each chunk of
1543 * character data. SAX parsers may return all contiguous character
1544 * data in a single chunk, or they may split it into several
1545 * chunks; however, all of the characters in any single event
1546 * must come from the same external entity, so that the Locator
1547 * provides useful information.</p>
1548 *
1549 * <p>The application must not attempt to read from the array
1550 * outside of the specified range.</p>
1551 *
1552 * <p>Note that some parsers will report whitespace using the
1553 * ignorableWhitespace() method rather than this one (validating
1554 * parsers must do so).</p>
1555 *
1556 * @param ch The characters from the XML document.
1557 * @param start The start position in the array.
1558 * @param length The number of characters to read from the array.
1559 * @throws org.xml.sax.SAXException Any SAX exception, possibly
1560 * wrapping another exception.
1561 * @see #ignorableWhitespace
1562 * @see org.xml.sax.Locator
1563 *
1564 * @throws org.xml.sax.SAXException
1565 */
1566 public final void cdata(char ch[], int start, int length)
1567 throws org.xml.sax.SAXException
1568 {
1569
1570 if ((null != m_elemContext.m_elementName)
1571 && (m_elemContext.m_elementName.equalsIgnoreCase("SCRIPT")
1572 || m_elemContext.m_elementName.equalsIgnoreCase("STYLE")))
1573 {
1574 try
1575 {
1576 if (m_elemContext.m_startTagOpen)
1577 {
1578 closeStartTag();
1579 m_elemContext.m_startTagOpen = false;
1580 }
1581
1582 m_ispreserve = true;
1583
1584 if (shouldIndent())
1585 indent();
1586
1587 // writer.write(ch, start, length);
1588 writeNormalizedChars(ch, start, length, true, m_lineSepUse);
1589 }
1590 catch (IOException ioe)
1591 {
1592 throw new org.xml.sax.SAXException(
1593 Utils.messages.createMessage(
1594 MsgKey.ER_OIERROR,
1595 null),
1596 ioe);
1597 //"IO error", ioe);
1598 }
1599 }
1600 else
1601 {
1602 super.cdata(ch, start, length);
1603 }
1604 }
1605
1606 /**
1607 * Receive notification of a processing instruction.
1608 *
1609 * @param target The processing instruction target.
1610 * @param data The processing instruction data, or null if
1611 * none was supplied.
1612 * @throws org.xml.sax.SAXException Any SAX exception, possibly
1613 * wrapping another exception.
1614 *
1615 * @throws org.xml.sax.SAXException
1616 */
1617 public void processingInstruction(String target, String data)
1618 throws org.xml.sax.SAXException
1619 {
1620
1621 // Process any pending starDocument and startElement first.
1622 flushPending();
1623
1624 // Use a fairly nasty hack to tell if the next node is supposed to be
1625 // unescaped text.
1626 if (target.equals(Result.PI_DISABLE_OUTPUT_ESCAPING))
1627 {
1628 startNonEscaping();
1629 }
1630 else if (target.equals(Result.PI_ENABLE_OUTPUT_ESCAPING))
1631 {
1632 endNonEscaping();
1633 }
1634 else
1635 {
1636 try
1637 {
1638 if (m_elemContext.m_startTagOpen)
1639 {
1640 closeStartTag();
1641 m_elemContext.m_startTagOpen = false;
1642 }
1643 else if (m_needToCallStartDocument)
1644 startDocumentInternal();
1645
1646 if (shouldIndent())
1647 indent();
1648
1649 final java.io.Writer writer = m_writer;
1650 //writer.write("<?" + target);
1651 writer.write("<?");
1652 writer.write(target);
1653
1654 if (data.length() > 0 && !Character.isSpaceChar(data.charAt(0)))
1655 writer.write(' ');
1656
1657 //writer.write(data + ">"); // different from XML
1658 writer.write(data); // different from XML
1659 writer.write('>'); // different from XML
1660
1661 // Always output a newline char if not inside of an
1662 // element. The whitespace is not significant in that
1663 // case.
1664 if (m_elemContext.m_currentElemDepth <= 0)
1665 outputLineSep();
1666
1667 m_startNewLine = true;
1668 }
1669 catch(IOException e)
1670 {
1671 throw new SAXException(e);
1672 }
1673 }
1674
1675 // now generate the PI event
1676 if (m_tracer != null)
1677 super.fireEscapingEvent(target, data);
1678 }
1679
1680 /**
1681 * Receive notivication of a entityReference.
1682 *
1683 * @param name non-null reference to entity name string.
1684 *
1685 * @throws org.xml.sax.SAXException
1686 */
1687 public final void entityReference(String name)
1688 throws org.xml.sax.SAXException
1689 {
1690 try
1691 {
1692
1693 final java.io.Writer writer = m_writer;
1694 writer.write('&');
1695 writer.write(name);
1696 writer.write(';');
1697
1698 } catch(IOException e)
1699 {
1700 throw new SAXException(e);
1701 }
1702 }
1703 /**
1704 * @see ExtendedContentHandler#endElement(String)
1705 */
1706 public final void endElement(String elemName) throws SAXException
1707 {
1708 endElement(null, null, elemName);
1709 }
1710
1711 /**
1712 * Process the attributes, which means to write out the currently
1713 * collected attributes to the writer. The attributes are not
1714 * cleared by this method
1715 *
1716 * @param writer the writer to write processed attributes to.
1717 * @param nAttrs the number of attributes in m_attributes
1718 * to be processed
1719 *
1720 * @throws org.xml.sax.SAXException
1721 */
1722 public void processAttributes(java.io.Writer writer, int nAttrs)
1723 throws IOException,SAXException
1724 {
1725 /*
1726 * process the collected attributes
1727 */
1728 for (int i = 0; i < nAttrs; i++)
1729 {
1730 processAttribute(
1731 writer,
1732 m_attributes.getQName(i),
1733 m_attributes.getValue(i),
1734 m_elemContext.m_elementDesc);
1735 }
1736 }
1737
1738 /**
1739 * For the enclosing elements starting tag write out out any attributes
1740 * followed by ">"
1741 *
1742 *@throws org.xml.sax.SAXException
1743 */
1744 protected void closeStartTag() throws SAXException
1745 {
1746 try
1747 {
1748
1749 // finish processing attributes, time to fire off the start element event
1750 if (m_tracer != null)
1751 super.fireStartElem(m_elemContext.m_elementName);
1752
1753 int nAttrs = m_attributes.getLength();
1754 if (nAttrs>0)
1755 {
1756 processAttributes(m_writer, nAttrs);
1757 // clear attributes object for re-use with next element
1758 m_attributes.clear();
1759 }
1760
1761 m_writer.write('>');
1762
1763 /* whether Xalan or XSLTC, we have the prefix mappings now, so
1764 * lets determine if the current element is specified in the cdata-
1765 * section-elements list.
1766 */
1767 if (m_StringOfCDATASections != null)
1768 m_elemContext.m_isCdataSection = isCdataSection();
1769 if (m_doIndent)
1770 {
1771 m_isprevtext = false;
1772 m_preserves.push(m_ispreserve);
1773 }
1774
1775 }
1776 catch(IOException e)
1777 {
1778 throw new SAXException(e);
1779 }
1780 }
1781
1782 /**
1783 * This method is used when a prefix/uri namespace mapping
1784 * is indicated after the element was started with a
1785 * startElement() and before and endElement().
1786 * startPrefixMapping(prefix,uri) would be used before the
1787 * startElement() call.
1788 * @param uri the URI of the namespace
1789 * @param prefix the prefix associated with the given URI.
1790 *
1791 * @see ExtendedContentHandler#namespaceAfterStartElement(String, String)
1792 */
1793 public void namespaceAfterStartElement(String prefix, String uri)
1794 throws SAXException
1795 {
1796 // hack for XSLTC with finding URI for default namespace
1797 if (m_elemContext.m_elementURI == null)
1798 {
1799 String prefix1 = getPrefixPart(m_elemContext.m_elementName);
1800 if (prefix1 == null && EMPTYSTRING.equals(prefix))
1801 {
1802 // the elements URI is not known yet, and it
1803 // doesn't have a prefix, and we are currently
1804 // setting the uri for prefix "", so we have
1805 // the uri for the element... lets remember it
1806 m_elemContext.m_elementURI = uri;
1807 }
1808 }
1809 startPrefixMapping(prefix,uri,false);
1810 }
1811
1812 public void startDTD(String name, String publicId, String systemId)
1813 throws SAXException
1814 {
1815 m_inDTD = true;
1816 super.startDTD(name, publicId, systemId);
1817 }
1818
1819 /**
1820 * Report the end of DTD declarations.
1821 * @throws org.xml.sax.SAXException The application may raise an exception.
1822 * @see #startDTD
1823 */
1824 public void endDTD() throws org.xml.sax.SAXException
1825 {
1826 m_inDTD = false;
1827 /* for ToHTMLStream the DOCTYPE is entirely output in the
1828 * startDocumentInternal() method, so don't do anything here
1829 */
1830 }
1831 /**
1832 * This method does nothing.
1833 */
1834 public void attributeDecl(
1835 String eName,
1836 String aName,
1837 String type,
1838 String valueDefault,
1839 String value)
1840 throws SAXException
1841 {
1842 // The internal DTD subset is not serialized by the ToHTMLStream serializer
1843 }
1844
1845 /**
1846 * This method does nothing.
1847 */
1848 public void elementDecl(String name, String model) throws SAXException
1849 {
1850 // The internal DTD subset is not serialized by the ToHTMLStream serializer
1851 }
1852 /**
1853 * This method does nothing.
1854 */
1855 public void internalEntityDecl(String name, String value)
1856 throws SAXException
1857 {
1858 // The internal DTD subset is not serialized by the ToHTMLStream serializer
1859 }
1860 /**
1861 * This method does nothing.
1862 */
1863 public void externalEntityDecl(
1864 String name,
1865 String publicId,
1866 String systemId)
1867 throws SAXException
1868 {
1869 // The internal DTD subset is not serialized by the ToHTMLStream serializer
1870 }
1871
1872 /**
1873 * This method is used to add an attribute to the currently open element.
1874 * The caller has guaranted that this attribute is unique, which means that it
1875 * not been seen before and will not be seen again.
1876 *
1877 * @param name the qualified name of the attribute
1878 * @param value the value of the attribute which can contain only
1879 * ASCII printable characters characters in the range 32 to 127 inclusive.
1880 * @param flags the bit values of this integer give optimization information.
1881 */
1882 public void addUniqueAttribute(String name, String value, int flags)
1883 throws SAXException
1884 {
1885 try
1886 {
1887 final java.io.Writer writer = m_writer;
1888 if ((flags & NO_BAD_CHARS) > 0 && m_htmlcharInfo.onlyQuotAmpLtGt)
1889 {
1890 // "flags" has indicated that the characters
1891 // '>' '<' '&' and '"' are not in the value and
1892 // m_htmlcharInfo has recorded that there are no other
1893 // entities in the range 0 to 127 so we write out the
1894 // value directly
1895 writer.write(' ');
1896 writer.write(name);
1897 writer.write("=\"");
1898 writer.write(value);
1899 writer.write('"');
1900 }
1901 else if (
1902 (flags & HTML_ATTREMPTY) > 0
1903 && (value.length() == 0 || value.equalsIgnoreCase(name)))
1904 {
1905 writer.write(' ');
1906 writer.write(name);
1907 }
1908 else
1909 {
1910 writer.write(' ');
1911 writer.write(name);
1912 writer.write("=\"");
1913 if ((flags & HTML_ATTRURL) > 0)
1914 {
1915 writeAttrURI(writer, value, m_specialEscapeURLs);
1916 }
1917 else
1918 {
1919 writeAttrString(writer, value, this.getEncoding());
1920 }
1921 writer.write('"');
1922 }
1923 } catch (IOException e) {
1924 throw new SAXException(e);
1925 }
1926 }
1927
1928 public void comment(char ch[], int start, int length)
1929 throws SAXException
1930 {
1931 // The internal DTD subset is not serialized by the ToHTMLStream serializer
1932 if (m_inDTD)
1933 return;
1934 super.comment(ch, start, length);
1935 }
1936
1937 public boolean reset()
1938 {
1939 boolean ret = super.reset();
1940 if (!ret)
1941 return false;
1942 initToHTMLStream();
1943 return true;
1944 }
1945
1946 private void initToHTMLStream()
1947 {
1948 // m_elementDesc = null;
1949 m_inBlockElem = false;
1950 m_inDTD = false;
1951 // m_isRawStack.clear();
1952 m_omitMetaTag = false;
1953 m_specialEscapeURLs = true;
1954 }
1955
1956 static class Trie
1957 {
1958 /**
1959 * A digital search trie for 7-bit ASCII text
1960 * The API is a subset of java.util.Hashtable
1961 * The key must be a 7-bit ASCII string
1962 * The value may be any Java Object
1963 * One can get an object stored in a trie from its key,
1964 * but the search is either case sensitive or case
1965 * insensitive to the characters in the key, and this
1966 * choice of sensitivity or insensitivity is made when
1967 * the Trie is created, before any objects are put in it.
1968 *
1969 * This class is a copy of the one in com.sun.org.apache.xml.internal.utils.
1970 * It exists to cut the serializers dependancy on that package.
1971 *
1972 * @xsl.usage internal
1973 */
1974
1975 /** Size of the m_nextChar array. */
1976 public static final int ALPHA_SIZE = 128;
1977
1978 /** The root node of the tree. */
1979 final Node m_Root;
1980
1981 /** helper buffer to convert Strings to char arrays */
1982 private char[] m_charBuffer = new char[0];
1983
1984 /** true if the search for an object is lower case only with the key */
1985 private final boolean m_lowerCaseOnly;
1986
1987 /**
1988 * Construct the trie that has a case insensitive search.
1989 */
1990 public Trie()
1991 {
1992 m_Root = new Node();
1993 m_lowerCaseOnly = false;
1994 }
1995
1996 /**
1997 * Construct the trie given the desired case sensitivity with the key.
1998 * @param lowerCaseOnly true if the search keys are to be loser case only,
1999 * not case insensitive.
2000 */
2001 public Trie(boolean lowerCaseOnly)
2002 {
2003 m_Root = new Node();
2004 m_lowerCaseOnly = lowerCaseOnly;
2005 }
2006
2007 /**
2008 * Put an object into the trie for lookup.
2009 *
2010 * @param key must be a 7-bit ASCII string
2011 * @param value any java object.
2012 *
2013 * @return The old object that matched key, or null.
2014 */
2015 public Object put(String key, Object value)
2016 {
2017
2018 final int len = key.length();
2019 if (len > m_charBuffer.length)
2020 {
2021 // make the biggest buffer ever needed in get(String)
2022 m_charBuffer = new char[len];
2023 }
2024
2025 Node node = m_Root;
2026
2027 for (int i = 0; i < len; i++)
2028 {
2029 Node nextNode =
2030 node.m_nextChar[Character.toLowerCase(key.charAt(i))];
2031
2032 if (nextNode != null)
2033 {
2034 node = nextNode;
2035 }
2036 else
2037 {
2038 for (; i < len; i++)
2039 {
2040 Node newNode = new Node();
2041 if (m_lowerCaseOnly)
2042 {
2043 // put this value into the tree only with a lower case key
2044 node.m_nextChar[Character.toLowerCase(
2045 key.charAt(i))] =
2046 newNode;
2047 }
2048 else
2049 {
2050 // put this value into the tree with a case insensitive key
2051 node.m_nextChar[Character.toUpperCase(
2052 key.charAt(i))] =
2053 newNode;
2054 node.m_nextChar[Character.toLowerCase(
2055 key.charAt(i))] =
2056 newNode;
2057 }
2058 node = newNode;
2059 }
2060 break;
2061 }
2062 }
2063
2064 Object ret = node.m_Value;
2065
2066 node.m_Value = value;
2067
2068 return ret;
2069 }
2070
2071 /**
2072 * Get an object that matches the key.
2073 *
2074 * @param key must be a 7-bit ASCII string
2075 *
2076 * @return The object that matches the key, or null.
2077 */
2078 public Object get(final String key)
2079 {
2080
2081 final int len = key.length();
2082
2083 /* If the name is too long, we won't find it, this also keeps us
2084 * from overflowing m_charBuffer
2085 */
2086 if (m_charBuffer.length < len)
2087 return null;
2088
2089 Node node = m_Root;
2090 switch (len) // optimize the look up based on the number of chars
2091 {
2092 // case 0 looks silly, but the generated bytecode runs
2093 // faster for lookup of elements of length 2 with this in
2094 // and a fair bit faster. Don't know why.
2095 case 0 :
2096 {
2097 return null;
2098 }
2099
2100 case 1 :
2101 {
2102 final char ch = key.charAt(0);
2103 if (ch < ALPHA_SIZE)
2104 {
2105 node = node.m_nextChar[ch];
2106 if (node != null)
2107 return node.m_Value;
2108 }
2109 return null;
2110 }
2111 // comment out case 2 because the default is faster
2112 // case 2 :
2113 // {
2114 // final char ch0 = key.charAt(0);
2115 // final char ch1 = key.charAt(1);
2116 // if (ch0 < ALPHA_SIZE && ch1 < ALPHA_SIZE)
2117 // {
2118 // node = node.m_nextChar[ch0];
2119 // if (node != null)
2120 // {
2121 //
2122 // if (ch1 < ALPHA_SIZE)
2123 // {
2124 // node = node.m_nextChar[ch1];
2125 // if (node != null)
2126 // return node.m_Value;
2127 // }
2128 // }
2129 // }
2130 // return null;
2131 // }
2132 default :
2133 {
2134 for (int i = 0; i < len; i++)
2135 {
2136 // A thread-safe way to loop over the characters
2137 final char ch = key.charAt(i);
2138 if (ALPHA_SIZE <= ch)
2139 {
2140 // the key is not 7-bit ASCII so we won't find it here
2141 return null;
2142 }
2143
2144 node = node.m_nextChar[ch];
2145 if (node == null)
2146 return null;
2147 }
2148
2149 return node.m_Value;
2150 }
2151 }
2152 }
2153
2154 /**
2155 * The node representation for the trie.
2156 * @xsl.usage internal
2157 */
2158 private class Node
2159 {
2160
2161 /**
2162 * Constructor, creates a Node[ALPHA_SIZE].
2163 */
2164 Node()
2165 {
2166 m_nextChar = new Node[ALPHA_SIZE];
2167 m_Value = null;
2168 }
2169
2170 /** The next nodes. */
2171 final Node m_nextChar[];
2172
2173 /** The value. */
2174 Object m_Value;
2175 }
2176 /**
2177 * Construct the trie from another Trie.
2178 * Both the existing Trie and this new one share the same table for
2179 * lookup, and it is assumed that the table is fully populated and
2180 * not changing anymore.
2181 *
2182 * @param existingTrie the Trie that this one is a copy of.
2183 */
2184 public Trie(Trie existingTrie)
2185 {
2186 // copy some fields from the existing Trie into this one.
2187 m_Root = existingTrie.m_Root;
2188 m_lowerCaseOnly = existingTrie.m_lowerCaseOnly;
2189
2190 // get a buffer just big enough to hold the longest key in the table.
2191 int max = existingTrie.getLongestKeyLength();
2192 m_charBuffer = new char[max];
2193 }
2194
2195 /**
2196 * Get an object that matches the key.
2197 * This method is faster than get(), but is not thread-safe.
2198 *
2199 * @param key must be a 7-bit ASCII string
2200 *
2201 * @return The object that matches the key, or null.
2202 */
2203 public Object get2(final String key)
2204 {
2205
2206 final int len = key.length();
2207
2208 /* If the name is too long, we won't find it, this also keeps us
2209 * from overflowing m_charBuffer
2210 */
2211 if (m_charBuffer.length < len)
2212 return null;
2213
2214 Node node = m_Root;
2215 switch (len) // optimize the look up based on the number of chars
2216 {
2217 // case 0 looks silly, but the generated bytecode runs
2218 // faster for lookup of elements of length 2 with this in
2219 // and a fair bit faster. Don't know why.
2220 case 0 :
2221 {
2222 return null;
2223 }
2224
2225 case 1 :
2226 {
2227 final char ch = key.charAt(0);
2228 if (ch < ALPHA_SIZE)
2229 {
2230 node = node.m_nextChar[ch];
2231 if (node != null)
2232 return node.m_Value;
2233 }
2234 return null;
2235 }
2236 default :
2237 {
2238 /* Copy string into array. This is not thread-safe because
2239 * it modifies the contents of m_charBuffer. If multiple
2240 * threads were to use this Trie they all would be
2241 * using this same array (not good). So this
2242 * method is not thread-safe, but it is faster because
2243 * converting to a char[] and looping over elements of
2244 * the array is faster than a String's charAt(i).
2245 */
2246 key.getChars(0, len, m_charBuffer, 0);
2247
2248 for (int i = 0; i < len; i++)
2249 {
2250 final char ch = m_charBuffer[i];
2251 if (ALPHA_SIZE <= ch)
2252 {
2253 // the key is not 7-bit ASCII so we won't find it here
2254 return null;
2255 }
2256
2257 node = node.m_nextChar[ch];
2258 if (node == null)
2259 return null;
2260 }
2261
2262 return node.m_Value;
2263 }
2264 }
2265 }
2266
2267 /**
2268 * Get the length of the longest key used in the table.
2269 */
2270 public int getLongestKeyLength()
2271 {
2272 return m_charBuffer.length;
2273 }
2274 }
2275 }