001: /*
002: * The Apache Software License, Version 1.1
003: *
004: *
005: * Copyright (c) 1999,2000 The Apache Software Foundation. All rights
006: * reserved.
007: *
008: * Redistribution and use in source and binary forms, with or without
009: * modification, are permitted provided that the following conditions
010: * are met:
011: *
012: * 1. Redistributions of source code must retain the above copyright
013: * notice, this list of conditions and the following disclaimer.
014: *
015: * 2. Redistributions in binary form must reproduce the above copyright
016: * notice, this list of conditions and the following disclaimer in
017: * the documentation and/or other materials provided with the
018: * distribution.
019: *
020: * 3. The end-user documentation included with the redistribution,
021: * if any, must include the following acknowledgment:
022: * "This product includes software developed by the
023: * Apache Software Foundation (http://www.apache.org/)."
024: * Alternately, this acknowledgment may appear in the software itself,
025: * if and wherever such third-party acknowledgments normally appear.
026: *
027: * 4. The names "Xerces" and "Apache Software Foundation" must
028: * not be used to endorse or promote products derived from this
029: * software without prior written permission. For written
030: * permission, please contact apache@apache.org.
031: *
032: * 5. Products derived from this software may not be called "Apache",
033: * nor may "Apache" appear in their name, without prior written
034: * permission of the Apache Software Foundation.
035: *
036: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
037: * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
038: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
039: * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
040: * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
041: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
042: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
043: * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
044: * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
045: * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
046: * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
047: * SUCH DAMAGE.
048: * ====================================================================
049: *
050: * This software consists of voluntary contributions made by many
051: * individuals on behalf of the Apache Software Foundation and was
052: * originally based on software copyright (c) 1999, International
053: * Business Machines, Inc., http://www.apache.org. For more
054: * information on the Apache Software Foundation, please see
055: * <http://www.apache.org/>.
056: */
057:
058: package org.apache.xerces.readers;
059:
060: import org.apache.xerces.framework.XMLErrorReporter;
061: import org.apache.xerces.utils.QName;
062: import org.apache.xerces.utils.StringPool;
063: import org.xml.sax.EntityResolver;
064: import org.xml.sax.InputSource;
065: import org.xml.sax.Locator;
066: import java.io.InputStream;
067:
068: /**
069: * This is the interface used for entity management. This interface
070: * is typically implemented by the "parser" class to provide entity
071: * management services for the scanner classes.
072: *
073: * @version $Id: XMLEntityHandler.java,v 1.3 2000/05/17 18:32:44 jeffreyr Exp $
074: */
075: public interface XMLEntityHandler extends Locator {
076:
077: /**
078: * Special return values for scanCharRef method. The normal return
079: * value is a unicode character. These error conditions are defined
080: * using invalid XML unicode code points.
081: */
082: public static final int CHARREF_RESULT_SEMICOLON_REQUIRED = -1,
083: CHARREF_RESULT_INVALID_CHAR = -2,
084: CHARREF_RESULT_OUT_OF_RANGE = -3;
085:
086: /**
087: * Special return values for scanStringLiteral method. The normal
088: * return value is a StringPool handle. These error conditions are
089: * defined using invalid indices.
090: */
091: public static final int STRINGLIT_RESULT_QUOTE_REQUIRED = -1,
092: STRINGLIT_RESULT_INVALID_CHAR = -2;
093:
094: /**
095: * Special return values for scanAttValue method. The normal return
096: * value is a StringPool handle for a simple AttValue that was already
097: * correctly normalized for CDATA in the original document. These
098: * other return values either indicate an error or that the AttValue
099: * needs further processing.
100: */
101: public static final int ATTVALUE_RESULT_COMPLEX = -1,
102: ATTVALUE_RESULT_LESSTHAN = -2,
103: ATTVALUE_RESULT_INVALID_CHAR = -3;
104:
105: /**
106: * Special return values for scanEntityValue method. The normal return
107: * value is a StringPool handle for a simple EntityValue that was entirely
108: * contained within the original document. These other return values can
109: * either indicate an error or that the EntityValue needs further processing.
110: */
111: public static final int ENTITYVALUE_RESULT_FINISHED = -1,
112: ENTITYVALUE_RESULT_REFERENCE = -2,
113: ENTITYVALUE_RESULT_PEREF = -3,
114: ENTITYVALUE_RESULT_INVALID_CHAR = -4,
115: ENTITYVALUE_RESULT_END_OF_INPUT = -5;
116:
117: /**
118: * Return values for the scanContent method.
119: */
120: public static final int CONTENT_RESULT_START_OF_PI = 0,
121: CONTENT_RESULT_START_OF_COMMENT = 1,
122: CONTENT_RESULT_START_OF_CDSECT = 2,
123: CONTENT_RESULT_END_OF_CDSECT = 3,
124: CONTENT_RESULT_START_OF_ETAG = 4,
125: CONTENT_RESULT_MATCHING_ETAG = 5,
126: CONTENT_RESULT_START_OF_ELEMENT = 6,
127: CONTENT_RESULT_START_OF_CHARREF = 7,
128: CONTENT_RESULT_START_OF_ENTITYREF = 8,
129: CONTENT_RESULT_INVALID_CHAR = 9,
130: CONTENT_RESULT_MARKUP_NOT_RECOGNIZED = 10,
131: CONTENT_RESULT_MARKUP_END_OF_INPUT = 11,
132: CONTENT_RESULT_REFERENCE_END_OF_INPUT = 12;
133:
134: /**
135: * This is an enumeration of all the defined entity types.
136: * These are provided to communicate state information to
137: * the clients of the parser.
138: */
139: public static final int ENTITYTYPE_INTERNAL_PE = 0,
140: ENTITYTYPE_EXTERNAL_PE = 1, ENTITYTYPE_INTERNAL = 2,
141: ENTITYTYPE_EXTERNAL = 3, ENTITYTYPE_UNPARSED = 4,
142: ENTITYTYPE_DOCUMENT = 5, ENTITYTYPE_EXTERNAL_SUBSET = 6;
143:
144: /**
145: * This is an enumeration of all the defined contexts in which
146: * an entity reference may appear. The order is important, as
147: * all explicit general entity references must appear first and
148: * the last of these must be ENTITYREF_IN_CONTENT. This permits
149: * the test "(context <= ENTITYREF_IN_CONTENT)" to be used as a
150: * quick check for a general entity reference.
151: *
152: * @see #startReadingFromEntity
153: */
154: public static final int ENTITYREF_IN_ATTVALUE = 0,
155: ENTITYREF_IN_DEFAULTATTVALUE = 1, ENTITYREF_IN_CONTENT = 2,
156: ENTITYREF_IN_DTD_AS_MARKUP = 3,
157: ENTITYREF_IN_ENTITYVALUE = 4,
158: ENTITYREF_IN_DTD_WITHIN_MARKUP = 5, ENTITYREF_DOCUMENT = 6,
159: ENTITYREF_EXTERNAL_SUBSET = 7;
160:
161: /**
162: * Start reading document from an InputSource.
163: *
164: * @param source The input source for the document to process.
165: * @return <code>true</code> if we were able to open the document source;
166: * <code>false</code> otherwise.
167: * @exception java.lang.Exception
168: */
169: public boolean startReadingFromDocument(InputSource source)
170: throws Exception;
171:
172: /**
173: * Start reading from this entity.
174: *
175: * Note that the reader depth is not used by the reader, but is made
176: * available so that it may be retrieved at end of input to test that
177: * gramatical structures are properly nested within entities.
178: *
179: * @param entityName The entity name handle in the string pool.
180: * @param readerDepth The depth to associate with the reader for this entity.
181: * @param context The context of the entity reference; see ENTITYREF_IN_*.
182: * @return <code>true</code> if the entity might start with a TextDecl;
183: * <code>false</code> otherwise.
184: * @exception java.lang.Exception
185: */
186: public boolean startReadingFromEntity(int entityName,
187: int readerDepth, int entityContext) throws Exception;
188:
189: /**
190: * Expand the system identifier relative to the entity that we are processing.
191: *
192: * @return The expanded system identifier.
193: */
194: public String expandSystemId(String systemId);
195:
196: /**
197: * DTD specific entity handler
198: */
199: public interface DTDHandler {
200: /**
201: * Start reading from the external subset of the DTD.
202: *
203: * @param publicId The public identifier for the external subset.
204: * @param systemId The system identifier for the external subset.
205: * @param readerDepth The depth to associate with the reader for the external subset.
206: * @exception java.lang.Exception
207: */
208: public void startReadingFromExternalSubset(String publicId,
209: String systemId, int readerDepth) throws Exception;
210:
211: /**
212: * Finished reading from the external subset of the DTD.
213: * @exception java.lang.Exception
214: */
215: public void stopReadingFromExternalSubset() throws Exception;
216:
217: /**
218: * Start the scope of an entity declaration.
219: *
220: * @return <code>true</code> on success; otherwise
221: * <code>false</code> if the entity declaration is recursive.
222: * @exception java.lang.Exception
223: */
224: public boolean startEntityDecl(boolean isPE, int entityName)
225: throws Exception;
226:
227: /**
228: * End the scope of an entity declaration.
229: * @exception java.lang.Exception
230: */
231: public void endEntityDecl() throws Exception;
232:
233: /**
234: * Declare entities and notations.
235: */
236: public int addInternalPEDecl(int entityName, int value,
237: boolean isExternal) throws Exception;
238:
239: public int addExternalPEDecl(int entityName, int publicId,
240: int systemId, boolean isExternal) throws Exception;
241:
242: public int addInternalEntityDecl(int entityName, int value,
243: boolean isExternal) throws Exception;
244:
245: public int addExternalEntityDecl(int entityName, int publicId,
246: int systemId, boolean isExternal) throws Exception;
247:
248: public int addUnparsedEntityDecl(int entityName, int publicId,
249: int systemId, int notationName, boolean isExternal)
250: throws Exception;
251:
252: public int addNotationDecl(int notationName, int publicId,
253: int systemId, boolean isExternal) throws Exception;
254:
255: /**
256: * Check for unparsed entity.
257: *
258: * @param entityName The string handle for the entity name.
259: * @return <code>true</code> if entityName is an unparsed entity; otherwise
260: * <code>false</code> if entityName is not declared or not an unparsed entity.
261: */
262: public boolean isUnparsedEntity(int entityName);
263:
264: /**
265: * Check for declared notation.
266: *
267: * @param notationName The string handle for the notation name.
268: * @return <code>true</code> if notationName is a declared notation; otherwise
269: * <code>false</code> if notationName is not declared.
270: */
271: public boolean isNotationDeclared(int entityName);
272:
273: /**
274: * Remember a required but undeclared notation.
275: */
276: public void addRequiredNotation(int notationName,
277: Locator locator, int majorCode, int minorCode,
278: Object[] args);
279:
280: /**
281: * Check required but undeclared notations.
282: */
283: public void checkRequiredNotations() throws Exception;
284: }
285:
286: /**
287: * Return a unique identifier for the current reader.
288: */
289: public int getReaderId();
290:
291: /**
292: * Set the depth for the current reader.
293: */
294: public void setReaderDepth(int depth);
295:
296: /**
297: * Return the depth set for the current reader.
298: */
299: public int getReaderDepth();
300:
301: /**
302: * Return the current reader.
303: */
304: public EntityReader getEntityReader();
305:
306: /**
307: * This method is called by the reader subclasses at the
308: * end of input.
309: *
310: * @return The reader to use next.
311: * @exception java.lang.Exception
312: */
313: public EntityReader changeReaders() throws Exception;
314:
315: /**
316: * This interface is used to store and retrieve character
317: * sequences. The primary use is for a literal data buffer
318: * where we can construct the values for literal entity
319: * replacement text. When all of the characters for the
320: * replacement text have been added to the buffer, the
321: * contents are added to the string pool for later use
322: * in constructing a StringReader if the entity is referenced.
323: */
324: public interface CharBuffer {
325: /**
326: * Append a character to this buffer.
327: *
328: * @param ch The character.
329: */
330: public void append(char ch);
331:
332: /**
333: * Append characters to this buffer.
334: *
335: * @param chars The char array containing the characters.
336: * @param offset The offset within the char array of the first character to append.
337: * @param length The number of characters to append.
338: */
339: public void append(char[] chars, int offset, int length);
340:
341: /**
342: * Get the current length of the buffer. This is also the
343: * offset of the next character that is added to the buffer.
344: *
345: * @return The length of the buffer.
346: */
347: public int length();
348:
349: /**
350: * Add a region of this buffer to the string pool.
351: *
352: * @param offset The offset within this buffer of the first character of the string.
353: * @param length The number of characters in the string.
354: * @return The <code>StringPool</code> handle of the string.
355: */
356: public int addString(int offset, int length);
357: }
358:
359: /**
360: * Set the character data handler.
361: */
362: public void setCharDataHandler(
363: XMLEntityHandler.CharDataHandler charDataHandler);
364:
365: /**
366: * Get the character data handler.
367: */
368: public XMLEntityHandler.CharDataHandler getCharDataHandler();
369:
370: /**
371: * Interface for passing character data.
372: */
373: public interface CharDataHandler {
374: /**
375: * Process character data, character array version
376: *
377: * @param chars character buffer to be processed
378: * @param offset offset in buffer where the data starts
379: * @param length length of characters to be processed
380: * @exception java.lang.Exception
381: */
382: public void processCharacters(char[] chars, int offset,
383: int length) throws Exception;
384:
385: /**
386: * Process character data, <code>StringPool</code> handle version
387: *
388: * @param stringHandle <code>StringPool</code> handle to the character data
389: * @exception java.lang.Exception
390: */
391: public void processCharacters(int stringHandle)
392: throws Exception;
393:
394: /**
395: * Process white space data, character array version
396: *
397: * @param chars character buffer to be processed
398: * @param offset offset in buffer where the data starts
399: * @param length length of whitespace to be processed
400: * @exception java.lang.Exception
401: */
402: public void processWhitespace(char[] chars, int offset,
403: int length) throws Exception;
404:
405: /**
406: * Process white space data, <code>StringPool</code> handle version
407: *
408: * @param stringHandle <code>StringPool</code> handle to the whitespace
409: * @exception java.lang.Exception
410: */
411: public void processWhitespace(int stringHandle)
412: throws Exception;
413: }
414:
415: /**
416: * This is the interface for scanners to process input data
417: * from entities without needing to know the details of the
418: * underlying storage of those entities, or their encodings.
419: *
420: * The methods in this interface have been refined over time
421: * to a rough balance between keeping the XML grammar dependent
422: * code within the scanner classes, and allowing high performance
423: * processing of XML documents.
424: */
425: public interface EntityReader {
426: /**
427: * Return the current offset within this reader.
428: *
429: * @return The offset.
430: */
431: public int currentOffset();
432:
433: /**
434: * Return the line number of the current position within the document that we are processing.
435: *
436: * @return The current line number.
437: */
438: public int getLineNumber();
439:
440: /**
441: * Return the column number of the current position within the document that we are processing.
442: *
443: * @return The current column number.
444: */
445: public int getColumnNumber();
446:
447: /**
448: * This method is provided for scanner implementations.
449: */
450: public void setInCDSect(boolean inCDSect);
451:
452: /**
453: * This method is provided for scanner implementations.
454: */
455: public boolean getInCDSect();
456:
457: /**
458: * Append the characters processed by this reader associated with <code>offset</code> and
459: * <code>length</code> to the <code>CharBuffer</code>.
460: *
461: * @param charBuffer The <code>CharBuffer</code> to append the characters to.
462: * @param offset The offset within this reader where the copy should start.
463: * @param length The length within this reader where the copy should stop.
464: */
465: public void append(XMLEntityHandler.CharBuffer charBuffer,
466: int offset, int length);
467:
468: /**
469: * Add a string to the <code>StringPool</code> from the characters scanned using this
470: * reader as described by <code>offset</code> and <code>length</code>.
471: *
472: * @param offset The offset within this reader where the characters start.
473: * @param length The length within this reader where the characters end.
474: * @return The <code>StringPool</code> handle for the string.
475: */
476: public int addString(int offset, int length);
477:
478: /**
479: * Add a symbol to the <code>StringPool</code> from the characters scanned using this
480: * reader as described by <code>offset</code> and <code>length</code>.
481: *
482: * @param offset The offset within this reader where the characters start.
483: * @param length The length within this reader where the characters end.
484: * @return The <code>StringPool</code> handle for the symbol.
485: */
486: public int addSymbol(int offset, int length);
487:
488: /**
489: * Test that the current character is a <code>ch</code> character.
490: *
491: * @param ch The character to match against.
492: * @param skipPastChar If <code>true</code>, we advance past the matched character.
493: * @return <code>true</code> if the current character is a <code>ch</code> character;
494: * <code>false</code> otherwise.
495: * @exception java.lang.Exception
496: */
497: public boolean lookingAtChar(char ch, boolean skipPastChar)
498: throws Exception;
499:
500: /**
501: * Test that the current character is valid.
502: *
503: * @param skipPastChar If <code>true</code>, we advance past the valid character.
504: * @return <code>true</code> if the current character is valid;
505: * <code>false</code> otherwise.
506: * @exception java.lang.Exception
507: */
508: public boolean lookingAtValidChar(boolean skipPastChar)
509: throws Exception;
510:
511: /**
512: * Test that the current character is a whitespace character.
513: *
514: * @param skipPastChar If <code>true</code>, we advance past the whitespace character.
515: * @return <code>true</code> if the current character is whitespace;
516: * <code>false</code> otherwise.
517: * @exception java.lang.Exception
518: */
519: public boolean lookingAtSpace(boolean skipPastChar)
520: throws Exception;
521:
522: /**
523: * Advance through the input data up to the next <code>ch</code> character.
524: *
525: * @param ch The character to search for.
526: * @exception java.lang.Exception
527: */
528: public void skipToChar(char ch) throws Exception;
529:
530: /**
531: * Skip past whitespace characters starting at the current position.
532: * @exception java.lang.Exception
533: */
534: public void skipPastSpaces() throws Exception;
535:
536: /**
537: * Skip past a sequence of characters that match the XML definition of a Name.
538: * @exception java.lang.Exception
539: */
540: public void skipPastName(char fastcheck) throws Exception;
541:
542: /**
543: * Skip past a sequence of characters that match the XML definition of an Nmtoken.
544: * @exception java.lang.Exception
545: */
546: public void skipPastNmtoken(char fastcheck) throws Exception;
547:
548: /**
549: * Skip past a sequence of characters that matches the specified character array.
550: *
551: * @param s The characters to match.
552: * @return <code>true</code> if the current character is valid;
553: * <code>false</code> otherwise.
554: * @exception java.lang.Exception
555: */
556: public boolean skippedString(char[] s) throws Exception;
557:
558: /**
559: * Scan an invalid character.
560: *
561: * @return The invalid character as an integer, or -1 if there was a bad encoding.
562: * @exception java.lang.Exception
563: */
564: public int scanInvalidChar() throws Exception;
565:
566: /**
567: * Scan a character reference.
568: *
569: * @return The value of the character, or one of the following error codes:
570: *
571: * CHARREF_RESULT_SEMICOLON_REQUIRED
572: * CHARREF_RESULT_INVALID_CHAR
573: * CHARREF_RESULT_OUT_OF_RANGE
574: * @exception java.lang.Exception
575: */
576: public int scanCharRef(boolean isHexadecimal) throws Exception;
577:
578: /**
579: * Scan a string literal.
580: *
581: * @return The <code>StringPool</code> handle for the string that
582: * was scanned, or one of the following error codes:
583: *
584: * STRINGLIT_RESULT_QUOTE_REQUIRED
585: * STRINGLIT_RESULT_INVALID_CHAR
586: * @exception java.lang.Exception
587: */
588: public int scanStringLiteral() throws Exception;
589:
590: /**
591: * Scan an attribute value.
592: *
593: * @param qchar The initial quote character, either a single or double quote.
594: * @return The <code>StringPool</code> handle for the string that
595: * was scanned, or one of the following error codes:
596: *
597: * ATTVALUE_RESULT_COMPLEX
598: * ATTVALUE_RESULT_LESSTHAN
599: * ATTVALUE_RESULT_INVALID_CHAR
600: * @exception java.lang.Exception
601: */
602: public int scanAttValue(char qchar, boolean asSymbol)
603: throws Exception;
604:
605: /**
606: * Scan an entity value.
607: *
608: * @param qchar The initial quote character, either a single or double quote.
609: * @return The <code>StringPool</code> handle for the string that
610: * was scanned, or one of the following error codes:
611: *
612: * ENTITYVALUE_RESULT_FINISHED
613: * ENTITYVALUE_RESULT_REFERENCE
614: * ENTITYVALUE_RESULT_PEREF
615: * ENTITYVALUE_RESULT_INVALID_CHAR
616: * ENTITYVALUE_RESULT_END_OF_INPUT
617: * @exception java.lang.Exception
618: */
619: public int scanEntityValue(int qchar, boolean createString)
620: throws Exception;
621:
622: /**
623: * Add a sequence of characters that match the XML definition of a Name to the <code>StringPool</code>.
624: *
625: * If we find a name at the current position we will add it to the <code>StringPool</code>
626: * as a symbol and will return the string pool handle for that symbol to the caller.
627: *
628: * @param fastcheck A character that is not a legal name character that is provided as a
629: * hint to the reader of a character likely to terminate the Name.
630: * @return The <code>StringPool</code> handle for the name that was scanned,
631: * or -1 if a name was not found at the current position within the input data.
632: * @exception java.lang.Exception
633: */
634: public int scanName(char fastcheck) throws Exception;
635:
636: /**
637: * Scan the name that is expected at the current position in the document.
638: *
639: * This method is invoked when we are scanning the element type in an end tag
640: * that must match the element type in the corresponding start tag.
641: *
642: * @param fastcheck A character that is not a legal name character that is provided as a
643: * hint to the reader of a character likely to terminate the Name.
644: * @param expectedName The characters of the name we expect.
645: * @return <code>true</code> if we scanned the name we expected to find; otherwise
646: * <code>false</code> if we did not.
647: * @exception java.lang.Exception
648: */
649: public boolean scanExpectedName(char fastcheck,
650: StringPool.CharArrayRange expectedName)
651: throws Exception;
652:
653: /**
654: * Add a sequence of characters that match the XML Namespaces definition of a QName
655: * to the <code>StringPool</code>.
656: *
657: * If we find a QName at the current position we will add it to the <code>StringPool</code>
658: * and will return the string pool handle of that QName to the caller.
659: *
660: * @param fastcheck A character that is not a legal name character that is provided as a
661: * hint to the reader of a character likely to terminate the Name.
662: * <!--
663: * @return The <code>StringPool</code> handle for the QName that was scanned,
664: * or -1 if a name was not found at the current position within the input data.
665: * -->
666: * @exception java.lang.Exception
667: */
668: public void scanQName(char fastcheck, QName qname)
669: throws Exception;
670:
671: /**
672: * Skip through the input while we are looking at character data.
673: *
674: * @param elementType The element type handle in the StringPool.
675: * @return One of the following result codes:
676: *
677: * CONTENT_RESULT_START_OF_PI
678: * CONTENT_RESULT_START_OF_COMMENT
679: * CONTENT_RESULT_START_OF_CDSECT
680: * CONTENT_RESULT_END_OF_CDSECT
681: * CONTENT_RESULT_START_OF_ETAG
682: * CONTENT_RESULT_MATCHING_ETAG
683: * CONTENT_RESULT_START_OF_ELEMENT
684: * CONTENT_RESULT_START_OF_CHARREF
685: * CONTENT_RESULT_START_OF_ENTITYREF
686: * CONTENT_RESULT_INVALID_CHAR
687: * CONTENT_RESULT_MARKUP_NOT_RECOGNIZED
688: * CONTENT_RESULT_MARKUP_END_OF_INPUT
689: * CONTENT_RESULT_REFERENCE_END_OF_INPUT
690: * @exception java.lang.Exception
691: */
692: public int scanContent(QName element) throws Exception;
693: }
694: }
|