1 /*
2 * Copyright (c) 2007, 2017, Oracle and/or its affiliates. All rights reserved.
3 */
4 /*
5 * Licensed to the Apache Software Foundation (ASF) under one or more
6 * contributor license agreements. See the NOTICE file distributed with
7 * this work for additional information regarding copyright ownership.
8 * The ASF licenses this file to You under the Apache License, Version 2.0
9 * (the "License"); you may not use this file except in compliance with
10 * the License. You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21 package com.sun.org.apache.xml.internal.dtm.ref.sax2dtm;
22
23 import com.sun.org.apache.xml.internal.dtm.DTM;
24 import com.sun.org.apache.xml.internal.dtm.DTMManager;
25 import com.sun.org.apache.xml.internal.dtm.DTMWSFilter;
26 import com.sun.org.apache.xml.internal.dtm.ref.DTMDefaultBaseIterators;
27 import com.sun.org.apache.xml.internal.dtm.ref.DTMManagerDefault;
28 import com.sun.org.apache.xml.internal.dtm.ref.DTMStringPool;
29 import com.sun.org.apache.xml.internal.dtm.ref.DTMTreeWalker;
30 import com.sun.org.apache.xml.internal.dtm.ref.IncrementalSAXSource;
31 import com.sun.org.apache.xml.internal.dtm.ref.NodeLocator;
32 import com.sun.org.apache.xml.internal.res.XMLErrorResources;
33 import com.sun.org.apache.xml.internal.res.XMLMessages;
34 import com.sun.org.apache.xml.internal.utils.FastStringBuffer;
35 import com.sun.org.apache.xml.internal.utils.IntStack;
36 import com.sun.org.apache.xml.internal.utils.IntVector;
37 import com.sun.org.apache.xml.internal.utils.StringVector;
38 import com.sun.org.apache.xml.internal.utils.SuballocatedIntVector;
39 import com.sun.org.apache.xml.internal.utils.SystemIDResolver;
40 import com.sun.org.apache.xml.internal.utils.WrappedRuntimeException;
41 import com.sun.org.apache.xml.internal.utils.XMLString;
42 import com.sun.org.apache.xml.internal.utils.XMLStringFactory;
43 import java.util.ArrayList;
44 import java.util.HashMap;
45 import java.util.List;
46 import java.util.Map;
47 import java.util.Vector;
48 import javax.xml.transform.Source;
49 import javax.xml.transform.SourceLocator;
50 import org.xml.sax.Attributes;
51 import org.xml.sax.ContentHandler;
52 import org.xml.sax.DTDHandler;
53 import org.xml.sax.EntityResolver;
54 import org.xml.sax.ErrorHandler;
55 import org.xml.sax.InputSource;
56 import org.xml.sax.Locator;
57 import org.xml.sax.SAXException;
58 import org.xml.sax.SAXParseException;
59 import org.xml.sax.ext.DeclHandler;
60 import org.xml.sax.ext.LexicalHandler;
61
62 /**
63 * This class implements a DTM that tends to be optimized more for speed than
64 * for compactness, that is constructed via SAX2 ContentHandler events.
65 *
66 * @LastModified: Oct 2017
67 */
68 public class SAX2DTM extends DTMDefaultBaseIterators
69 implements EntityResolver, DTDHandler, ContentHandler, ErrorHandler,
70 DeclHandler, LexicalHandler
71 {
72 /** Set true to monitor SAX events and similar diagnostic info. */
73 private static final boolean DEBUG = false;
74
75 /**
76 * If we're building the model incrementally on demand, we need to
77 * be able to tell the source when to send us more data.
78 *
79 * Note that if this has not been set, and you attempt to read ahead
80 * of the current build point, we'll probably throw a null-pointer
81 * exception. We could try to wait-and-retry instead, as a very poor
82 * fallback, but that has all the known problems with multithreading
83 * on multiprocessors and we Don't Want to Go There.
84 *
85 * @see setIncrementalSAXSource
86 */
87 private IncrementalSAXSource m_incrementalSAXSource = null;
88
89 /**
90 * All the character content, including attribute values, are stored in
91 * this buffer.
92 *
93 * %REVIEW% Should this have an option of being shared across DTMs?
94 * Sequentially only; not threadsafe... Currently, I think not.
95 *
96 * %REVIEW% Initial size was pushed way down to reduce weight of RTFs.
97 * pending reduction in number of RTF DTMs. Now that we're sharing a DTM
98 * between RTFs, and tail-pruning... consider going back to the larger/faster.
99 *
100 * Made protected rather than private so SAX2RTFDTM can access it.
101 */
102 protected FastStringBuffer m_chars;
103
104 /** This vector holds offset and length data.
105 */
106 protected SuballocatedIntVector m_data;
107
108 /** The parent stack, needed only for construction.
109 * Made protected rather than private so SAX2RTFDTM can access it.
110 */
111 transient protected IntStack m_parents;
112
113 /** The current previous node, needed only for construction time.
114 * Made protected rather than private so SAX2RTFDTM can access it.
115 */
116 transient protected int m_previous = 0;
117
118 /** Namespace support, only relevent at construction time.
119 * Made protected rather than private so SAX2RTFDTM can access it.
120 */
121 transient protected Vector<String> m_prefixMappings = new Vector<>();
122
123 /** Namespace support, only relevent at construction time.
124 * Made protected rather than private so SAX2RTFDTM can access it.
125 */
126 transient protected IntStack m_contextIndexes;
127
128 /** Type of next characters() event within text block in prgress. */
129 transient protected int m_textType = DTM.TEXT_NODE;
130
131 /**
132 * Type of coalesced text block. See logic in the characters()
133 * method.
134 */
135 transient protected int m_coalescedTextType = DTM.TEXT_NODE;
136
137 /** The SAX Document locator */
138 transient protected Locator m_locator = null;
139
140 /** The SAX Document system-id */
141 transient private String m_systemId = null;
142
143 /** We are inside the DTD. This is used for ignoring comments. */
144 transient protected boolean m_insideDTD = false;
145
146 /** Tree Walker for dispatchToEvents. */
147 protected DTMTreeWalker m_walker = new DTMTreeWalker();
148
149 /** pool of string values that come as strings. */
150 protected DTMStringPool m_valuesOrPrefixes;
151
152 /** End document has been reached.
153 * Made protected rather than private so SAX2RTFDTM can access it.
154 */
155 protected boolean m_endDocumentOccured = false;
156
157 /** Data or qualified name values, one array element for each node. */
158 protected SuballocatedIntVector m_dataOrQName;
159
160 /**
161 * This table holds the ID string to node associations, for
162 * XML IDs.
163 */
164 protected Map<String, Integer> m_idAttributes = new HashMap<>();
165
166 /**
167 * fixed dom-style names.
168 */
169 private static final String[] m_fixednames = { null,
170 null, // nothing, Element
171 null, "#text", // Attr, Text
172 "#cdata_section", null, // CDATA, EntityReference
173 null, null, // Entity, PI
174 "#comment", "#document", // Comment, Document
175 null, "#document-fragment", // Doctype, DocumentFragment
176 null }; // Notation
177
178 /**
179 * Vector of entities. Each record is composed of four Strings:
180 * publicId, systemID, notationName, and name.
181 */
182 private List<String> m_entities = null;
183
184 /** m_entities public ID offset. */
185 private static final int ENTITY_FIELD_PUBLICID = 0;
186
187 /** m_entities system ID offset. */
188 private static final int ENTITY_FIELD_SYSTEMID = 1;
189
190 /** m_entities notation name offset. */
191 private static final int ENTITY_FIELD_NOTATIONNAME = 2;
192
193 /** m_entities name offset. */
194 private static final int ENTITY_FIELD_NAME = 3;
195
196 /** Number of entries per record for m_entities. */
197 private static final int ENTITY_FIELDS_PER = 4;
198
199 /**
200 * The starting offset within m_chars for the text or
201 * CDATA_SECTION node currently being acumulated,
202 * or -1 if there is no text node in progress
203 */
204 protected int m_textPendingStart = -1;
205
206 /**
207 * Describes whether information about document source location
208 * should be maintained or not.
209 *
210 * Made protected for access by SAX2RTFDTM.
211 */
212 protected boolean m_useSourceLocationProperty = false;
213
214 /** Made protected for access by SAX2RTFDTM.
215 */
216 protected StringVector m_sourceSystemId;
217
218 /** Made protected for access by SAX2RTFDTM.
219 */
220 protected IntVector m_sourceLine;
221
222 /** Made protected for access by SAX2RTFDTM.
223 */
224 protected IntVector m_sourceColumn;
225
226 /**
227 * Construct a SAX2DTM object using the default block size.
228 *
229 * @param mgr The DTMManager who owns this DTM.
230 * @param source the JAXP 1.1 Source object for this DTM.
231 * @param dtmIdentity The DTM identity ID for this DTM.
232 * @param whiteSpaceFilter The white space filter for this DTM, which may
233 * be null.
234 * @param xstringfactory XMLString factory for creating character content.
235 * @param doIndexing true if the caller considers it worth it to use
236 * indexing schemes.
237 */
238 public SAX2DTM(DTMManager mgr, Source source, int dtmIdentity,
239 DTMWSFilter whiteSpaceFilter,
240 XMLStringFactory xstringfactory,
241 boolean doIndexing)
242 {
243
244 this(mgr, source, dtmIdentity, whiteSpaceFilter,
245 xstringfactory, doIndexing, DEFAULT_BLOCKSIZE, true, false);
246 }
247
248 /**
249 * Construct a SAX2DTM object ready to be constructed from SAX2
250 * ContentHandler events.
251 *
252 * @param mgr The DTMManager who owns this DTM.
253 * @param source the JAXP 1.1 Source object for this DTM.
254 * @param dtmIdentity The DTM identity ID for this DTM.
255 * @param whiteSpaceFilter The white space filter for this DTM, which may
256 * be null.
257 * @param xstringfactory XMLString factory for creating character content.
258 * @param doIndexing true if the caller considers it worth it to use
259 * indexing schemes.
260 * @param blocksize The block size of the DTM.
261 * @param usePrevsib true if we want to build the previous sibling node array.
262 * @param newNameTable true if we want to use a new ExpandedNameTable for this DTM.
263 */
264 public SAX2DTM(DTMManager mgr, Source source, int dtmIdentity,
265 DTMWSFilter whiteSpaceFilter,
266 XMLStringFactory xstringfactory,
267 boolean doIndexing,
268 int blocksize,
269 boolean usePrevsib,
270 boolean newNameTable)
271 {
272 super(mgr, source, dtmIdentity, whiteSpaceFilter,
273 xstringfactory, doIndexing, blocksize, usePrevsib, newNameTable);
274
275 // %OPT% Use smaller sizes for all internal storage units when
276 // the blocksize is small. This reduces the cost of creating an RTF.
277 if (blocksize <= 64) {
278 m_data = new SuballocatedIntVector(blocksize, DEFAULT_NUMBLOCKS_SMALL);
279 m_dataOrQName = new SuballocatedIntVector(blocksize, DEFAULT_NUMBLOCKS_SMALL);
280 m_valuesOrPrefixes = new DTMStringPool(16);
281 m_chars = new FastStringBuffer(7, 10);
282 m_contextIndexes = new IntStack(4);
283 m_parents = new IntStack(4);
284 } else {
285 m_data = new SuballocatedIntVector(blocksize, DEFAULT_NUMBLOCKS);
286 m_dataOrQName = new SuballocatedIntVector(blocksize, DEFAULT_NUMBLOCKS);
287 m_valuesOrPrefixes = new DTMStringPool();
288 m_chars = new FastStringBuffer(10, 13);
289 m_contextIndexes = new IntStack();
290 m_parents = new IntStack();
291 }
292
293 // %REVIEW% Initial size pushed way down to reduce weight of RTFs
294 // (I'm not entirely sure 0 would work, so I'm playing it safe for now.)
295 //m_data = new SuballocatedIntVector(doIndexing ? (1024*2) : 512, 1024);
296 //m_data = new SuballocatedIntVector(blocksize);
297
298 m_data.addElement(0); // Need placeholder in case index into here must be <0.
299
300 //m_dataOrQName = new SuballocatedIntVector(blocksize);
301
302 // m_useSourceLocationProperty=com.sun.org.apache.xalan.internal.processor.TransformerFactoryImpl.m_source_location;
303 m_useSourceLocationProperty = mgr.getSource_location();
304 m_sourceSystemId = (m_useSourceLocationProperty) ? new StringVector() : null;
305 m_sourceLine = (m_useSourceLocationProperty) ? new IntVector() : null;
306 m_sourceColumn = (m_useSourceLocationProperty) ? new IntVector() : null;
307 }
308
309 /**
310 * Set whether information about document source location
311 * should be maintained or not.
312 */
313 public void setUseSourceLocation(boolean useSourceLocation) {
314 m_useSourceLocationProperty = useSourceLocation;
315 }
316
317 /**
318 * Get the data or qualified name for the given node identity.
319 *
320 * @param identity The node identity.
321 *
322 * @return The data or qualified name, or DTM.NULL.
323 */
324 protected int _dataOrQName(int identity) {
325 if (identity < m_size)
326 return m_dataOrQName.elementAt(identity);
327
328 // Check to see if the information requested has been processed, and,
329 // if not, advance the iterator until we the information has been
330 // processed.
331 while (true) {
332 boolean isMore = nextNode();
333
334 if (!isMore)
335 return NULL;
336 else if (identity < m_size)
337 return m_dataOrQName.elementAt(identity);
338 }
339 }
340
341 /**
342 * Ask the CoRoutine parser to doTerminate and clear the reference.
343 */
344 public void clearCoRoutine() {
345 clearCoRoutine(true);
346 }
347
348 /**
349 * Ask the CoRoutine parser to doTerminate and clear the reference. If
350 * the CoRoutine parser has already been cleared, this will have no effect.
351 *
352 * @param callDoTerminate true of doTerminate should be called on the
353 * coRoutine parser.
354 */
355 public void clearCoRoutine(boolean callDoTerminate) {
356 if (null != m_incrementalSAXSource) {
357 if (callDoTerminate)
358 m_incrementalSAXSource.deliverMoreNodes(false);
359
360 m_incrementalSAXSource = null;
361 }
362 }
363
364 /**
365 * Bind a IncrementalSAXSource to this DTM. If we discover we need nodes
366 * that have not yet been built, we will ask this object to send us more
367 * events, and it will manage interactions with its data sources.
368 *
369 * Note that we do not actually build the IncrementalSAXSource, since we don't
370 * know what source it's reading from, what thread that source will run in,
371 * or when it will run.
372 *
373 * @param incrementalSAXSource The parser that we want to recieve events from
374 * on demand.
375 */
376 public void setIncrementalSAXSource(IncrementalSAXSource incrementalSAXSource) {
377 // Establish coroutine link so we can request more data
378 //
379 // Note: It's possible that some versions of IncrementalSAXSource may
380 // not actually use a CoroutineManager, and hence may not require
381 // that we obtain an Application Coroutine ID. (This relies on the
382 // coroutine transaction details having been encapsulated in the
383 // IncrementalSAXSource.do...() methods.)
384 m_incrementalSAXSource = incrementalSAXSource;
385
386 // Establish SAX-stream link so we can receive the requested data
387 incrementalSAXSource.setContentHandler(this);
388 incrementalSAXSource.setLexicalHandler(this);
389 incrementalSAXSource.setDTDHandler(this);
390
391 // Are the following really needed? incrementalSAXSource doesn't yet
392 // support them, and they're mostly no-ops here...
393 //incrementalSAXSource.setErrorHandler(this);
394 //incrementalSAXSource.setDeclHandler(this);
395 }
396
397 /**
398 * getContentHandler returns "our SAX builder" -- the thing that
399 * someone else should send SAX events to in order to extend this
400 * DTM model.
401 *
402 * %REVIEW% Should this return null if constrution already done/begun?
403 *
404 * @return null if this model doesn't respond to SAX events,
405 * "this" if the DTM object has a built-in SAX ContentHandler,
406 * the IncrementalSAXSource if we're bound to one and should receive
407 * the SAX stream via it for incremental build purposes...
408 *
409 * Note that IncrementalSAXSource_Filter is package private, hence
410 * it can be statically referenced using instanceof (CR 6537912).
411 */
412 public ContentHandler getContentHandler() {
413 if (m_incrementalSAXSource.getClass().getName()
414 .equals("com.sun.org.apache.xml.internal.dtm.ref.IncrementalSAXSource_Filter"))
415 return (ContentHandler) m_incrementalSAXSource;
416 else
417 return this;
418 }
419
420 /**
421 * Return this DTM's lexical handler.
422 *
423 * %REVIEW% Should this return null if constrution already done/begun?
424 *
425 * @return null if this model doesn't respond to lexical SAX events,
426 * "this" if the DTM object has a built-in SAX ContentHandler,
427 * the IncrementalSAXSource if we're bound to one and should receive
428 * the SAX stream via it for incremental build purposes...
429 *
430 * Note that IncrementalSAXSource_Filter is package private, hence
431 * it can be statically referenced using instanceof (CR 6537912).
432 */
433 public LexicalHandler getLexicalHandler() {
434 if (m_incrementalSAXSource.getClass().getName()
435 .equals("com.sun.org.apache.xml.internal.dtm.ref.IncrementalSAXSource_Filter"))
436 return (LexicalHandler) m_incrementalSAXSource;
437 else
438 return this;
439 }
440
441 /**
442 * Return this DTM's EntityResolver.
443 *
444 * @return null if this model doesn't respond to SAX entity ref events.
445 */
446 public EntityResolver getEntityResolver() {
447 return this;
448 }
449
450 /**
451 * Return this DTM's DTDHandler.
452 *
453 * @return null if this model doesn't respond to SAX dtd events.
454 */
455 public DTDHandler getDTDHandler() {
456 return this;
457 }
458
459 /**
460 * Return this DTM's ErrorHandler.
461 *
462 * @return null if this model doesn't respond to SAX error events.
463 */
464 public ErrorHandler getErrorHandler() {
465 return this;
466 }
467
468 /**
469 * Return this DTM's DeclHandler.
470 *
471 * @return null if this model doesn't respond to SAX Decl events.
472 */
473 public DeclHandler getDeclHandler() {
474 return this;
475 }
476
477 /**
478 * @return true iff we're building this model incrementally (eg
479 * we're partnered with a IncrementalSAXSource) and thus require that the
480 * transformation and the parse run simultaneously. Guidance to the
481 * DTMManager.
482 */
483 public boolean needsTwoThreads() {
484 return null != m_incrementalSAXSource;
485 }
486
487 /**
488 * Directly call the
489 * characters method on the passed ContentHandler for the
490 * string-value of the given node (see http://www.w3.org/TR/xpath#data-model
491 * for the definition of a node's string-value). Multiple calls to the
492 * ContentHandler's characters methods may well occur for a single call to
493 * this method.
494 *
495 * @param nodeHandle The node ID.
496 * @param ch A non-null reference to a ContentHandler.
497 * @param normalize true if the content should be normalized according to
498 * the rules for the XPath
499 * <a href="http://www.w3.org/TR/xpath#function-normalize-space">normalize-space</a>
500 * function.
501 *
502 * @throws SAXException
503 */
504 public void dispatchCharactersEvents(int nodeHandle, ContentHandler ch,
505 boolean normalize)
506 throws SAXException
507 {
508 int identity = makeNodeIdentity(nodeHandle);
509
510 if (identity == DTM.NULL)
511 return;
512
513 int type = _type(identity);
514
515 if (isTextType(type)) {
516 int dataIndex = m_dataOrQName.elementAt(identity);
517 int offset = m_data.elementAt(dataIndex);
518 int length = m_data.elementAt(dataIndex + 1);
519
520 if(normalize)
521 m_chars.sendNormalizedSAXcharacters(ch, offset, length);
522 else
523 m_chars.sendSAXcharacters(ch, offset, length);
524 } else {
525 int firstChild = _firstch(identity);
526
527 if (DTM.NULL != firstChild) {
528 int offset = -1;
529 int length = 0;
530 int startNode = identity;
531
532 identity = firstChild;
533
534 do {
535 type = _type(identity);
536
537 if (isTextType(type)) {
538 int dataIndex = _dataOrQName(identity);
539
540 if (-1 == offset) {
541 offset = m_data.elementAt(dataIndex);
542 }
543
544 length += m_data.elementAt(dataIndex + 1);
545 }
546
547 identity = getNextNodeIdentity(identity);
548 } while (DTM.NULL != identity && (_parent(identity) >= startNode));
549
550 if (length > 0) {
551 if(normalize)
552 m_chars.sendNormalizedSAXcharacters(ch, offset, length);
553 else
554 m_chars.sendSAXcharacters(ch, offset, length);
555 }
556 } else if(type != DTM.ELEMENT_NODE) {
557 int dataIndex = _dataOrQName(identity);
558
559 if (dataIndex < 0) {
560 dataIndex = -dataIndex;
561 dataIndex = m_data.elementAt(dataIndex + 1);
562 }
563
564 String str = m_valuesOrPrefixes.indexToString(dataIndex);
565
566 if(normalize)
567 FastStringBuffer.sendNormalizedSAXcharacters(str.toCharArray(),
568 0, str.length(), ch);
569 else
570 ch.characters(str.toCharArray(), 0, str.length());
571 }
572 }
573 }
574
575 /**
576 * Given a node handle, return its DOM-style node name. This will
577 * include names such as #text or #document.
578 *
579 * @param nodeHandle the id of the node.
580 * @return String Name of this node, which may be an empty string.
581 * %REVIEW% Document when empty string is possible...
582 * %REVIEW-COMMENT% It should never be empty, should it?
583 */
584 public String getNodeName(int nodeHandle) {
585 int expandedTypeID = getExpandedTypeID(nodeHandle);
586 // If just testing nonzero, no need to shift...
587 int namespaceID = m_expandedNameTable.getNamespaceID(expandedTypeID);
588
589 if (0 == namespaceID) {
590 // Don't retrieve name until/unless needed
591 // String name = m_expandedNameTable.getLocalName(expandedTypeID);
592 int type = getNodeType(nodeHandle);
593
594 if (type == DTM.NAMESPACE_NODE) {
595 if (null == m_expandedNameTable.getLocalName(expandedTypeID))
596 return "xmlns";
597 else
598 return "xmlns:" + m_expandedNameTable.getLocalName(expandedTypeID);
599 } else if (0 == m_expandedNameTable.getLocalNameID(expandedTypeID)) {
600 return m_fixednames[type];
601 } else
602 return m_expandedNameTable.getLocalName(expandedTypeID);
603 } else {
604 int qnameIndex = m_dataOrQName.elementAt(makeNodeIdentity(nodeHandle));
605
606 if (qnameIndex < 0) {
607 qnameIndex = -qnameIndex;
608 qnameIndex = m_data.elementAt(qnameIndex);
609 }
610
611 return m_valuesOrPrefixes.indexToString(qnameIndex);
612 }
613 }
614
615 /**
616 * Given a node handle, return the XPath node name. This should be
617 * the name as described by the XPath data model, NOT the DOM-style
618 * name.
619 *
620 * @param nodeHandle the id of the node.
621 * @return String Name of this node, which may be an empty string.
622 */
623 public String getNodeNameX(int nodeHandle) {
624 int expandedTypeID = getExpandedTypeID(nodeHandle);
625 int namespaceID = m_expandedNameTable.getNamespaceID(expandedTypeID);
626
627 if (namespaceID == 0) {
628 String name = m_expandedNameTable.getLocalName(expandedTypeID);
629
630 if (name == null)
631 return "";
632 else
633 return name;
634 } else {
635 int qnameIndex = m_dataOrQName.elementAt(makeNodeIdentity(nodeHandle));
636
637 if (qnameIndex < 0) {
638 qnameIndex = -qnameIndex;
639 qnameIndex = m_data.elementAt(qnameIndex);
640 }
641
642 return m_valuesOrPrefixes.indexToString(qnameIndex);
643 }
644 }
645
646 /**
647 * 5. [specified] A flag indicating whether this attribute was actually
648 * specified in the start-tag of its element, or was defaulted from the
649 * DTD.
650 *
651 * @param attributeHandle Must be a valid handle to an attribute node.
652 * @return <code>true</code> if the attribute was specified;
653 * <code>false</code> if it was defaulted.
654 */
655 public boolean isAttributeSpecified(int attributeHandle) {
656 // I'm not sure if I want to do anything with this...
657 return true; // ??
658 }
659
660 /**
661 * A document type declaration information item has the following properties:
662 *
663 * 1. [system identifier] The system identifier of the external subset, if
664 * it exists. Otherwise this property has no value.
665 *
666 * @return the system identifier String object, or null if there is none.
667 */
668 public String getDocumentTypeDeclarationSystemIdentifier() {
669 /** @todo: implement this com.sun.org.apache.xml.internal.dtm.DTMDefaultBase abstract method */
670 error(XMLMessages.createXMLMessage(XMLErrorResources.ER_METHOD_NOT_SUPPORTED, null));//"Not yet supported!");
671
672 return null;
673 }
674
675 /**
676 * Get the next node identity value in the list, and call the iterator
677 * if it hasn't been added yet.
678 *
679 * @param identity The node identity (index).
680 * @return identity+1, or DTM.NULL.
681 */
682 protected int getNextNodeIdentity(int identity) {
683 identity += 1;
684
685 while (identity >= m_size) {
686 if (m_incrementalSAXSource == null)
687 return DTM.NULL;
688
689 nextNode();
690 }
691
692 return identity;
693 }
694
695 /**
696 * Directly create SAX parser events from a subtree.
697 *
698 * @param nodeHandle The node ID.
699 * @param ch A non-null reference to a ContentHandler.
700 *
701 * @throws SAXException
702 */
703 public void dispatchToEvents(int nodeHandle, ContentHandler ch)
704 throws SAXException
705 {
706
707 DTMTreeWalker treeWalker = m_walker;
708 ContentHandler prevCH = treeWalker.getcontentHandler();
709
710 if (null != prevCH)
711 {
712 treeWalker = new DTMTreeWalker();
713 }
714
715 treeWalker.setcontentHandler(ch);
716 treeWalker.setDTM(this);
717
718 try
719 {
720 treeWalker.traverse(nodeHandle);
721 }
722 finally
723 {
724 treeWalker.setcontentHandler(null);
725 }
726 }
727
728 /**
729 * Get the number of nodes that have been added.
730 *
731 * @return The number of that are currently in the tree.
732 */
733 public int getNumberOfNodes()
734 {
735 return m_size;
736 }
737
738 /**
739 * This method should try and build one or more nodes in the table.
740 *
741 * @return The true if a next node is found or false if
742 * there are no more nodes.
743 */
744 protected boolean nextNode()
745 {
746
747 if (null == m_incrementalSAXSource)
748 return false;
749
750 if (m_endDocumentOccured)
751 {
752 clearCoRoutine();
753
754 return false;
755 }
756
757 Object gotMore = m_incrementalSAXSource.deliverMoreNodes(true);
758
759 // gotMore may be a Boolean (TRUE if still parsing, FALSE if
760 // EOF) or an exception if IncrementalSAXSource malfunctioned
761 // (code error rather than user error).
762 //
763 // %REVIEW% Currently the ErrorHandlers sketched herein are
764 // no-ops, so I'm going to initially leave this also as a
765 // no-op.
766 if (!(gotMore instanceof Boolean))
767 {
768 if(gotMore instanceof RuntimeException)
769 {
770 throw (RuntimeException)gotMore;
771 }
772 else if(gotMore instanceof Exception)
773 {
774 throw new WrappedRuntimeException((Exception)gotMore);
775 }
776 // for now...
777 clearCoRoutine();
778
779 return false;
780
781 // %TBD%
782 }
783
784 if (gotMore != Boolean.TRUE)
785 {
786
787 // EOF reached without satisfying the request
788 clearCoRoutine(); // Drop connection, stop trying
789
790 // %TBD% deregister as its listener?
791 }
792
793 return true;
794 }
795
796 /**
797 * Bottleneck determination of text type.
798 *
799 * @param type oneof DTM.XXX_NODE.
800 *
801 * @return true if this is a text or cdata section.
802 */
803 private final boolean isTextType(int type)
804 {
805 return (DTM.TEXT_NODE == type || DTM.CDATA_SECTION_NODE == type);
806 }
807
808 // /**
809 // * Ensure that the size of the information arrays can hold another entry
810 // * at the given index.
811 // *
812 // * @param on exit from this function, the information arrays sizes must be
813 // * at least index+1.
814 // *
815 // * NEEDSDOC @param index
816 // */
817 // protected void ensureSize(int index)
818 // {
819 // // dataOrQName is an SuballocatedIntVector and hence self-sizing.
820 // // But DTMDefaultBase may need fixup.
821 // super.ensureSize(index);
822 // }
823
824 /**
825 * Construct the node map from the node.
826 *
827 * @param type raw type ID, one of DTM.XXX_NODE.
828 * @param expandedTypeID The expended type ID.
829 * @param parentIndex The current parent index.
830 * @param previousSibling The previous sibling index.
831 * @param dataOrPrefix index into m_data table, or string handle.
832 * @param canHaveFirstChild true if the node can have a first child, false
833 * if it is atomic.
834 *
835 * @return The index identity of the node that was added.
836 */
837 protected int addNode(int type, int expandedTypeID,
838 int parentIndex, int previousSibling,
839 int dataOrPrefix, boolean canHaveFirstChild)
840 {
841 // Common to all nodes:
842 int nodeIndex = m_size++;
843
844 // Have we overflowed a DTM Identity's addressing range?
845 if(m_dtmIdent.size() == (nodeIndex>>>DTMManager.IDENT_DTM_NODE_BITS))
846 {
847 addNewDTMID(nodeIndex);
848 }
849
850 m_firstch.addElement(canHaveFirstChild ? NOTPROCESSED : DTM.NULL);
851 m_nextsib.addElement(NOTPROCESSED);
852 m_parent.addElement(parentIndex);
853 m_exptype.addElement(expandedTypeID);
854 m_dataOrQName.addElement(dataOrPrefix);
855
856 if (m_prevsib != null) {
857 m_prevsib.addElement(previousSibling);
858 }
859
860 if (DTM.NULL != previousSibling) {
861 m_nextsib.setElementAt(nodeIndex,previousSibling);
862 }
863
864 if (m_locator != null && m_useSourceLocationProperty) {
865 setSourceLocation();
866 }
867
868 // Note that nextSibling is not processed until charactersFlush()
869 // is called, to handle successive characters() events.
870
871 // Special handling by type: Declare namespaces, attach first child
872 switch(type)
873 {
874 case DTM.NAMESPACE_NODE:
875 declareNamespaceInContext(parentIndex,nodeIndex);
876 break;
877 case DTM.ATTRIBUTE_NODE:
878 break;
879 default:
880 if (DTM.NULL == previousSibling && DTM.NULL != parentIndex) {
881 m_firstch.setElementAt(nodeIndex,parentIndex);
882 }
883 break;
884 }
885
886 return nodeIndex;
887 }
888
889 /**
890 * Get a new DTM ID beginning at the specified node index.
891 * @param nodeIndex The node identity at which the new DTM ID will begin
892 * addressing.
893 */
894 protected void addNewDTMID(int nodeIndex) {
895 try
896 {
897 if(m_mgr==null)
898 throw new ClassCastException();
899
900 // Handle as Extended Addressing
901 DTMManagerDefault mgrD=(DTMManagerDefault)m_mgr;
902 int id=mgrD.getFirstFreeDTMID();
903 mgrD.addDTM(this,id,nodeIndex);
904 m_dtmIdent.addElement(id<<DTMManager.IDENT_DTM_NODE_BITS);
905 }
906 catch(ClassCastException e)
907 {
908 // %REVIEW% Wrong error message, but I've been told we're trying
909 // not to add messages right not for I18N reasons.
910 // %REVIEW% Should this be a Fatal Error?
911 error(XMLMessages.createXMLMessage(XMLErrorResources.ER_NO_DTMIDS_AVAIL, null));//"No more DTM IDs are available";
912 }
913 }
914
915 /**
916 * Migrate a DTM built with an old DTMManager to a new DTMManager.
917 * After the migration, the new DTMManager will treat the DTM as
918 * one that is built by itself.
919 * This is used to support DTM sharing between multiple transformations.
920 * @param manager the DTMManager
921 */
922 public void migrateTo(DTMManager manager) {
923 super.migrateTo(manager);
924
925 // We have to reset the information in m_dtmIdent and
926 // register the DTM with the new manager.
927 int numDTMs = m_dtmIdent.size();
928 int dtmId = m_mgrDefault.getFirstFreeDTMID();
929 int nodeIndex = 0;
930 for (int i = 0; i < numDTMs; i++)
931 {
932 m_dtmIdent.setElementAt(dtmId << DTMManager.IDENT_DTM_NODE_BITS, i);
933 m_mgrDefault.addDTM(this, dtmId, nodeIndex);
934 dtmId++;
935 nodeIndex += (1 << DTMManager.IDENT_DTM_NODE_BITS);
936 }
937 }
938
939 /**
940 * Store the source location of the current node. This method must be called
941 * as every node is added to the DTM or for no node.
942 */
943 protected void setSourceLocation() {
944 m_sourceSystemId.addElement(m_locator.getSystemId());
945 m_sourceLine.addElement(m_locator.getLineNumber());
946 m_sourceColumn.addElement(m_locator.getColumnNumber());
947
948 //%REVIEW% %BUG% Prevent this from arising in the first place
949 // by not allowing the enabling conditions to change after we start
950 // building the document.
951 if (m_sourceSystemId.size() != m_size) {
952 String msg = "CODING ERROR in Source Location: " + m_size + " != "
953 + m_sourceSystemId.size();
954 System.err.println(msg);
955 throw new RuntimeException(msg);
956 }
957 }
958
959 /**
960 * Given a node handle, return its node value. This is mostly
961 * as defined by the DOM, but may ignore some conveniences.
962 * <p>
963 *
964 * @param nodeHandle The node id.
965 * @return String Value of this node, or null if not
966 * meaningful for this node type.
967 */
968 public String getNodeValue(int nodeHandle)
969 {
970
971 int identity = makeNodeIdentity(nodeHandle);
972 int type = _type(identity);
973
974 if (isTextType(type))
975 {
976 int dataIndex = _dataOrQName(identity);
977 int offset = m_data.elementAt(dataIndex);
978 int length = m_data.elementAt(dataIndex + 1);
979
980 // %OPT% We should cache this, I guess.
981 return m_chars.getString(offset, length);
982 }
983 else if (DTM.ELEMENT_NODE == type || DTM.DOCUMENT_FRAGMENT_NODE == type
984 || DTM.DOCUMENT_NODE == type)
985 {
986 return null;
987 }
988 else
989 {
990 int dataIndex = _dataOrQName(identity);
991
992 if (dataIndex < 0)
993 {
994 dataIndex = -dataIndex;
995 dataIndex = m_data.elementAt(dataIndex + 1);
996 }
997
998 return m_valuesOrPrefixes.indexToString(dataIndex);
999 }
1000 }
1001
1002 /**
1003 * Given a node handle, return its XPath-style localname.
1004 * (As defined in Namespaces, this is the portion of the name after any
1005 * colon character).
1006 *
1007 * @param nodeHandle the id of the node.
1008 * @return String Local name of this node.
1009 */
1010 public String getLocalName(int nodeHandle)
1011 {
1012 return m_expandedNameTable.getLocalName(_exptype(makeNodeIdentity(nodeHandle)));
1013 }
1014
1015 /**
1016 * The getUnparsedEntityURI function returns the URI of the unparsed
1017 * entity with the specified name in the same document as the context
1018 * node (see [3.3 Unparsed Entities]). It returns the empty string if
1019 * there is no such entity.
1020 * <p>
1021 * XML processors may choose to use the System Identifier (if one
1022 * is provided) to resolve the entity, rather than the URI in the
1023 * Public Identifier. The details are dependent on the processor, and
1024 * we would have to support some form of plug-in resolver to handle
1025 * this properly. Currently, we simply return the System Identifier if
1026 * present, and hope that it a usable URI or that our caller can
1027 * map it to one.
1028 * TODO: Resolve Public Identifiers... or consider changing function name.
1029 * <p>
1030 * If we find a relative URI
1031 * reference, XML expects it to be resolved in terms of the base URI
1032 * of the document. The DOM doesn't do that for us, and it isn't
1033 * entirely clear whether that should be done here; currently that's
1034 * pushed up to a higher level of our application. (Note that DOM Level
1035 * 1 didn't store the document's base URI.)
1036 * TODO: Consider resolving Relative URIs.
1037 * <p>
1038 * (The DOM's statement that "An XML processor may choose to
1039 * completely expand entities before the structure model is passed
1040 * to the DOM" refers only to parsed entities, not unparsed, and hence
1041 * doesn't affect this function.)
1042 *
1043 * @param name A string containing the Entity Name of the unparsed
1044 * entity.
1045 *
1046 * @return String containing the URI of the Unparsed Entity, or an
1047 * empty string if no such entity exists.
1048 */
1049 public String getUnparsedEntityURI(String name) {
1050 String url = "";
1051
1052 if (null == m_entities) {
1053 return url;
1054 }
1055
1056 int n = m_entities.size();
1057
1058 for (int i = 0; i < n; i += ENTITY_FIELDS_PER) {
1059 String ename = m_entities.get(i + ENTITY_FIELD_NAME);
1060
1061 if (null != ename && ename.equals(name)) {
1062 String nname = m_entities.get(i + ENTITY_FIELD_NOTATIONNAME);
1063
1064 if (null != nname) {
1065 // The draft says: "The XSLT processor may use the public
1066 // identifier to generate a URI for the entity instead of the URI
1067 // specified in the system identifier. If the XSLT processor does
1068 // not use the public identifier to generate the URI, it must use
1069 // the system identifier; if the system identifier is a relative
1070 // URI, it must be resolved into an absolute URI using the URI of
1071 // the resource containing the entity declaration as the base
1072 // URI [RFC2396]."
1073 // So I'm falling a bit short here.
1074 url = m_entities.get(i + ENTITY_FIELD_SYSTEMID);
1075
1076 if (null == url) {
1077 url = m_entities.get(i + ENTITY_FIELD_PUBLICID);
1078 }
1079 }
1080
1081 break;
1082 }
1083 }
1084
1085 return url;
1086 }
1087
1088 /**
1089 * Given a namespace handle, return the prefix that the namespace decl is
1090 * mapping.
1091 * Given a node handle, return the prefix used to map to the namespace.
1092 *
1093 * <p> %REVIEW% Are you sure you want "" for no prefix? </p>
1094 * <p> %REVIEW-COMMENT% I think so... not totally sure. -sb </p>
1095 *
1096 * @param nodeHandle the id of the node.
1097 * @return String prefix of this node's name, or "" if no explicit
1098 * namespace prefix was given.
1099 */
1100 public String getPrefix(int nodeHandle)
1101 {
1102
1103 int identity = makeNodeIdentity(nodeHandle);
1104 int type = _type(identity);
1105
1106 if (DTM.ELEMENT_NODE == type)
1107 {
1108 int prefixIndex = _dataOrQName(identity);
1109
1110 if (0 == prefixIndex)
1111 return "";
1112 else
1113 {
1114 String qname = m_valuesOrPrefixes.indexToString(prefixIndex);
1115
1116 return getPrefix(qname, null);
1117 }
1118 }
1119 else if (DTM.ATTRIBUTE_NODE == type)
1120 {
1121 int prefixIndex = _dataOrQName(identity);
1122
1123 if (prefixIndex < 0)
1124 {
1125 prefixIndex = m_data.elementAt(-prefixIndex);
1126
1127 String qname = m_valuesOrPrefixes.indexToString(prefixIndex);
1128
1129 return getPrefix(qname, null);
1130 }
1131 }
1132
1133 return "";
1134 }
1135
1136 /**
1137 * Retrieves an attribute node by by qualified name and namespace URI.
1138 *
1139 * @param nodeHandle int Handle of the node upon which to look up this attribute..
1140 * @param namespaceURI The namespace URI of the attribute to
1141 * retrieve, or null.
1142 * @param name The local name of the attribute to
1143 * retrieve.
1144 * @return The attribute node handle with the specified name (
1145 * <code>nodeName</code>) or <code>DTM.NULL</code> if there is no such
1146 * attribute.
1147 */
1148 public int getAttributeNode(int nodeHandle, String namespaceURI,
1149 String name)
1150 {
1151
1152 for (int attrH = getFirstAttribute(nodeHandle); DTM.NULL != attrH;
1153 attrH = getNextAttribute(attrH))
1154 {
1155 String attrNS = getNamespaceURI(attrH);
1156 String attrName = getLocalName(attrH);
1157 boolean nsMatch = namespaceURI == attrNS
1158 || (namespaceURI != null
1159 && namespaceURI.equals(attrNS));
1160
1161 if (nsMatch && name.equals(attrName))
1162 return attrH;
1163 }
1164
1165 return DTM.NULL;
1166 }
1167
1168 /**
1169 * Return the public identifier of the external subset,
1170 * normalized as described in 4.2.2 External Entities [XML]. If there is
1171 * no external subset or if it has no public identifier, this property
1172 * has no value.
1173 *
1174 * @return the public identifier String object, or null if there is none.
1175 */
1176 public String getDocumentTypeDeclarationPublicIdentifier()
1177 {
1178
1179 /** @todo: implement this com.sun.org.apache.xml.internal.dtm.DTMDefaultBase abstract method */
1180 error(XMLMessages.createXMLMessage(XMLErrorResources.ER_METHOD_NOT_SUPPORTED, null));//"Not yet supported!");
1181
1182 return null;
1183 }
1184
1185 /**
1186 * Given a node handle, return its DOM-style namespace URI
1187 * (As defined in Namespaces, this is the declared URI which this node's
1188 * prefix -- or default in lieu thereof -- was mapped to.)
1189 *
1190 * <p>%REVIEW% Null or ""? -sb</p>
1191 *
1192 * @param nodeHandle the id of the node.
1193 * @return String URI value of this node's namespace, or null if no
1194 * namespace was resolved.
1195 */
1196 public String getNamespaceURI(int nodeHandle)
1197 {
1198
1199 return m_expandedNameTable.getNamespace(_exptype(makeNodeIdentity(nodeHandle)));
1200 }
1201
1202 /**
1203 * Get the string-value of a node as a String object
1204 * (see http://www.w3.org/TR/xpath#data-model
1205 * for the definition of a node's string-value).
1206 *
1207 * @param nodeHandle The node ID.
1208 *
1209 * @return A string object that represents the string-value of the given node.
1210 */
1211 public XMLString getStringValue(int nodeHandle)
1212 {
1213 int identity = makeNodeIdentity(nodeHandle);
1214 int type;
1215 if(identity==DTM.NULL) // Separate lines because I wanted to breakpoint it
1216 type = DTM.NULL;
1217 else
1218 type= _type(identity);
1219
1220 if (isTextType(type))
1221 {
1222 int dataIndex = _dataOrQName(identity);
1223 int offset = m_data.elementAt(dataIndex);
1224 int length = m_data.elementAt(dataIndex + 1);
1225
1226 return m_xstrf.newstr(m_chars, offset, length);
1227 }
1228 else
1229 {
1230 int firstChild = _firstch(identity);
1231
1232 if (DTM.NULL != firstChild)
1233 {
1234 int offset = -1;
1235 int length = 0;
1236 int startNode = identity;
1237
1238 identity = firstChild;
1239
1240 do {
1241 type = _type(identity);
1242
1243 if (isTextType(type))
1244 {
1245 int dataIndex = _dataOrQName(identity);
1246
1247 if (-1 == offset)
1248 {
1249 offset = m_data.elementAt(dataIndex);
1250 }
1251
1252 length += m_data.elementAt(dataIndex + 1);
1253 }
1254
1255 identity = getNextNodeIdentity(identity);
1256 } while (DTM.NULL != identity && (_parent(identity) >= startNode));
1257
1258 if (length > 0)
1259 {
1260 return m_xstrf.newstr(m_chars, offset, length);
1261 }
1262 }
1263 else if(type != DTM.ELEMENT_NODE)
1264 {
1265 int dataIndex = _dataOrQName(identity);
1266
1267 if (dataIndex < 0)
1268 {
1269 dataIndex = -dataIndex;
1270 dataIndex = m_data.elementAt(dataIndex + 1);
1271 }
1272 return m_xstrf.newstr(m_valuesOrPrefixes.indexToString(dataIndex));
1273 }
1274 }
1275
1276 return m_xstrf.emptystr();
1277 }
1278
1279 /**
1280 * Determine if the string-value of a node is whitespace
1281 *
1282 * @param nodeHandle The node Handle.
1283 *
1284 * @return Return true if the given node is whitespace.
1285 */
1286 public boolean isWhitespace(int nodeHandle)
1287 {
1288 int identity = makeNodeIdentity(nodeHandle);
1289 int type;
1290 if(identity==DTM.NULL) // Separate lines because I wanted to breakpoint it
1291 type = DTM.NULL;
1292 else
1293 type= _type(identity);
1294
1295 if (isTextType(type))
1296 {
1297 int dataIndex = _dataOrQName(identity);
1298 int offset = m_data.elementAt(dataIndex);
1299 int length = m_data.elementAt(dataIndex + 1);
1300
1301 return m_chars.isWhitespace(offset, length);
1302 }
1303 return false;
1304 }
1305
1306 /**
1307 * Returns the <code>Element</code> whose <code>ID</code> is given by
1308 * <code>elementId</code>. If no such element exists, returns
1309 * <code>DTM.NULL</code>. Behavior is not defined if more than one element
1310 * has this <code>ID</code>. Attributes (including those
1311 * with the name "ID") are not of type ID unless so defined by DTD/Schema
1312 * information available to the DTM implementation.
1313 * Implementations that do not know whether attributes are of type ID or
1314 * not are expected to return <code>DTM.NULL</code>.
1315 *
1316 * <p>%REVIEW% Presumably IDs are still scoped to a single document,
1317 * and this operation searches only within a single document, right?
1318 * Wouldn't want collisions between DTMs in the same process.</p>
1319 *
1320 * @param elementId The unique <code>id</code> value for an element.
1321 * @return The handle of the matching element.
1322 */
1323 public int getElementById(String elementId)
1324 {
1325
1326 Integer intObj;
1327 boolean isMore = true;
1328
1329 do
1330 {
1331 intObj = m_idAttributes.get(elementId);
1332
1333 if (null != intObj)
1334 return makeNodeHandle(intObj.intValue());
1335
1336 if (!isMore || m_endDocumentOccured)
1337 break;
1338
1339 isMore = nextNode();
1340 }
1341 while (null == intObj);
1342
1343 return DTM.NULL;
1344 }
1345
1346 /**
1347 * Get a prefix either from the qname or from the uri mapping, or just make
1348 * one up!
1349 *
1350 * @param qname The qualified name, which may be null.
1351 * @param uri The namespace URI, which may be null.
1352 *
1353 * @return The prefix if there is one, or null.
1354 */
1355 public String getPrefix(String qname, String uri) {
1356 String prefix;
1357 int uriIndex = -1;
1358
1359 if (null != uri && uri.length() > 0) {
1360 do {
1361 uriIndex = m_prefixMappings.indexOf(uri, ++uriIndex);
1362 } while ((uriIndex & 0x01) == 0);
1363
1364 if (uriIndex >= 0) {
1365 prefix = m_prefixMappings.get(uriIndex - 1);
1366 } else if (null != qname) {
1367 int indexOfNSSep = qname.indexOf(':');
1368
1369 if (qname.equals("xmlns"))
1370 prefix = "";
1371 else if (qname.startsWith("xmlns:"))
1372 prefix = qname.substring(indexOfNSSep + 1);
1373 else
1374 prefix = (indexOfNSSep > 0)
1375 ? qname.substring(0, indexOfNSSep) : null;
1376 } else {
1377 prefix = null;
1378 }
1379 } else if (null != qname) {
1380 int indexOfNSSep = qname.indexOf(':');
1381
1382 if (indexOfNSSep > 0) {
1383 if (qname.startsWith("xmlns:"))
1384 prefix = qname.substring(indexOfNSSep + 1);
1385 else
1386 prefix = qname.substring(0, indexOfNSSep);
1387 } else {
1388 if (qname.equals("xmlns"))
1389 prefix = "";
1390 else
1391 prefix = null;
1392 }
1393 } else {
1394 prefix = null;
1395 }
1396
1397 return prefix;
1398 }
1399
1400 /**
1401 * Get a prefix either from the uri mapping, or just make
1402 * one up!
1403 *
1404 * @param uri The namespace URI, which may be null.
1405 *
1406 * @return The prefix if there is one, or null.
1407 */
1408 public int getIdForNamespace(String uri) {
1409 return m_valuesOrPrefixes.stringToIndex(uri);
1410 }
1411
1412 /**
1413 * Get a prefix either from the qname or from the uri mapping, or just make
1414 * one up!
1415 *
1416 * @return The prefix if there is one, or null.
1417 */
1418 public String getNamespaceURI(String prefix) {
1419 String uri = "";
1420 int prefixIndex = m_contextIndexes.peek() - 1 ;
1421
1422 if (null == prefix) {
1423 prefix = "";
1424 }
1425
1426 do {
1427 prefixIndex = m_prefixMappings.indexOf(prefix, ++prefixIndex);
1428 } while ((prefixIndex >= 0) && (prefixIndex & 0x01) == 0x01);
1429
1430 if (prefixIndex > -1) {
1431 uri = m_prefixMappings.get(prefixIndex + 1);
1432 }
1433
1434 return uri;
1435 }
1436
1437 /**
1438 * Set an ID string to node association in the ID table.
1439 *
1440 * @param id The ID string.
1441 * @param elem The associated element handle.
1442 */
1443 public void setIDAttribute(String id, int elem)
1444 {
1445 m_idAttributes.put(id, elem);
1446 }
1447
1448 /**
1449 * Check whether accumulated text should be stripped; if not,
1450 * append the appropriate flavor of text/cdata node.
1451 */
1452 protected void charactersFlush()
1453 {
1454
1455 if (m_textPendingStart >= 0) // -1 indicates no-text-in-progress
1456 {
1457 int length = m_chars.size() - m_textPendingStart;
1458 boolean doStrip = false;
1459
1460 if (getShouldStripWhitespace())
1461 {
1462 doStrip = m_chars.isWhitespace(m_textPendingStart, length);
1463 }
1464
1465 if (doStrip) {
1466 m_chars.setLength(m_textPendingStart); // Discard accumulated text
1467 } else {
1468 // Guard against characters/ignorableWhitespace events that
1469 // contained no characters. They should not result in a node.
1470 if (length > 0) {
1471 int exName = m_expandedNameTable.getExpandedTypeID(DTM.TEXT_NODE);
1472 int dataIndex = m_data.size();
1473
1474 m_previous = addNode(m_coalescedTextType, exName,
1475 m_parents.peek(), m_previous, dataIndex, false);
1476
1477 m_data.addElement(m_textPendingStart);
1478 m_data.addElement(length);
1479 }
1480 }
1481
1482 // Reset for next text block
1483 m_textPendingStart = -1;
1484 m_textType = m_coalescedTextType = DTM.TEXT_NODE;
1485 }
1486 }
1487
1488 ////////////////////////////////////////////////////////////////////
1489 // Implementation of the EntityResolver interface.
1490 ////////////////////////////////////////////////////////////////////
1491
1492 /**
1493 * Resolve an external entity.
1494 *
1495 * <p>Always return null, so that the parser will use the system
1496 * identifier provided in the XML document. This method implements
1497 * the SAX default behaviour: application writers can override it
1498 * in a subclass to do special translations such as catalog lookups
1499 * or URI redirection.</p>
1500 *
1501 * @param publicId The public identifer, or null if none is
1502 * available.
1503 * @param systemId The system identifier provided in the XML
1504 * document.
1505 * @return The new input source, or null to require the
1506 * default behaviour.
1507 * @throws SAXException Any SAX exception, possibly
1508 * wrapping another exception.
1509 * @see EntityResolver#resolveEntity
1510 *
1511 * @throws SAXException
1512 */
1513 public InputSource resolveEntity(String publicId, String systemId)
1514 throws SAXException
1515 {
1516 return null;
1517 }
1518
1519 ////////////////////////////////////////////////////////////////////
1520 // Implementation of DTDHandler interface.
1521 ////////////////////////////////////////////////////////////////////
1522
1523 /**
1524 * Receive notification of a notation declaration.
1525 *
1526 * <p>By default, do nothing. Application writers may override this
1527 * method in a subclass if they wish to keep track of the notations
1528 * declared in a document.</p>
1529 *
1530 * @param name The notation name.
1531 * @param publicId The notation public identifier, or null if not
1532 * available.
1533 * @param systemId The notation system identifier.
1534 * @throws SAXException Any SAX exception, possibly
1535 * wrapping another exception.
1536 * @see DTDHandler#notationDecl
1537 *
1538 * @throws SAXException
1539 */
1540 public void notationDecl(String name, String publicId, String systemId)
1541 throws SAXException
1542 {
1543
1544 // no op
1545 }
1546
1547 /**
1548 * Receive notification of an unparsed entity declaration.
1549 *
1550 * <p>By default, do nothing. Application writers may override this
1551 * method in a subclass to keep track of the unparsed entities
1552 * declared in a document.</p>
1553 *
1554 * @param name The entity name.
1555 * @param publicId The entity public identifier, or null if not
1556 * available.
1557 * @param systemId The entity system identifier.
1558 * @param notationName The name of the associated notation.
1559 * @throws SAXException Any SAX exception, possibly
1560 * wrapping another exception.
1561 * @see DTDHandler#unparsedEntityDecl
1562 *
1563 * @throws SAXException
1564 */
1565 public void unparsedEntityDecl(String name, String publicId, String systemId,
1566 String notationName) throws SAXException
1567 {
1568 if (null == m_entities) {
1569 m_entities = new ArrayList<>();
1570 }
1571
1572 try {
1573 systemId = SystemIDResolver.getAbsoluteURI(systemId,
1574 getDocumentBaseURI());
1575 } catch (Exception e) {
1576 throw new SAXException(e);
1577 }
1578
1579 // private static final int ENTITY_FIELD_PUBLICID = 0;
1580 m_entities.add(publicId);
1581
1582 // private static final int ENTITY_FIELD_SYSTEMID = 1;
1583 m_entities.add(systemId);
1584
1585 // private static final int ENTITY_FIELD_NOTATIONNAME = 2;
1586 m_entities.add(notationName);
1587
1588 // private static final int ENTITY_FIELD_NAME = 3;
1589 m_entities.add(name);
1590 }
1591
1592 ////////////////////////////////////////////////////////////////////
1593 // Implementation of ContentHandler interface.
1594 ////////////////////////////////////////////////////////////////////
1595
1596 /**
1597 * Receive a Locator object for document events.
1598 *
1599 * <p>By default, do nothing. Application writers may override this
1600 * method in a subclass if they wish to store the locator for use
1601 * with other document events.</p>
1602 *
1603 * @param locator A locator for all SAX document events.
1604 * @see ContentHandler#setDocumentLocator
1605 * @see Locator
1606 */
1607 public void setDocumentLocator(Locator locator)
1608 {
1609 m_locator = locator;
1610 m_systemId = locator.getSystemId();
1611 }
1612
1613 /**
1614 * Receive notification of the beginning of the document.
1615 *
1616 * @throws SAXException Any SAX exception, possibly
1617 * wrapping another exception.
1618 * @see ContentHandler#startDocument
1619 */
1620 public void startDocument() throws SAXException
1621 {
1622 if (DEBUG)
1623 System.out.println("startDocument");
1624
1625
1626 int doc = addNode(DTM.DOCUMENT_NODE,
1627 m_expandedNameTable.getExpandedTypeID(DTM.DOCUMENT_NODE),
1628 DTM.NULL, DTM.NULL, 0, true);
1629
1630 m_parents.push(doc);
1631 m_previous = DTM.NULL;
1632
1633 m_contextIndexes.push(m_prefixMappings.size()); // for the next element.
1634 }
1635
1636 /**
1637 * Receive notification of the end of the document.
1638 *
1639 * @throws SAXException Any SAX exception, possibly
1640 * wrapping another exception.
1641 * @see ContentHandler#endDocument
1642 */
1643 public void endDocument() throws SAXException
1644 {
1645 if (DEBUG)
1646 System.out.println("endDocument");
1647
1648 charactersFlush();
1649
1650 m_nextsib.setElementAt(NULL,0);
1651
1652 if (m_firstch.elementAt(0) == NOTPROCESSED)
1653 m_firstch.setElementAt(NULL,0);
1654
1655 if (DTM.NULL != m_previous)
1656 m_nextsib.setElementAt(DTM.NULL,m_previous);
1657
1658 m_parents = null;
1659 m_prefixMappings = null;
1660 m_contextIndexes = null;
1661
1662 m_endDocumentOccured = true;
1663
1664 // Bugzilla 4858: throw away m_locator. we cache m_systemId
1665 m_locator = null;
1666 }
1667
1668 /**
1669 * Receive notification of the start of a Namespace mapping.
1670 *
1671 * <p>By default, do nothing. Application writers may override this
1672 * method in a subclass to take specific actions at the start of
1673 * each Namespace prefix scope (such as storing the prefix mapping).</p>
1674 *
1675 * @param prefix The Namespace prefix being declared.
1676 * @param uri The Namespace URI mapped to the prefix.
1677 * @throws SAXException Any SAX exception, possibly
1678 * wrapping another exception.
1679 * @see ContentHandler#startPrefixMapping
1680 */
1681 public void startPrefixMapping(String prefix, String uri)
1682 throws SAXException
1683 {
1684
1685 if (DEBUG)
1686 System.out.println("startPrefixMapping: prefix: " + prefix + ", uri: "
1687 + uri);
1688
1689 if(null == prefix)
1690 prefix = "";
1691 m_prefixMappings.add(prefix);
1692 m_prefixMappings.add(uri);
1693 }
1694
1695 /**
1696 * Receive notification of the end of a Namespace mapping.
1697 *
1698 * <p>By default, do nothing. Application writers may override this
1699 * method in a subclass to take specific actions at the end of
1700 * each prefix mapping.</p>
1701 *
1702 * @param prefix The Namespace prefix being declared.
1703 * @throws SAXException Any SAX exception, possibly
1704 * wrapping another exception.
1705 * @see ContentHandler#endPrefixMapping
1706 */
1707 public void endPrefixMapping(String prefix) throws SAXException
1708 {
1709 if (DEBUG)
1710 System.out.println("endPrefixMapping: prefix: " + prefix);
1711
1712 if(null == prefix)
1713 prefix = "";
1714
1715 int index = m_contextIndexes.peek() - 1;
1716
1717 do
1718 {
1719 index = m_prefixMappings.indexOf(prefix, ++index);
1720 } while ( (index >= 0) && ((index & 0x01) == 0x01) );
1721
1722
1723 if (index > -1)
1724 {
1725 m_prefixMappings.setElementAt("%@$#^@#", index);
1726 m_prefixMappings.setElementAt("%@$#^@#", index + 1);
1727 }
1728
1729 // no op
1730 }
1731
1732 /**
1733 * Check if a declaration has already been made for a given prefix.
1734 *
1735 * @param prefix non-null prefix string.
1736 *
1737 * @return true if the declaration has already been declared in the
1738 * current context.
1739 */
1740 protected boolean declAlreadyDeclared(String prefix) {
1741 int startDecls = m_contextIndexes.peek();
1742 Vector<String> prefixMappings = m_prefixMappings;
1743 int nDecls = prefixMappings.size();
1744
1745 for (int i = startDecls; i < nDecls; i += 2) {
1746 String prefixDecl = prefixMappings.get(i);
1747
1748 if (prefixDecl == null)
1749 continue;
1750
1751 if (prefixDecl.equals(prefix))
1752 return true;
1753 }
1754
1755 return false;
1756 }
1757
1758 boolean m_pastFirstElement=false;
1759
1760 /**
1761 * Receive notification of the start of an element.
1762 *
1763 * <p>By default, do nothing. Application writers may override this
1764 * method in a subclass to take specific actions at the start of
1765 * each element (such as allocating a new tree node or writing
1766 * output to a file).</p>
1767 *
1768 * @param uri The Namespace URI, or the empty string if the
1769 * element has no Namespace URI or if Namespace
1770 * processing is not being performed.
1771 * @param localName The local name (without prefix), or the
1772 * empty string if Namespace processing is not being
1773 * performed.
1774 * @param qName The qualified name (with prefix), or the
1775 * empty string if qualified names are not available.
1776 * @param attributes The specified or defaulted attributes.
1777 * @throws SAXException Any SAX exception, possibly
1778 * wrapping another exception.
1779 * @see ContentHandler#startElement
1780 */
1781 public void startElement(String uri, String localName, String qName,
1782 Attributes attributes) throws SAXException
1783 {
1784 if (DEBUG) {
1785 System.out.println("startElement: uri: " + uri +
1786 ", localname: " + localName +
1787 ", qname: "+qName+", atts: " + attributes);
1788
1789 boolean DEBUG_ATTRS=true;
1790 if (DEBUG_ATTRS & attributes!=null) {
1791 int n = attributes.getLength();
1792 if (n==0) {
1793 System.out.println("\tempty attribute list");
1794 } else for (int i = 0; i < n; i++) {
1795 System.out.println("\t attr: uri: " + attributes.getURI(i) +
1796 ", localname: " + attributes.getLocalName(i) +
1797 ", qname: " + attributes.getQName(i) +
1798 ", type: " + attributes.getType(i) +
1799 ", value: " + attributes.getValue(i));
1800 }
1801 }
1802 }
1803
1804 charactersFlush();
1805
1806 if ((localName == null || localName.isEmpty()) &&
1807 (uri == null || uri.isEmpty())) {
1808 localName = qName;
1809 }
1810
1811 int exName = m_expandedNameTable.getExpandedTypeID(uri, localName, DTM.ELEMENT_NODE);
1812 String prefix = getPrefix(qName, uri);
1813 int prefixIndex = (null != prefix)
1814 ? m_valuesOrPrefixes.stringToIndex(qName) : 0;
1815
1816 int elemNode = addNode(DTM.ELEMENT_NODE, exName,
1817 m_parents.peek(), m_previous, prefixIndex, true);
1818
1819 if (m_indexing)
1820 indexNode(exName, elemNode);
1821
1822 m_parents.push(elemNode);
1823
1824 int startDecls = m_contextIndexes.peek();
1825 int nDecls = m_prefixMappings.size();
1826 int prev = DTM.NULL;
1827
1828 if (!m_pastFirstElement) {
1829 // SPECIAL CASE: Implied declaration at root element
1830 prefix = "xml";
1831 String declURL = "http://www.w3.org/XML/1998/namespace";
1832 exName = m_expandedNameTable.getExpandedTypeID(null, prefix, DTM.NAMESPACE_NODE);
1833 int val = m_valuesOrPrefixes.stringToIndex(declURL);
1834 prev = addNode(DTM.NAMESPACE_NODE, exName, elemNode,
1835 prev, val, false);
1836 m_pastFirstElement=true;
1837 }
1838
1839 for (int i = startDecls; i < nDecls; i += 2) {
1840 prefix = m_prefixMappings.get(i);
1841
1842 if (prefix == null)
1843 continue;
1844
1845 String declURL = m_prefixMappings.get(i + 1);
1846
1847 exName = m_expandedNameTable.getExpandedTypeID(null, prefix, DTM.NAMESPACE_NODE);
1848
1849 int val = m_valuesOrPrefixes.stringToIndex(declURL);
1850
1851 prev = addNode(DTM.NAMESPACE_NODE, exName, elemNode,
1852 prev, val, false);
1853 }
1854
1855 int n = attributes.getLength();
1856
1857 for (int i = 0; i < n; i++) {
1858 String attrUri = attributes.getURI(i);
1859 String attrQName = attributes.getQName(i);
1860 String valString = attributes.getValue(i);
1861
1862 prefix = getPrefix(attrQName, attrUri);
1863
1864 int nodeType;
1865
1866 String attrLocalName = attributes.getLocalName(i);
1867
1868 if ((null != attrQName) &&
1869 (attrQName.equals("xmlns") || attrQName.startsWith("xmlns:"))) {
1870 if (declAlreadyDeclared(prefix))
1871 continue; // go to the next attribute.
1872
1873 nodeType = DTM.NAMESPACE_NODE;
1874 } else {
1875 nodeType = DTM.ATTRIBUTE_NODE;
1876
1877 if (attributes.getType(i).equalsIgnoreCase("ID"))
1878 setIDAttribute(valString, elemNode);
1879 }
1880
1881 // Bit of a hack... if somehow valString is null, stringToIndex will
1882 // return -1, which will make things very unhappy.
1883 if (null == valString)
1884 valString = "";
1885
1886 int val = m_valuesOrPrefixes.stringToIndex(valString);
1887 //String attrLocalName = attributes.getLocalName(i);
1888
1889 if (null != prefix) {
1890 prefixIndex = m_valuesOrPrefixes.stringToIndex(attrQName);
1891
1892 int dataIndex = m_data.size();
1893
1894 m_data.addElement(prefixIndex);
1895 m_data.addElement(val);
1896
1897 val = -dataIndex;
1898 }
1899
1900 exName = m_expandedNameTable.getExpandedTypeID(attrUri, attrLocalName, nodeType);
1901 prev = addNode(nodeType, exName, elemNode, prev, val,
1902 false);
1903 }
1904
1905 if (DTM.NULL != prev)
1906 m_nextsib.setElementAt(DTM.NULL,prev);
1907
1908 if (null != m_wsfilter) {
1909 short wsv = m_wsfilter.getShouldStripSpace(makeNodeHandle(elemNode), this);
1910 boolean shouldStrip = (DTMWSFilter.INHERIT == wsv)
1911 ? getShouldStripWhitespace()
1912 : (DTMWSFilter.STRIP == wsv);
1913
1914 pushShouldStripWhitespace(shouldStrip);
1915 }
1916
1917 m_previous = DTM.NULL;
1918
1919 m_contextIndexes.push(m_prefixMappings.size()); // for the children.
1920 }
1921
1922 /**
1923 * Receive notification of the end of an element.
1924 *
1925 * <p>By default, do nothing. Application writers may override this
1926 * method in a subclass to take specific actions at the end of
1927 * each element (such as finalising a tree node or writing
1928 * output to a file).</p>
1929 *
1930 * @param uri The Namespace URI, or the empty string if the
1931 * element has no Namespace URI or if Namespace
1932 * processing is not being performed.
1933 * @param localName The local name (without prefix), or the
1934 * empty string if Namespace processing is not being
1935 * performed.
1936 * @param qName The qualified XML 1.0 name (with prefix), or the
1937 * empty string if qualified names are not available.
1938 * @throws SAXException Any SAX exception, possibly
1939 * wrapping another exception.
1940 * @see ContentHandler#endElement
1941 */
1942 public void endElement(String uri, String localName, String qName)
1943 throws SAXException
1944 {
1945 if (DEBUG)
1946 System.out.println("endElement: uri: " + uri + ", localname: "
1947 + localName + ", qname: "+qName);
1948
1949 charactersFlush();
1950
1951 // If no one noticed, startPrefixMapping is a drag.
1952 // Pop the context for the last child (the one pushed by startElement)
1953 m_contextIndexes.quickPop(1);
1954
1955 // Do it again for this one (the one pushed by the last endElement).
1956 int topContextIndex = m_contextIndexes.peek();
1957 if (topContextIndex != m_prefixMappings.size()) {
1958 m_prefixMappings.setSize(topContextIndex);
1959 }
1960
1961 int lastNode = m_previous;
1962
1963 m_previous = m_parents.pop();
1964
1965 // If lastNode is still DTM.NULL, this element had no children
1966 if (DTM.NULL == lastNode)
1967 m_firstch.setElementAt(DTM.NULL,m_previous);
1968 else
1969 m_nextsib.setElementAt(DTM.NULL,lastNode);
1970
1971 popShouldStripWhitespace();
1972 }
1973
1974 /**
1975 * Receive notification of character data inside an element.
1976 *
1977 * <p>By default, do nothing. Application writers may override this
1978 * method to take specific actions for each chunk of character data
1979 * (such as adding the data to a node or buffer, or printing it to
1980 * a file).</p>
1981 *
1982 * @param ch The characters.
1983 * @param start The start position in the character array.
1984 * @param length The number of characters to use from the
1985 * character array.
1986 * @throws SAXException Any SAX exception, possibly
1987 * wrapping another exception.
1988 * @see ContentHandler#characters
1989 */
1990 public void characters(char ch[], int start, int length) throws SAXException
1991 {
1992 if (m_textPendingStart == -1) // First one in this block
1993 {
1994 m_textPendingStart = m_chars.size();
1995 m_coalescedTextType = m_textType;
1996 }
1997 // Type logic: If all adjacent text is CDATASections, the
1998 // concatentated text is treated as a single CDATASection (see
1999 // initialization above). If any were ordinary Text, the whole
2000 // thing is treated as Text. This may be worth %REVIEW%ing.
2001 else if (m_textType == DTM.TEXT_NODE)
2002 {
2003 m_coalescedTextType = DTM.TEXT_NODE;
2004 }
2005
2006 m_chars.append(ch, start, length);
2007 }
2008
2009 /**
2010 * Receive notification of ignorable whitespace in element content.
2011 *
2012 * <p>By default, do nothing. Application writers may override this
2013 * method to take specific actions for each chunk of ignorable
2014 * whitespace (such as adding data to a node or buffer, or printing
2015 * it to a file).</p>
2016 *
2017 * @param ch The whitespace characters.
2018 * @param start The start position in the character array.
2019 * @param length The number of characters to use from the
2020 * character array.
2021 * @throws SAXException Any SAX exception, possibly
2022 * wrapping another exception.
2023 * @see ContentHandler#ignorableWhitespace
2024 */
2025 public void ignorableWhitespace(char ch[], int start, int length)
2026 throws SAXException
2027 {
2028
2029 // %OPT% We can probably take advantage of the fact that we know this
2030 // is whitespace.
2031 characters(ch, start, length);
2032 }
2033
2034 /**
2035 * Receive notification of a processing instruction.
2036 *
2037 * <p>By default, do nothing. Application writers may override this
2038 * method in a subclass to take specific actions for each
2039 * processing instruction, such as setting status variables or
2040 * invoking other methods.</p>
2041 *
2042 * @param target The processing instruction target.
2043 * @param data The processing instruction data, or null if
2044 * none is supplied.
2045 * @throws SAXException Any SAX exception, possibly
2046 * wrapping another exception.
2047 * @see ContentHandler#processingInstruction
2048 */
2049 public void processingInstruction(String target, String data)
2050 throws SAXException
2051 {
2052 if (DEBUG)
2053 System.out.println("processingInstruction: target: " + target +", data: "+data);
2054
2055 charactersFlush();
2056
2057 int exName = m_expandedNameTable.getExpandedTypeID(null, target,
2058 DTM.PROCESSING_INSTRUCTION_NODE);
2059 int dataIndex = m_valuesOrPrefixes.stringToIndex(data);
2060
2061 m_previous = addNode(DTM.PROCESSING_INSTRUCTION_NODE, exName,
2062 m_parents.peek(), m_previous,
2063 dataIndex, false);
2064 }
2065
2066 /**
2067 * Receive notification of a skipped entity.
2068 *
2069 * <p>By default, do nothing. Application writers may override this
2070 * method in a subclass to take specific actions for each
2071 * processing instruction, such as setting status variables or
2072 * invoking other methods.</p>
2073 *
2074 * @param name The name of the skipped entity.
2075 * @throws SAXException Any SAX exception, possibly
2076 * wrapping another exception.
2077 * @see ContentHandler#processingInstruction
2078 */
2079 public void skippedEntity(String name) throws SAXException
2080 {
2081
2082 // %REVIEW% What should be done here?
2083 // no op
2084 }
2085
2086 ////////////////////////////////////////////////////////////////////
2087 // Implementation of the ErrorHandler interface.
2088 ////////////////////////////////////////////////////////////////////
2089
2090 /**
2091 * Receive notification of a parser warning.
2092 *
2093 * <p>The default implementation does nothing. Application writers
2094 * may override this method in a subclass to take specific actions
2095 * for each warning, such as inserting the message in a log file or
2096 * printing it to the console.</p>
2097 *
2098 * @param e The warning information encoded as an exception.
2099 * @throws SAXException Any SAX exception, possibly
2100 * wrapping another exception.
2101 * @see ErrorHandler#warning
2102 * @see SAXParseException
2103 */
2104 public void warning(SAXParseException e) throws SAXException
2105 {
2106
2107 // %REVIEW% Is there anyway to get the JAXP error listener here?
2108 System.err.println(e.getMessage());
2109 }
2110
2111 /**
2112 * Receive notification of a recoverable parser error.
2113 *
2114 * <p>The default implementation does nothing. Application writers
2115 * may override this method in a subclass to take specific actions
2116 * for each error, such as inserting the message in a log file or
2117 * printing it to the console.</p>
2118 *
2119 * @param e The warning information encoded as an exception.
2120 * @throws SAXException Any SAX exception, possibly
2121 * wrapping another exception.
2122 * @see ErrorHandler#warning
2123 * @see SAXParseException
2124 */
2125 public void error(SAXParseException e) throws SAXException
2126 {
2127 throw e;
2128 }
2129
2130 /**
2131 * Report a fatal XML parsing error.
2132 *
2133 * <p>The default implementation throws a SAXParseException.
2134 * Application writers may override this method in a subclass if
2135 * they need to take specific actions for each fatal error (such as
2136 * collecting all of the errors into a single report): in any case,
2137 * the application must stop all regular processing when this
2138 * method is invoked, since the document is no longer reliable, and
2139 * the parser may no longer report parsing events.</p>
2140 *
2141 * @param e The error information encoded as an exception.
2142 * @throws SAXException Any SAX exception, possibly
2143 * wrapping another exception.
2144 * @see ErrorHandler#fatalError
2145 * @see SAXParseException
2146 */
2147 public void fatalError(SAXParseException e) throws SAXException
2148 {
2149 throw e;
2150 }
2151
2152 ////////////////////////////////////////////////////////////////////
2153 // Implementation of the DeclHandler interface.
2154 ////////////////////////////////////////////////////////////////////
2155
2156 /**
2157 * Report an element type declaration.
2158 *
2159 * <p>The content model will consist of the string "EMPTY", the
2160 * string "ANY", or a parenthesised group, optionally followed
2161 * by an occurrence indicator. The model will be normalized so
2162 * that all whitespace is removed,and will include the enclosing
2163 * parentheses.</p>
2164 *
2165 * @param name The element type name.
2166 * @param model The content model as a normalized string.
2167 * @throws SAXException The application may raise an exception.
2168 */
2169 public void elementDecl(String name, String model) throws SAXException
2170 {
2171
2172 // no op
2173 }
2174
2175 /**
2176 * Report an attribute type declaration.
2177 *
2178 * <p>Only the effective (first) declaration for an attribute will
2179 * be reported. The type will be one of the strings "CDATA",
2180 * "ID", "IDREF", "IDREFS", "NMTOKEN", "NMTOKENS", "ENTITY",
2181 * "ENTITIES", or "NOTATION", or a parenthesized token group with
2182 * the separator "|" and all whitespace removed.</p>
2183 *
2184 * @param eName The name of the associated element.
2185 * @param aName The name of the attribute.
2186 * @param type A string representing the attribute type.
2187 * @param valueDefault A string representing the attribute default
2188 * ("#IMPLIED", "#REQUIRED", or "#FIXED") or null if
2189 * none of these applies.
2190 * @param value A string representing the attribute's default value,
2191 * or null if there is none.
2192 * @throws SAXException The application may raise an exception.
2193 */
2194 public void attributeDecl(
2195 String eName, String aName, String type, String valueDefault, String value)
2196 throws SAXException
2197 {
2198
2199 // no op
2200 }
2201
2202 /**
2203 * Report an internal entity declaration.
2204 *
2205 * <p>Only the effective (first) declaration for each entity
2206 * will be reported.</p>
2207 *
2208 * @param name The name of the entity. If it is a parameter
2209 * entity, the name will begin with '%'.
2210 * @param value The replacement text of the entity.
2211 * @throws SAXException The application may raise an exception.
2212 * @see #externalEntityDecl
2213 * @see DTDHandler#unparsedEntityDecl
2214 */
2215 public void internalEntityDecl(String name, String value)
2216 throws SAXException
2217 {
2218
2219 // no op
2220 }
2221
2222 /**
2223 * Report a parsed external entity declaration.
2224 *
2225 * <p>Only the effective (first) declaration for each entity
2226 * will be reported.</p>
2227 *
2228 * @param name The name of the entity. If it is a parameter
2229 * entity, the name will begin with '%'.
2230 * @param publicId The declared public identifier of the entity, or
2231 * null if none was declared.
2232 * @param systemId The declared system identifier of the entity.
2233 * @throws SAXException The application may raise an exception.
2234 * @see #internalEntityDecl
2235 * @see DTDHandler#unparsedEntityDecl
2236 */
2237 public void externalEntityDecl(
2238 String name, String publicId, String systemId) throws SAXException
2239 {
2240
2241 // no op
2242 }
2243
2244 ////////////////////////////////////////////////////////////////////
2245 // Implementation of the LexicalHandler interface.
2246 ////////////////////////////////////////////////////////////////////
2247
2248 /**
2249 * Report the start of DTD declarations, if any.
2250 *
2251 * <p>Any declarations are assumed to be in the internal subset
2252 * unless otherwise indicated by a {@link #startEntity startEntity}
2253 * event.</p>
2254 *
2255 * <p>Note that the start/endDTD events will appear within
2256 * the start/endDocument events from ContentHandler and
2257 * before the first startElement event.</p>
2258 *
2259 * @param name The document type name.
2260 * @param publicId The declared public identifier for the
2261 * external DTD subset, or null if none was declared.
2262 * @param systemId The declared system identifier for the
2263 * external DTD subset, or null if none was declared.
2264 * @throws SAXException The application may raise an
2265 * exception.
2266 * @see #endDTD
2267 * @see #startEntity
2268 */
2269 public void startDTD(String name, String publicId, String systemId)
2270 throws SAXException
2271 {
2272
2273 m_insideDTD = true;
2274 }
2275
2276 /**
2277 * Report the end of DTD declarations.
2278 *
2279 * @throws SAXException The application may raise an exception.
2280 * @see #startDTD
2281 */
2282 public void endDTD() throws SAXException
2283 {
2284
2285 m_insideDTD = false;
2286 }
2287
2288 /**
2289 * Report the beginning of an entity in content.
2290 *
2291 * <p><strong>NOTE:</entity> entity references in attribute
2292 * values -- and the start and end of the document entity --
2293 * are never reported.</p>
2294 *
2295 * <p>The start and end of the external DTD subset are reported
2296 * using the pseudo-name "[dtd]". All other events must be
2297 * properly nested within start/end entity events.</p>
2298 *
2299 * <p>Note that skipped entities will be reported through the
2300 * {@link ContentHandler#skippedEntity skippedEntity}
2301 * event, which is part of the ContentHandler interface.</p>
2302 *
2303 * @param name The name of the entity. If it is a parameter
2304 * entity, the name will begin with '%'.
2305 * @throws SAXException The application may raise an exception.
2306 * @see #endEntity
2307 * @see DeclHandler#internalEntityDecl
2308 * @see DeclHandler#externalEntityDecl
2309 */
2310 public void startEntity(String name) throws SAXException
2311 {
2312
2313 // no op
2314 }
2315
2316 /**
2317 * Report the end of an entity.
2318 *
2319 * @param name The name of the entity that is ending.
2320 * @throws SAXException The application may raise an exception.
2321 * @see #startEntity
2322 */
2323 public void endEntity(String name) throws SAXException
2324 {
2325
2326 // no op
2327 }
2328
2329 /**
2330 * Report the start of a CDATA section.
2331 *
2332 * <p>The contents of the CDATA section will be reported through
2333 * the regular {@link ContentHandler#characters
2334 * characters} event.</p>
2335 *
2336 * @throws SAXException The application may raise an exception.
2337 * @see #endCDATA
2338 */
2339 public void startCDATA() throws SAXException
2340 {
2341 m_textType = DTM.CDATA_SECTION_NODE;
2342 }
2343
2344 /**
2345 * Report the end of a CDATA section.
2346 *
2347 * @throws SAXException The application may raise an exception.
2348 * @see #startCDATA
2349 */
2350 public void endCDATA() throws SAXException
2351 {
2352 m_textType = DTM.TEXT_NODE;
2353 }
2354
2355 /**
2356 * Report an XML comment anywhere in the document.
2357 *
2358 * <p>This callback will be used for comments inside or outside the
2359 * document element, including comments in the external DTD
2360 * subset (if read).</p>
2361 *
2362 * @param ch An array holding the characters in the comment.
2363 * @param start The starting position in the array.
2364 * @param length The number of characters to use from the array.
2365 * @throws SAXException The application may raise an exception.
2366 */
2367 public void comment(char ch[], int start, int length) throws SAXException
2368 {
2369
2370 if (m_insideDTD) // ignore comments if we're inside the DTD
2371 return;
2372
2373 charactersFlush();
2374
2375 int exName = m_expandedNameTable.getExpandedTypeID(DTM.COMMENT_NODE);
2376
2377 // For now, treat comments as strings... I guess we should do a
2378 // seperate FSB buffer instead.
2379 int dataIndex = m_valuesOrPrefixes.stringToIndex(new String(ch, start,
2380 length));
2381
2382
2383 m_previous = addNode(DTM.COMMENT_NODE, exName,
2384 m_parents.peek(), m_previous, dataIndex, false);
2385 }
2386
2387 /**
2388 * Set a run time property for this DTM instance.
2389 *
2390 * %REVIEW% Now that we no longer use this method to support
2391 * getSourceLocatorFor, can we remove it?
2392 *
2393 * @param property a <code>String</code> value
2394 * @param value an <code>Object</code> value
2395 */
2396 public void setProperty(String property, Object value)
2397 {
2398 }
2399
2400 /** Retrieve the SourceLocator associated with a specific node.
2401 * This is only meaningful if the XalanProperties.SOURCE_LOCATION flag was
2402 * set True using setProperty; if it was never set, or was set false, we
2403 * will return null.
2404 *
2405 * (We _could_ return a locator with the document's base URI and bogus
2406 * line/column information. Trying that; see the else clause.)
2407 * */
2408 public SourceLocator getSourceLocatorFor(int node)
2409 {
2410 if (m_useSourceLocationProperty)
2411 {
2412
2413 node = makeNodeIdentity(node);
2414
2415
2416 return new NodeLocator(null,
2417 m_sourceSystemId.elementAt(node),
2418 m_sourceLine.elementAt(node),
2419 m_sourceColumn.elementAt(node));
2420 }
2421 else if(m_locator!=null)
2422 {
2423 return new NodeLocator(null,m_locator.getSystemId(),-1,-1);
2424 }
2425 else if(m_systemId!=null)
2426 {
2427 return new NodeLocator(null,m_systemId,-1,-1);
2428 }
2429 return null;
2430 }
2431
2432 public String getFixedNames(int type){
2433 return m_fixednames[type];
2434 }
2435 }