1 /* 2 * Copyright (c) 2004, 2011, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 * 25 * THIS FILE WAS MODIFIED BY SUN MICROSYSTEMS, INC. 26 */ 27 28 package com.sun.xml.internal.fastinfoset.sax; 29 30 import com.sun.xml.internal.fastinfoset.Decoder; 31 import com.sun.xml.internal.fastinfoset.DecoderStateTables; 32 import com.sun.xml.internal.fastinfoset.EncodingConstants; 33 import com.sun.xml.internal.fastinfoset.QualifiedName; 34 import com.sun.xml.internal.fastinfoset.algorithm.BuiltInEncodingAlgorithmFactory; 35 import com.sun.xml.internal.fastinfoset.algorithm.BuiltInEncodingAlgorithmState; 36 import com.sun.xml.internal.org.jvnet.fastinfoset.sax.EncodingAlgorithmContentHandler; 37 import com.sun.xml.internal.org.jvnet.fastinfoset.sax.FastInfosetReader; 38 import com.sun.xml.internal.org.jvnet.fastinfoset.sax.PrimitiveTypeContentHandler; 39 import com.sun.xml.internal.fastinfoset.util.CharArray; 40 import com.sun.xml.internal.fastinfoset.util.CharArrayString; 41 import java.io.IOException; 42 import java.io.InputStream; 43 import java.net.URL; 44 import java.util.Map; 45 import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithm; 46 import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithmException; 47 import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithmIndexes; 48 import com.sun.xml.internal.org.jvnet.fastinfoset.FastInfosetException; 49 import org.xml.sax.ContentHandler; 50 import org.xml.sax.DTDHandler; 51 import org.xml.sax.EntityResolver; 52 import org.xml.sax.ErrorHandler; 53 import org.xml.sax.InputSource; 54 import org.xml.sax.SAXException; 55 import org.xml.sax.SAXNotRecognizedException; 56 import org.xml.sax.SAXNotSupportedException; 57 import org.xml.sax.SAXParseException; 58 import org.xml.sax.ext.LexicalHandler; 59 import org.xml.sax.helpers.DefaultHandler; 60 import com.sun.xml.internal.fastinfoset.CommonResourceBundle; 61 import java.util.logging.Level; 62 import java.util.logging.Logger; 63 import org.xml.sax.ext.DeclHandler; 64 65 /** 66 * The Fast Infoset SAX parser. 67 * <p> 68 * Instantiate this parser to parse a fast infoset document in accordance 69 * with the SAX API. 70 * 71 * <p> 72 * More than one fast infoset document may be decoded from the 73 * {@link java.io.InputStream}. 74 */ 75 public class SAXDocumentParser extends Decoder implements FastInfosetReader { 76 private static final Logger logger = Logger.getLogger(SAXDocumentParser.class.getName()); 77 78 /* 79 * Empty lexical handler used by default to report 80 * lexical-based events 81 */ 82 private static final class LexicalHandlerImpl implements LexicalHandler { 83 public void comment(char[] ch, int start, int end) { } 84 85 public void startDTD(String name, String publicId, String systemId) { } 86 public void endDTD() { } 87 88 public void startEntity(String name) { } 89 public void endEntity(String name) { } 90 91 public void startCDATA() { } 92 public void endCDATA() { } 93 }; 94 95 /* 96 * Empty DTD declaration handler used by default to report 97 * DTD declaration-based events 98 */ 99 private static final class DeclHandlerImpl implements DeclHandler { 100 public void elementDecl(String name, String model) throws SAXException { 101 } 102 103 public void attributeDecl(String eName, String aName, 104 String type, String mode, String value) throws SAXException { 105 } 106 107 public void internalEntityDecl(String name, 108 String value) throws SAXException { 109 } 110 111 public void externalEntityDecl(String name, 112 String publicId, String systemId) throws SAXException { 113 } 114 } 115 116 /** 117 * SAX Namespace attributes features 118 */ 119 protected boolean _namespacePrefixesFeature = false; 120 121 /** 122 * Reference to entity resolver. 123 */ 124 protected EntityResolver _entityResolver; 125 126 /** 127 * Reference to dtd handler. 128 */ 129 protected DTDHandler _dtdHandler; 130 131 /** 132 * Reference to content handler. 133 */ 134 protected ContentHandler _contentHandler; 135 136 /** 137 * Reference to error handler. 138 */ 139 protected ErrorHandler _errorHandler; 140 141 /** 142 * Reference to lexical handler. 143 */ 144 protected LexicalHandler _lexicalHandler; 145 146 /** 147 * Reference to DTD declaration handler. 148 */ 149 protected DeclHandler _declHandler; 150 151 protected EncodingAlgorithmContentHandler _algorithmHandler; 152 153 protected PrimitiveTypeContentHandler _primitiveHandler; 154 155 protected BuiltInEncodingAlgorithmState builtInAlgorithmState = 156 new BuiltInEncodingAlgorithmState(); 157 158 protected AttributesHolder _attributes; 159 160 protected int[] _namespacePrefixes = new int[16]; 161 162 protected int _namespacePrefixesIndex; 163 164 protected boolean _clearAttributes = false; 165 166 /** Creates a new instance of DocumetParser2 */ 167 public SAXDocumentParser() { 168 DefaultHandler handler = new DefaultHandler(); 169 _attributes = new AttributesHolder(_registeredEncodingAlgorithms); 170 171 _entityResolver = handler; 172 _dtdHandler = handler; 173 _contentHandler = handler; 174 _errorHandler = handler; 175 _lexicalHandler = new LexicalHandlerImpl(); 176 _declHandler = new DeclHandlerImpl(); 177 } 178 179 protected void resetOnError() { 180 _clearAttributes = false; 181 _attributes.clear(); 182 _namespacePrefixesIndex = 0; 183 184 if (_v != null) { 185 _v.prefix.clearCompletely(); 186 } 187 _duplicateAttributeVerifier.clear(); 188 } 189 190 // XMLReader interface 191 192 public boolean getFeature(String name) 193 throws SAXNotRecognizedException, SAXNotSupportedException { 194 if (name.equals(Features.NAMESPACES_FEATURE)) { 195 return true; 196 } else if (name.equals(Features.NAMESPACE_PREFIXES_FEATURE)) { 197 return _namespacePrefixesFeature; 198 } else if (name.equals(Features.STRING_INTERNING_FEATURE) || 199 name.equals(FastInfosetReader.STRING_INTERNING_PROPERTY)) { 200 return getStringInterning(); 201 } else { 202 throw new SAXNotRecognizedException( 203 CommonResourceBundle.getInstance().getString("message.featureNotSupported") + name); 204 } 205 } 206 207 public void setFeature(String name, boolean value) 208 throws SAXNotRecognizedException, SAXNotSupportedException { 209 if (name.equals(Features.NAMESPACES_FEATURE)) { 210 if (value == false) { 211 throw new SAXNotSupportedException(name + ":" + value); 212 } 213 } else if (name.equals(Features.NAMESPACE_PREFIXES_FEATURE)) { 214 _namespacePrefixesFeature = value; 215 } else if (name.equals(Features.STRING_INTERNING_FEATURE) || 216 name.equals(FastInfosetReader.STRING_INTERNING_PROPERTY)) { 217 setStringInterning(value); 218 } else { 219 throw new SAXNotRecognizedException( 220 CommonResourceBundle.getInstance().getString("message.featureNotSupported") + name); 221 } 222 } 223 224 public Object getProperty(String name) 225 throws SAXNotRecognizedException, SAXNotSupportedException { 226 if (name.equals(Properties.LEXICAL_HANDLER_PROPERTY)) { 227 return getLexicalHandler(); 228 } else if (name.equals(Properties.DTD_DECLARATION_HANDLER_PROPERTY)) { 229 return getDeclHandler(); 230 } else if (name.equals(FastInfosetReader.EXTERNAL_VOCABULARIES_PROPERTY)) { 231 return getExternalVocabularies(); 232 } else if (name.equals(FastInfosetReader.REGISTERED_ENCODING_ALGORITHMS_PROPERTY)) { 233 return getRegisteredEncodingAlgorithms(); 234 } else if (name.equals(FastInfosetReader.ENCODING_ALGORITHM_CONTENT_HANDLER_PROPERTY)) { 235 return getEncodingAlgorithmContentHandler(); 236 } else if (name.equals(FastInfosetReader.PRIMITIVE_TYPE_CONTENT_HANDLER_PROPERTY)) { 237 return getPrimitiveTypeContentHandler(); 238 } else { 239 throw new SAXNotRecognizedException(CommonResourceBundle.getInstance(). 240 getString("message.propertyNotRecognized", new Object[]{name})); 241 } 242 } 243 244 public void setProperty(String name, Object value) 245 throws SAXNotRecognizedException, SAXNotSupportedException { 246 if (name.equals(Properties.LEXICAL_HANDLER_PROPERTY)) { 247 if (value instanceof LexicalHandler) { 248 setLexicalHandler((LexicalHandler)value); 249 } else { 250 throw new SAXNotSupportedException(Properties.LEXICAL_HANDLER_PROPERTY); 251 } 252 } else if (name.equals(Properties.DTD_DECLARATION_HANDLER_PROPERTY)) { 253 if (value instanceof DeclHandler) { 254 setDeclHandler((DeclHandler)value); 255 } else { 256 throw new SAXNotSupportedException(Properties.LEXICAL_HANDLER_PROPERTY); 257 } 258 } else if (name.equals(FastInfosetReader.EXTERNAL_VOCABULARIES_PROPERTY)) { 259 if (value instanceof Map) { 260 setExternalVocabularies((Map)value); 261 } else { 262 throw new SAXNotSupportedException(FastInfosetReader.EXTERNAL_VOCABULARIES_PROPERTY); 263 } 264 } else if (name.equals(FastInfosetReader.REGISTERED_ENCODING_ALGORITHMS_PROPERTY)) { 265 if (value instanceof Map) { 266 setRegisteredEncodingAlgorithms((Map)value); 267 } else { 268 throw new SAXNotSupportedException(FastInfosetReader.REGISTERED_ENCODING_ALGORITHMS_PROPERTY); 269 } 270 } else if (name.equals(FastInfosetReader.ENCODING_ALGORITHM_CONTENT_HANDLER_PROPERTY)) { 271 if (value instanceof EncodingAlgorithmContentHandler) { 272 setEncodingAlgorithmContentHandler((EncodingAlgorithmContentHandler)value); 273 } else { 274 throw new SAXNotSupportedException(FastInfosetReader.ENCODING_ALGORITHM_CONTENT_HANDLER_PROPERTY); 275 } 276 } else if (name.equals(FastInfosetReader.PRIMITIVE_TYPE_CONTENT_HANDLER_PROPERTY)) { 277 if (value instanceof PrimitiveTypeContentHandler) { 278 setPrimitiveTypeContentHandler((PrimitiveTypeContentHandler)value); 279 } else { 280 throw new SAXNotSupportedException(FastInfosetReader.PRIMITIVE_TYPE_CONTENT_HANDLER_PROPERTY); 281 } 282 } else if (name.equals(FastInfosetReader.BUFFER_SIZE_PROPERTY)) { 283 if (value instanceof Integer) { 284 setBufferSize(((Integer)value).intValue()); 285 } else { 286 throw new SAXNotSupportedException(FastInfosetReader.BUFFER_SIZE_PROPERTY); 287 } 288 } else { 289 throw new SAXNotRecognizedException(CommonResourceBundle.getInstance(). 290 getString("message.propertyNotRecognized", new Object[]{name})); 291 } 292 } 293 294 public void setEntityResolver(EntityResolver resolver) { 295 _entityResolver = resolver; 296 } 297 298 public EntityResolver getEntityResolver() { 299 return _entityResolver; 300 } 301 302 public void setDTDHandler(DTDHandler handler) { 303 _dtdHandler = handler; 304 } 305 306 public DTDHandler getDTDHandler() { 307 return _dtdHandler; 308 } 309 public void setContentHandler(ContentHandler handler) { 310 _contentHandler = handler; 311 } 312 313 public ContentHandler getContentHandler() { 314 return _contentHandler; 315 } 316 317 public void setErrorHandler(ErrorHandler handler) { 318 _errorHandler = handler; 319 } 320 321 public ErrorHandler getErrorHandler() { 322 return _errorHandler; 323 } 324 325 public void parse(InputSource input) throws IOException, SAXException { 326 try { 327 InputStream s = input.getByteStream(); 328 if (s == null) { 329 String systemId = input.getSystemId(); 330 if (systemId == null) { 331 throw new SAXException(CommonResourceBundle.getInstance().getString("message.inputSource")); 332 } 333 parse(systemId); 334 } else { 335 parse(s); 336 } 337 } catch (FastInfosetException e) { 338 logger.log(Level.FINE, "parsing error", e); 339 throw new SAXException(e); 340 } 341 } 342 343 public void parse(String systemId) throws IOException, SAXException { 344 try { 345 systemId = SystemIdResolver.getAbsoluteURI(systemId); 346 parse(new URL(systemId).openStream()); 347 } catch (FastInfosetException e) { 348 logger.log(Level.FINE, "parsing error", e); 349 throw new SAXException(e); 350 } 351 } 352 353 354 355 356 // FastInfosetReader 357 358 public final void parse(InputStream s) throws IOException, FastInfosetException, SAXException { 359 setInputStream(s); 360 parse(); 361 } 362 363 public void setLexicalHandler(LexicalHandler handler) { 364 _lexicalHandler = handler; 365 } 366 367 public LexicalHandler getLexicalHandler() { 368 return _lexicalHandler; 369 } 370 371 public void setDeclHandler(DeclHandler handler) { 372 _declHandler = handler; 373 } 374 375 public DeclHandler getDeclHandler() { 376 return _declHandler; 377 } 378 379 public void setEncodingAlgorithmContentHandler(EncodingAlgorithmContentHandler handler) { 380 _algorithmHandler = handler; 381 } 382 383 public EncodingAlgorithmContentHandler getEncodingAlgorithmContentHandler() { 384 return _algorithmHandler; 385 } 386 387 public void setPrimitiveTypeContentHandler(PrimitiveTypeContentHandler handler) { 388 _primitiveHandler = handler; 389 } 390 391 public PrimitiveTypeContentHandler getPrimitiveTypeContentHandler() { 392 return _primitiveHandler; 393 } 394 395 396 397 398 public final void parse() throws FastInfosetException, IOException { 399 if (_octetBuffer.length < _bufferSize) { 400 _octetBuffer = new byte[_bufferSize]; 401 } 402 403 try { 404 reset(); 405 decodeHeader(); 406 if (_parseFragments) 407 processDIIFragment(); 408 else 409 processDII(); 410 } catch (RuntimeException e) { 411 try { 412 _errorHandler.fatalError(new SAXParseException(e.getClass().getName(), null, e)); 413 } catch (Exception ee) { 414 } 415 resetOnError(); 416 // Wrap runtime exception 417 throw new FastInfosetException(e); 418 } catch (FastInfosetException e) { 419 try { 420 _errorHandler.fatalError(new SAXParseException(e.getClass().getName(), null, e)); 421 } catch (Exception ee) { 422 } 423 resetOnError(); 424 throw e; 425 } catch (IOException e) { 426 try { 427 _errorHandler.fatalError(new SAXParseException(e.getClass().getName(), null, e)); 428 } catch (Exception ee) { 429 } 430 resetOnError(); 431 throw e; 432 } 433 } 434 435 protected final void processDII() throws FastInfosetException, IOException { 436 try { 437 _contentHandler.startDocument(); 438 } catch (SAXException e) { 439 throw new FastInfosetException("processDII", e); 440 } 441 442 _b = read(); 443 if (_b > 0) { 444 processDIIOptionalProperties(); 445 } 446 447 // Decode one Document Type II, Comment IIs, PI IIs and one EII 448 boolean firstElementHasOccured = false; 449 boolean documentTypeDeclarationOccured = false; 450 while(!_terminate || !firstElementHasOccured) { 451 _b = read(); 452 switch(DecoderStateTables.DII(_b)) { 453 case DecoderStateTables.EII_NO_AIIS_INDEX_SMALL: 454 processEII(_elementNameTable._array[_b], false); 455 firstElementHasOccured = true; 456 break; 457 case DecoderStateTables.EII_AIIS_INDEX_SMALL: 458 processEII(_elementNameTable._array[_b & EncodingConstants.INTEGER_3RD_BIT_SMALL_MASK], true); 459 firstElementHasOccured = true; 460 break; 461 case DecoderStateTables.EII_INDEX_MEDIUM: 462 processEII(decodeEIIIndexMedium(), (_b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0); 463 firstElementHasOccured = true; 464 break; 465 case DecoderStateTables.EII_INDEX_LARGE: 466 processEII(decodeEIIIndexLarge(), (_b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0); 467 firstElementHasOccured = true; 468 break; 469 case DecoderStateTables.EII_LITERAL: 470 { 471 final QualifiedName qn = decodeLiteralQualifiedName( 472 _b & EncodingConstants.LITERAL_QNAME_PREFIX_NAMESPACE_NAME_MASK, 473 _elementNameTable.getNext()); 474 _elementNameTable.add(qn); 475 processEII(qn, (_b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0); 476 firstElementHasOccured = true; 477 break; 478 } 479 case DecoderStateTables.EII_NAMESPACES: 480 processEIIWithNamespaces(); 481 firstElementHasOccured = true; 482 break; 483 case DecoderStateTables.DOCUMENT_TYPE_DECLARATION_II: 484 { 485 if (documentTypeDeclarationOccured) { 486 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.secondOccurenceOfDTDII")); 487 } 488 documentTypeDeclarationOccured = true; 489 490 String system_identifier = ((_b & EncodingConstants.DOCUMENT_TYPE_SYSTEM_IDENTIFIER_FLAG) > 0) 491 ? decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherURI) : ""; 492 String public_identifier = ((_b & EncodingConstants.DOCUMENT_TYPE_PUBLIC_IDENTIFIER_FLAG) > 0) 493 ? decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherURI) : ""; 494 495 _b = read(); 496 while (_b == EncodingConstants.PROCESSING_INSTRUCTION) { 497 switch(decodeNonIdentifyingStringOnFirstBit()) { 498 case NISTRING_STRING: 499 if (_addToTable) { 500 _v.otherString.add(new CharArray(_charBuffer, 0, _charBufferLength, true)); 501 } 502 break; 503 case NISTRING_ENCODING_ALGORITHM: 504 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.processingIIWithEncodingAlgorithm")); 505 case NISTRING_INDEX: 506 break; 507 case NISTRING_EMPTY_STRING: 508 break; 509 } 510 _b = read(); 511 } 512 if ((_b & EncodingConstants.TERMINATOR) != EncodingConstants.TERMINATOR) { 513 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.processingInstructionIIsNotTerminatedCorrectly")); 514 } 515 if (_b == EncodingConstants.DOUBLE_TERMINATOR) { 516 _terminate = true; 517 } 518 519 if (_notations != null) _notations.clear(); 520 if (_unparsedEntities != null) _unparsedEntities.clear(); 521 /* 522 * TODO 523 * Report All events associated with DTD, PIs, notations etc 524 */ 525 break; 526 } 527 case DecoderStateTables.COMMENT_II: 528 processCommentII(); 529 break; 530 case DecoderStateTables.PROCESSING_INSTRUCTION_II: 531 processProcessingII(); 532 break; 533 case DecoderStateTables.TERMINATOR_DOUBLE: 534 _doubleTerminate = true; 535 case DecoderStateTables.TERMINATOR_SINGLE: 536 _terminate = true; 537 break; 538 default: 539 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.IllegalStateDecodingDII")); 540 } 541 } 542 543 // Decode any remaining Comment IIs, PI IIs 544 while(!_terminate) { 545 _b = read(); 546 switch(DecoderStateTables.DII(_b)) { 547 case DecoderStateTables.COMMENT_II: 548 processCommentII(); 549 break; 550 case DecoderStateTables.PROCESSING_INSTRUCTION_II: 551 processProcessingII(); 552 break; 553 case DecoderStateTables.TERMINATOR_DOUBLE: 554 _doubleTerminate = true; 555 case DecoderStateTables.TERMINATOR_SINGLE: 556 _terminate = true; 557 break; 558 default: 559 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.IllegalStateDecodingDII")); 560 } 561 } 562 563 try { 564 _contentHandler.endDocument(); 565 } catch (SAXException e) { 566 throw new FastInfosetException("processDII", e); 567 } 568 } 569 570 protected final void processDIIFragment() throws FastInfosetException, IOException { 571 try { 572 _contentHandler.startDocument(); 573 } catch (SAXException e) { 574 throw new FastInfosetException("processDII", e); 575 } 576 577 _b = read(); 578 if (_b > 0) { 579 processDIIOptionalProperties(); 580 } 581 582 while(!_terminate) { 583 _b = read(); 584 switch(DecoderStateTables.EII(_b)) { 585 case DecoderStateTables.EII_NO_AIIS_INDEX_SMALL: 586 processEII(_elementNameTable._array[_b], false); 587 break; 588 case DecoderStateTables.EII_AIIS_INDEX_SMALL: 589 processEII(_elementNameTable._array[_b & EncodingConstants.INTEGER_3RD_BIT_SMALL_MASK], true); 590 break; 591 case DecoderStateTables.EII_INDEX_MEDIUM: 592 processEII(decodeEIIIndexMedium(), (_b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0); 593 break; 594 case DecoderStateTables.EII_INDEX_LARGE: 595 processEII(decodeEIIIndexLarge(), (_b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0); 596 break; 597 case DecoderStateTables.EII_LITERAL: 598 { 599 final QualifiedName qn = decodeLiteralQualifiedName( 600 _b & EncodingConstants.LITERAL_QNAME_PREFIX_NAMESPACE_NAME_MASK, 601 _elementNameTable.getNext()); 602 _elementNameTable.add(qn); 603 processEII(qn, (_b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0); 604 break; 605 } 606 case DecoderStateTables.EII_NAMESPACES: 607 processEIIWithNamespaces(); 608 break; 609 case DecoderStateTables.CII_UTF8_SMALL_LENGTH: 610 _octetBufferLength = (_b & EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_MASK) 611 + 1; 612 processUtf8CharacterString(); 613 break; 614 case DecoderStateTables.CII_UTF8_MEDIUM_LENGTH: 615 _octetBufferLength = read() + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_LIMIT; 616 processUtf8CharacterString(); 617 break; 618 case DecoderStateTables.CII_UTF8_LARGE_LENGTH: 619 _octetBufferLength = ((read() << 24) | 620 (read() << 16) | 621 (read() << 8) | 622 read()) 623 + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_MEDIUM_LIMIT; 624 processUtf8CharacterString(); 625 break; 626 case DecoderStateTables.CII_UTF16_SMALL_LENGTH: 627 _octetBufferLength = (_b & EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_MASK) 628 + 1; 629 decodeUtf16StringAsCharBuffer(); 630 if ((_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0) { 631 _characterContentChunkTable.add(_charBuffer, _charBufferLength); 632 } 633 634 try { 635 _contentHandler.characters(_charBuffer, 0, _charBufferLength); 636 } catch (SAXException e) { 637 throw new FastInfosetException("processCII", e); 638 } 639 break; 640 case DecoderStateTables.CII_UTF16_MEDIUM_LENGTH: 641 _octetBufferLength = read() + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_LIMIT; 642 decodeUtf16StringAsCharBuffer(); 643 if ((_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0) { 644 _characterContentChunkTable.add(_charBuffer, _charBufferLength); 645 } 646 647 try { 648 _contentHandler.characters(_charBuffer, 0, _charBufferLength); 649 } catch (SAXException e) { 650 throw new FastInfosetException("processCII", e); 651 } 652 break; 653 case DecoderStateTables.CII_UTF16_LARGE_LENGTH: 654 _octetBufferLength = ((read() << 24) | 655 (read() << 16) | 656 (read() << 8) | 657 read()) 658 + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_MEDIUM_LIMIT; 659 decodeUtf16StringAsCharBuffer(); 660 if ((_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0) { 661 _characterContentChunkTable.add(_charBuffer, _charBufferLength); 662 } 663 664 try { 665 _contentHandler.characters(_charBuffer, 0, _charBufferLength); 666 } catch (SAXException e) { 667 throw new FastInfosetException("processCII", e); 668 } 669 break; 670 case DecoderStateTables.CII_RA: 671 { 672 final boolean addToTable = (_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0; 673 674 // Decode resitricted alphabet integer 675 _identifier = (_b & 0x02) << 6; 676 _b = read(); 677 _identifier |= (_b & 0xFC) >> 2; 678 679 decodeOctetsOnSeventhBitOfNonIdentifyingStringOnThirdBit(_b); 680 681 decodeRestrictedAlphabetAsCharBuffer(); 682 683 if (addToTable) { 684 _characterContentChunkTable.add(_charBuffer, _charBufferLength); 685 } 686 687 try { 688 _contentHandler.characters(_charBuffer, 0, _charBufferLength); 689 } catch (SAXException e) { 690 throw new FastInfosetException("processCII", e); 691 } 692 break; 693 } 694 case DecoderStateTables.CII_EA: 695 { 696 final boolean addToTable = (_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0; 697 698 // Decode encoding algorithm integer 699 _identifier = (_b & 0x02) << 6; 700 _b = read(); 701 _identifier |= (_b & 0xFC) >> 2; 702 703 decodeOctetsOnSeventhBitOfNonIdentifyingStringOnThirdBit(_b); 704 705 processCIIEncodingAlgorithm(addToTable); 706 break; 707 } 708 case DecoderStateTables.CII_INDEX_SMALL: 709 { 710 final int index = _b & EncodingConstants.INTEGER_4TH_BIT_SMALL_MASK; 711 try { 712 _contentHandler.characters(_characterContentChunkTable._array, 713 _characterContentChunkTable._offset[index], 714 _characterContentChunkTable._length[index]); 715 } catch (SAXException e) { 716 throw new FastInfosetException("processCII", e); 717 } 718 break; 719 } 720 case DecoderStateTables.CII_INDEX_MEDIUM: 721 { 722 final int index = (((_b & EncodingConstants.INTEGER_4TH_BIT_MEDIUM_MASK) << 8) | read()) 723 + EncodingConstants.INTEGER_4TH_BIT_SMALL_LIMIT; 724 try { 725 _contentHandler.characters(_characterContentChunkTable._array, 726 _characterContentChunkTable._offset[index], 727 _characterContentChunkTable._length[index]); 728 } catch (SAXException e) { 729 throw new FastInfosetException("processCII", e); 730 } 731 break; 732 } 733 case DecoderStateTables.CII_INDEX_LARGE: 734 { 735 final int index = (((_b & EncodingConstants.INTEGER_4TH_BIT_LARGE_MASK) << 16) | 736 (read() << 8) | 737 read()) 738 + EncodingConstants.INTEGER_4TH_BIT_MEDIUM_LIMIT; 739 740 try { 741 _contentHandler.characters(_characterContentChunkTable._array, 742 _characterContentChunkTable._offset[index], 743 _characterContentChunkTable._length[index]); 744 } catch (SAXException e) { 745 throw new FastInfosetException("processCII", e); 746 } 747 break; 748 } 749 case DecoderStateTables.CII_INDEX_LARGE_LARGE: 750 { 751 final int index = ((read() << 16) | 752 (read() << 8) | 753 read()) 754 + EncodingConstants.INTEGER_4TH_BIT_LARGE_LIMIT; 755 756 try { 757 _contentHandler.characters(_characterContentChunkTable._array, 758 _characterContentChunkTable._offset[index], 759 _characterContentChunkTable._length[index]); 760 } catch (SAXException e) { 761 throw new FastInfosetException("processCII", e); 762 } 763 break; 764 } 765 case DecoderStateTables.COMMENT_II: 766 processCommentII(); 767 break; 768 case DecoderStateTables.PROCESSING_INSTRUCTION_II: 769 processProcessingII(); 770 break; 771 case DecoderStateTables.UNEXPANDED_ENTITY_REFERENCE_II: 772 { 773 String entity_reference_name = decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherNCName); 774 775 String system_identifier = ((_b & EncodingConstants.UNEXPANDED_ENTITY_SYSTEM_IDENTIFIER_FLAG) > 0) 776 ? decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherURI) : ""; 777 String public_identifier = ((_b & EncodingConstants.UNEXPANDED_ENTITY_PUBLIC_IDENTIFIER_FLAG) > 0) 778 ? decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherURI) : ""; 779 780 try { 781 /* 782 * TODO 783 * Need to verify if the skippedEntity method: 784 * http://java.sun.com/j2se/1.4.2/docs/api/org/xml/sax/ContentHandler.html#skippedEntity(java.lang.String) 785 * is the correct method to call. It appears so but a more extensive 786 * check is necessary. 787 */ 788 _contentHandler.skippedEntity(entity_reference_name); 789 } catch (SAXException e) { 790 throw new FastInfosetException("processUnexpandedEntityReferenceII", e); 791 } 792 break; 793 } 794 case DecoderStateTables.TERMINATOR_DOUBLE: 795 _doubleTerminate = true; 796 case DecoderStateTables.TERMINATOR_SINGLE: 797 _terminate = true; 798 break; 799 default: 800 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.IllegalStateDecodingEII")); 801 } 802 } 803 804 try { 805 _contentHandler.endDocument(); 806 } catch (SAXException e) { 807 throw new FastInfosetException("processDII", e); 808 } 809 } 810 811 protected final void processDIIOptionalProperties() throws FastInfosetException, IOException { 812 // Optimize for the most common case 813 if (_b == EncodingConstants.DOCUMENT_INITIAL_VOCABULARY_FLAG) { 814 decodeInitialVocabulary(); 815 return; 816 } 817 818 if ((_b & EncodingConstants.DOCUMENT_ADDITIONAL_DATA_FLAG) > 0) { 819 decodeAdditionalData(); 820 /* 821 * TODO 822 * how to report the additional data? 823 */ 824 } 825 826 if ((_b & EncodingConstants.DOCUMENT_INITIAL_VOCABULARY_FLAG) > 0) { 827 decodeInitialVocabulary(); 828 } 829 830 if ((_b & EncodingConstants.DOCUMENT_NOTATIONS_FLAG) > 0) { 831 decodeNotations(); 832 /* 833 try { 834 _dtdHandler.notationDecl(name, public_identifier, system_identifier); 835 } catch (SAXException e) { 836 throw new IOException("NotationsDeclarationII"); 837 } 838 */ 839 } 840 841 if ((_b & EncodingConstants.DOCUMENT_UNPARSED_ENTITIES_FLAG) > 0) { 842 decodeUnparsedEntities(); 843 /* 844 try { 845 _dtdHandler.unparsedEntityDecl(name, public_identifier, system_identifier, notation_name); 846 } catch (SAXException e) { 847 throw new IOException("UnparsedEntitiesII"); 848 } 849 */ 850 } 851 852 if ((_b & EncodingConstants.DOCUMENT_CHARACTER_ENCODING_SCHEME) > 0) { 853 String characterEncodingScheme = decodeCharacterEncodingScheme(); 854 /* 855 * TODO 856 * how to report the character encoding scheme? 857 */ 858 } 859 860 if ((_b & EncodingConstants.DOCUMENT_STANDALONE_FLAG) > 0) { 861 boolean standalone = (read() > 0) ? true : false ; 862 /* 863 * TODO 864 * how to report the standalone flag? 865 */ 866 } 867 868 if ((_b & EncodingConstants.DOCUMENT_VERSION_FLAG) > 0) { 869 decodeVersion(); 870 /* 871 * TODO 872 * how to report the standalone flag? 873 */ 874 } 875 } 876 877 protected final void processEII(QualifiedName name, boolean hasAttributes) throws FastInfosetException, IOException { 878 if (_prefixTable._currentInScope[name.prefixIndex] != name.namespaceNameIndex) { 879 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.qNameOfEIINotInScope")); 880 } 881 882 if (hasAttributes) { 883 processAIIs(); 884 } 885 886 try { 887 _contentHandler.startElement(name.namespaceName, name.localName, name.qName, _attributes); 888 } catch (SAXException e) { 889 logger.log(Level.FINE, "processEII error", e); 890 throw new FastInfosetException("processEII", e); 891 } 892 893 if (_clearAttributes) { 894 _attributes.clear(); 895 _clearAttributes = false; 896 } 897 898 while(!_terminate) { 899 _b = read(); 900 switch(DecoderStateTables.EII(_b)) { 901 case DecoderStateTables.EII_NO_AIIS_INDEX_SMALL: 902 processEII(_elementNameTable._array[_b], false); 903 break; 904 case DecoderStateTables.EII_AIIS_INDEX_SMALL: 905 processEII(_elementNameTable._array[_b & EncodingConstants.INTEGER_3RD_BIT_SMALL_MASK], true); 906 break; 907 case DecoderStateTables.EII_INDEX_MEDIUM: 908 processEII(decodeEIIIndexMedium(), (_b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0); 909 break; 910 case DecoderStateTables.EII_INDEX_LARGE: 911 processEII(decodeEIIIndexLarge(), (_b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0); 912 break; 913 case DecoderStateTables.EII_LITERAL: 914 { 915 final QualifiedName qn = decodeLiteralQualifiedName( 916 _b & EncodingConstants.LITERAL_QNAME_PREFIX_NAMESPACE_NAME_MASK, 917 _elementNameTable.getNext()); 918 _elementNameTable.add(qn); 919 processEII(qn, (_b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0); 920 break; 921 } 922 case DecoderStateTables.EII_NAMESPACES: 923 processEIIWithNamespaces(); 924 break; 925 case DecoderStateTables.CII_UTF8_SMALL_LENGTH: 926 _octetBufferLength = (_b & EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_MASK) 927 + 1; 928 processUtf8CharacterString(); 929 break; 930 case DecoderStateTables.CII_UTF8_MEDIUM_LENGTH: 931 _octetBufferLength = read() + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_LIMIT; 932 processUtf8CharacterString(); 933 break; 934 case DecoderStateTables.CII_UTF8_LARGE_LENGTH: 935 _octetBufferLength = ((read() << 24) | 936 (read() << 16) | 937 (read() << 8) | 938 read()) 939 + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_MEDIUM_LIMIT; 940 processUtf8CharacterString(); 941 break; 942 case DecoderStateTables.CII_UTF16_SMALL_LENGTH: 943 _octetBufferLength = (_b & EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_MASK) 944 + 1; 945 decodeUtf16StringAsCharBuffer(); 946 if ((_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0) { 947 _characterContentChunkTable.add(_charBuffer, _charBufferLength); 948 } 949 950 try { 951 _contentHandler.characters(_charBuffer, 0, _charBufferLength); 952 } catch (SAXException e) { 953 throw new FastInfosetException("processCII", e); 954 } 955 break; 956 case DecoderStateTables.CII_UTF16_MEDIUM_LENGTH: 957 _octetBufferLength = read() + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_LIMIT; 958 decodeUtf16StringAsCharBuffer(); 959 if ((_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0) { 960 _characterContentChunkTable.add(_charBuffer, _charBufferLength); 961 } 962 963 try { 964 _contentHandler.characters(_charBuffer, 0, _charBufferLength); 965 } catch (SAXException e) { 966 throw new FastInfosetException("processCII", e); 967 } 968 break; 969 case DecoderStateTables.CII_UTF16_LARGE_LENGTH: 970 _octetBufferLength = ((read() << 24) | 971 (read() << 16) | 972 (read() << 8) | 973 read()) 974 + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_MEDIUM_LIMIT; 975 decodeUtf16StringAsCharBuffer(); 976 if ((_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0) { 977 _characterContentChunkTable.add(_charBuffer, _charBufferLength); 978 } 979 980 try { 981 _contentHandler.characters(_charBuffer, 0, _charBufferLength); 982 } catch (SAXException e) { 983 throw new FastInfosetException("processCII", e); 984 } 985 break; 986 case DecoderStateTables.CII_RA: 987 { 988 final boolean addToTable = (_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0; 989 990 // Decode resitricted alphabet integer 991 _identifier = (_b & 0x02) << 6; 992 _b = read(); 993 _identifier |= (_b & 0xFC) >> 2; 994 995 decodeOctetsOnSeventhBitOfNonIdentifyingStringOnThirdBit(_b); 996 997 decodeRestrictedAlphabetAsCharBuffer(); 998 999 if (addToTable) { 1000 _characterContentChunkTable.add(_charBuffer, _charBufferLength); 1001 } 1002 1003 try { 1004 _contentHandler.characters(_charBuffer, 0, _charBufferLength); 1005 } catch (SAXException e) { 1006 throw new FastInfosetException("processCII", e); 1007 } 1008 break; 1009 } 1010 case DecoderStateTables.CII_EA: 1011 { 1012 final boolean addToTable = (_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0; 1013 // Decode encoding algorithm integer 1014 _identifier = (_b & 0x02) << 6; 1015 _b = read(); 1016 _identifier |= (_b & 0xFC) >> 2; 1017 1018 decodeOctetsOnSeventhBitOfNonIdentifyingStringOnThirdBit(_b); 1019 1020 processCIIEncodingAlgorithm(addToTable); 1021 break; 1022 } 1023 case DecoderStateTables.CII_INDEX_SMALL: 1024 { 1025 final int index = _b & EncodingConstants.INTEGER_4TH_BIT_SMALL_MASK; 1026 try { 1027 _contentHandler.characters(_characterContentChunkTable._array, 1028 _characterContentChunkTable._offset[index], 1029 _characterContentChunkTable._length[index]); 1030 } catch (SAXException e) { 1031 throw new FastInfosetException("processCII", e); 1032 } 1033 break; 1034 } 1035 case DecoderStateTables.CII_INDEX_MEDIUM: 1036 { 1037 final int index = (((_b & EncodingConstants.INTEGER_4TH_BIT_MEDIUM_MASK) << 8) | read()) 1038 + EncodingConstants.INTEGER_4TH_BIT_SMALL_LIMIT; 1039 try { 1040 _contentHandler.characters(_characterContentChunkTable._array, 1041 _characterContentChunkTable._offset[index], 1042 _characterContentChunkTable._length[index]); 1043 } catch (SAXException e) { 1044 throw new FastInfosetException("processCII", e); 1045 } 1046 break; 1047 } 1048 case DecoderStateTables.CII_INDEX_LARGE: 1049 { 1050 final int index = (((_b & EncodingConstants.INTEGER_4TH_BIT_LARGE_MASK) << 16) | 1051 (read() << 8) | 1052 read()) 1053 + EncodingConstants.INTEGER_4TH_BIT_MEDIUM_LIMIT; 1054 1055 try { 1056 _contentHandler.characters(_characterContentChunkTable._array, 1057 _characterContentChunkTable._offset[index], 1058 _characterContentChunkTable._length[index]); 1059 } catch (SAXException e) { 1060 throw new FastInfosetException("processCII", e); 1061 } 1062 break; 1063 } 1064 case DecoderStateTables.CII_INDEX_LARGE_LARGE: 1065 { 1066 final int index = ((read() << 16) | 1067 (read() << 8) | 1068 read()) 1069 + EncodingConstants.INTEGER_4TH_BIT_LARGE_LIMIT; 1070 1071 try { 1072 _contentHandler.characters(_characterContentChunkTable._array, 1073 _characterContentChunkTable._offset[index], 1074 _characterContentChunkTable._length[index]); 1075 } catch (SAXException e) { 1076 throw new FastInfosetException("processCII", e); 1077 } 1078 break; 1079 } 1080 case DecoderStateTables.COMMENT_II: 1081 processCommentII(); 1082 break; 1083 case DecoderStateTables.PROCESSING_INSTRUCTION_II: 1084 processProcessingII(); 1085 break; 1086 case DecoderStateTables.UNEXPANDED_ENTITY_REFERENCE_II: 1087 { 1088 String entity_reference_name = decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherNCName); 1089 1090 String system_identifier = ((_b & EncodingConstants.UNEXPANDED_ENTITY_SYSTEM_IDENTIFIER_FLAG) > 0) 1091 ? decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherURI) : ""; 1092 String public_identifier = ((_b & EncodingConstants.UNEXPANDED_ENTITY_PUBLIC_IDENTIFIER_FLAG) > 0) 1093 ? decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherURI) : ""; 1094 1095 try { 1096 /* 1097 * TODO 1098 * Need to verify if the skippedEntity method: 1099 * http://java.sun.com/j2se/1.4.2/docs/api/org/xml/sax/ContentHandler.html#skippedEntity(java.lang.String) 1100 * is the correct method to call. It appears so but a more extensive 1101 * check is necessary. 1102 */ 1103 _contentHandler.skippedEntity(entity_reference_name); 1104 } catch (SAXException e) { 1105 throw new FastInfosetException("processUnexpandedEntityReferenceII", e); 1106 } 1107 break; 1108 } 1109 case DecoderStateTables.TERMINATOR_DOUBLE: 1110 _doubleTerminate = true; 1111 case DecoderStateTables.TERMINATOR_SINGLE: 1112 _terminate = true; 1113 break; 1114 default: 1115 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.IllegalStateDecodingEII")); 1116 } 1117 } 1118 1119 _terminate = _doubleTerminate; 1120 _doubleTerminate = false; 1121 1122 try { 1123 _contentHandler.endElement(name.namespaceName, name.localName, name.qName); 1124 } catch (SAXException e) { 1125 throw new FastInfosetException("processEII", e); 1126 } 1127 } 1128 1129 private final void processUtf8CharacterString() throws FastInfosetException, IOException { 1130 if ((_b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0) { 1131 _characterContentChunkTable.ensureSize(_octetBufferLength); 1132 final int charactersOffset = _characterContentChunkTable._arrayIndex; 1133 decodeUtf8StringAsCharBuffer(_characterContentChunkTable._array, charactersOffset); 1134 _characterContentChunkTable.add(_charBufferLength); 1135 try { 1136 _contentHandler.characters(_characterContentChunkTable._array, charactersOffset, _charBufferLength); 1137 } catch (SAXException e) { 1138 throw new FastInfosetException("processCII", e); 1139 } 1140 } else { 1141 decodeUtf8StringAsCharBuffer(); 1142 try { 1143 _contentHandler.characters(_charBuffer, 0, _charBufferLength); 1144 } catch (SAXException e) { 1145 throw new FastInfosetException("processCII", e); 1146 } 1147 } 1148 } 1149 1150 protected final void processEIIWithNamespaces() throws FastInfosetException, IOException { 1151 final boolean hasAttributes = (_b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0; 1152 1153 _clearAttributes = (_namespacePrefixesFeature) ? true : false; 1154 1155 if (++_prefixTable._declarationId == Integer.MAX_VALUE) { 1156 _prefixTable.clearDeclarationIds(); 1157 } 1158 1159 String prefix = "", namespaceName = ""; 1160 final int start = _namespacePrefixesIndex; 1161 int b = read(); 1162 while ((b & EncodingConstants.NAMESPACE_ATTRIBUTE_MASK) == EncodingConstants.NAMESPACE_ATTRIBUTE) { 1163 if (_namespacePrefixesIndex == _namespacePrefixes.length) { 1164 final int[] namespaceAIIs = new int[_namespacePrefixesIndex * 3 / 2 + 1]; 1165 System.arraycopy(_namespacePrefixes, 0, namespaceAIIs, 0, _namespacePrefixesIndex); 1166 _namespacePrefixes = namespaceAIIs; 1167 } 1168 1169 switch (b & EncodingConstants.NAMESPACE_ATTRIBUTE_PREFIX_NAME_MASK) { 1170 // no prefix, no namespace 1171 // Undeclaration of default namespace 1172 case 0: 1173 prefix = namespaceName = ""; 1174 _namespaceNameIndex = _prefixIndex = _namespacePrefixes[_namespacePrefixesIndex++] = -1; 1175 break; 1176 // no prefix, namespace 1177 // Declaration of default namespace 1178 case 1: 1179 prefix = ""; 1180 namespaceName = decodeIdentifyingNonEmptyStringOnFirstBitAsNamespaceName(false); 1181 1182 _prefixIndex = _namespacePrefixes[_namespacePrefixesIndex++] = -1; 1183 break; 1184 // prefix, no namespace 1185 // Undeclaration of namespace 1186 case 2: 1187 prefix = decodeIdentifyingNonEmptyStringOnFirstBitAsPrefix(false); 1188 namespaceName = ""; 1189 1190 _namespaceNameIndex = -1; 1191 _namespacePrefixes[_namespacePrefixesIndex++] = _prefixIndex; 1192 break; 1193 // prefix, namespace 1194 // Declaration of prefixed namespace 1195 case 3: 1196 prefix = decodeIdentifyingNonEmptyStringOnFirstBitAsPrefix(true); 1197 namespaceName = decodeIdentifyingNonEmptyStringOnFirstBitAsNamespaceName(true); 1198 1199 _namespacePrefixes[_namespacePrefixesIndex++] = _prefixIndex; 1200 break; 1201 } 1202 1203 _prefixTable.pushScope(_prefixIndex, _namespaceNameIndex); 1204 1205 if (_namespacePrefixesFeature) { 1206 // Add the namespace delcaration as an attribute 1207 if (prefix != "") { 1208 _attributes.addAttribute(new QualifiedName( 1209 EncodingConstants.XMLNS_NAMESPACE_PREFIX, 1210 EncodingConstants.XMLNS_NAMESPACE_NAME, 1211 prefix), 1212 namespaceName); 1213 } else { 1214 _attributes.addAttribute(EncodingConstants.DEFAULT_NAMESPACE_DECLARATION, 1215 namespaceName); 1216 } 1217 } 1218 1219 try { 1220 _contentHandler.startPrefixMapping(prefix, namespaceName); 1221 } catch (SAXException e) { 1222 throw new IOException("processStartNamespaceAII"); 1223 } 1224 1225 b = read(); 1226 } 1227 if (b != EncodingConstants.TERMINATOR) { 1228 throw new IOException(CommonResourceBundle.getInstance().getString("message.EIInamespaceNameNotTerminatedCorrectly")); 1229 } 1230 final int end = _namespacePrefixesIndex; 1231 1232 _b = read(); 1233 switch(DecoderStateTables.EII(_b)) { 1234 case DecoderStateTables.EII_NO_AIIS_INDEX_SMALL: 1235 processEII(_elementNameTable._array[_b], hasAttributes); 1236 break; 1237 case DecoderStateTables.EII_INDEX_MEDIUM: 1238 processEII(decodeEIIIndexMedium(), hasAttributes); 1239 break; 1240 case DecoderStateTables.EII_INDEX_LARGE: 1241 processEII(decodeEIIIndexLarge(), hasAttributes); 1242 break; 1243 case DecoderStateTables.EII_LITERAL: 1244 { 1245 final QualifiedName qn = decodeLiteralQualifiedName( 1246 _b & EncodingConstants.LITERAL_QNAME_PREFIX_NAMESPACE_NAME_MASK, 1247 _elementNameTable.getNext()); 1248 _elementNameTable.add(qn); 1249 processEII(qn, hasAttributes); 1250 break; 1251 } 1252 default: 1253 throw new IOException(CommonResourceBundle.getInstance().getString("message.IllegalStateDecodingEIIAfterAIIs")); 1254 } 1255 1256 try { 1257 for (int i = end - 1; i >= start; i--) { 1258 final int prefixIndex = _namespacePrefixes[i]; 1259 _prefixTable.popScope(prefixIndex); 1260 prefix = (prefixIndex > 0) ? _prefixTable.get(prefixIndex - 1) : 1261 (prefixIndex == -1) ? "" : EncodingConstants.XML_NAMESPACE_PREFIX; 1262 _contentHandler.endPrefixMapping(prefix); 1263 } 1264 _namespacePrefixesIndex = start; 1265 } catch (SAXException e) { 1266 throw new IOException("processStartNamespaceAII"); 1267 } 1268 } 1269 1270 protected final void processAIIs() throws FastInfosetException, IOException { 1271 QualifiedName name; 1272 int b; 1273 String value; 1274 1275 _clearAttributes = true; 1276 1277 if (++_duplicateAttributeVerifier._currentIteration == Integer.MAX_VALUE) { 1278 _duplicateAttributeVerifier.clear(); 1279 } 1280 1281 do { 1282 // AII qualified name 1283 b = read(); 1284 switch (DecoderStateTables.AII(b)) { 1285 case DecoderStateTables.AII_INDEX_SMALL: 1286 name = _attributeNameTable._array[b]; 1287 break; 1288 case DecoderStateTables.AII_INDEX_MEDIUM: 1289 { 1290 final int i = (((b & EncodingConstants.INTEGER_2ND_BIT_MEDIUM_MASK) << 8) | read()) 1291 + EncodingConstants.INTEGER_2ND_BIT_SMALL_LIMIT; 1292 name = _attributeNameTable._array[i]; 1293 break; 1294 } 1295 case DecoderStateTables.AII_INDEX_LARGE: 1296 { 1297 final int i = (((b & EncodingConstants.INTEGER_2ND_BIT_LARGE_MASK) << 16) | (read() << 8) | read()) 1298 + EncodingConstants.INTEGER_2ND_BIT_MEDIUM_LIMIT; 1299 name = _attributeNameTable._array[i]; 1300 break; 1301 } 1302 case DecoderStateTables.AII_LITERAL: 1303 name = decodeLiteralQualifiedName( 1304 b & EncodingConstants.LITERAL_QNAME_PREFIX_NAMESPACE_NAME_MASK, 1305 _attributeNameTable.getNext()); 1306 name.createAttributeValues(_duplicateAttributeVerifier.MAP_SIZE); 1307 _attributeNameTable.add(name); 1308 break; 1309 case DecoderStateTables.AII_TERMINATOR_DOUBLE: 1310 _doubleTerminate = true; 1311 case DecoderStateTables.AII_TERMINATOR_SINGLE: 1312 _terminate = true; 1313 // AIIs have finished break out of loop 1314 continue; 1315 default: 1316 throw new IOException(CommonResourceBundle.getInstance().getString("message.decodingAIIs")); 1317 } 1318 1319 if (name.prefixIndex > 0 && _prefixTable._currentInScope[name.prefixIndex] != name.namespaceNameIndex) { 1320 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.AIIqNameNotInScope")); 1321 } 1322 1323 _duplicateAttributeVerifier.checkForDuplicateAttribute(name.attributeHash, name.attributeId); 1324 1325 // [normalized value] of AII 1326 1327 b = read(); 1328 switch(DecoderStateTables.NISTRING(b)) { 1329 case DecoderStateTables.NISTRING_UTF8_SMALL_LENGTH: 1330 _octetBufferLength = (b & EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_SMALL_MASK) + 1; 1331 value = decodeUtf8StringAsString(); 1332 if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) { 1333 _attributeValueTable.add(value); 1334 } 1335 1336 _attributes.addAttribute(name, value); 1337 break; 1338 case DecoderStateTables.NISTRING_UTF8_MEDIUM_LENGTH: 1339 _octetBufferLength = read() + EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_SMALL_LIMIT; 1340 value = decodeUtf8StringAsString(); 1341 if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) { 1342 _attributeValueTable.add(value); 1343 } 1344 1345 _attributes.addAttribute(name, value); 1346 break; 1347 case DecoderStateTables.NISTRING_UTF8_LARGE_LENGTH: 1348 _octetBufferLength = ((read() << 24) | 1349 (read() << 16) | 1350 (read() << 8) | 1351 read()) 1352 + EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_MEDIUM_LIMIT; 1353 value = decodeUtf8StringAsString(); 1354 if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) { 1355 _attributeValueTable.add(value); 1356 } 1357 1358 _attributes.addAttribute(name, value); 1359 break; 1360 case DecoderStateTables.NISTRING_UTF16_SMALL_LENGTH: 1361 _octetBufferLength = (b & EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_SMALL_MASK) + 1; 1362 value = decodeUtf16StringAsString(); 1363 if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) { 1364 _attributeValueTable.add(value); 1365 } 1366 1367 _attributes.addAttribute(name, value); 1368 break; 1369 case DecoderStateTables.NISTRING_UTF16_MEDIUM_LENGTH: 1370 _octetBufferLength = read() + EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_SMALL_LIMIT; 1371 value = decodeUtf16StringAsString(); 1372 if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) { 1373 _attributeValueTable.add(value); 1374 } 1375 1376 _attributes.addAttribute(name, value); 1377 break; 1378 case DecoderStateTables.NISTRING_UTF16_LARGE_LENGTH: 1379 _octetBufferLength = ((read() << 24) | 1380 (read() << 16) | 1381 (read() << 8) | 1382 read()) 1383 + EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_MEDIUM_LIMIT; 1384 value = decodeUtf16StringAsString(); 1385 if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) { 1386 _attributeValueTable.add(value); 1387 } 1388 1389 _attributes.addAttribute(name, value); 1390 break; 1391 case DecoderStateTables.NISTRING_RA: 1392 { 1393 final boolean addToTable = (b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0; 1394 // Decode resitricted alphabet integer 1395 _identifier = (b & 0x0F) << 4; 1396 b = read(); 1397 _identifier |= (b & 0xF0) >> 4; 1398 1399 decodeOctetsOnFifthBitOfNonIdentifyingStringOnFirstBit(b); 1400 1401 value = decodeRestrictedAlphabetAsString(); 1402 if (addToTable) { 1403 _attributeValueTable.add(value); 1404 } 1405 1406 _attributes.addAttribute(name, value); 1407 break; 1408 } 1409 case DecoderStateTables.NISTRING_EA: 1410 { 1411 final boolean addToTable = (b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0; 1412 1413 _identifier = (b & 0x0F) << 4; 1414 b = read(); 1415 _identifier |= (b & 0xF0) >> 4; 1416 1417 decodeOctetsOnFifthBitOfNonIdentifyingStringOnFirstBit(b); 1418 1419 processAIIEncodingAlgorithm(name, addToTable); 1420 break; 1421 } 1422 case DecoderStateTables.NISTRING_INDEX_SMALL: 1423 _attributes.addAttribute(name, 1424 _attributeValueTable._array[b & EncodingConstants.INTEGER_2ND_BIT_SMALL_MASK]); 1425 break; 1426 case DecoderStateTables.NISTRING_INDEX_MEDIUM: 1427 { 1428 final int index = (((b & EncodingConstants.INTEGER_2ND_BIT_MEDIUM_MASK) << 8) | read()) 1429 + EncodingConstants.INTEGER_2ND_BIT_SMALL_LIMIT; 1430 1431 _attributes.addAttribute(name, 1432 _attributeValueTable._array[index]); 1433 break; 1434 } 1435 case DecoderStateTables.NISTRING_INDEX_LARGE: 1436 { 1437 final int index = (((b & EncodingConstants.INTEGER_2ND_BIT_LARGE_MASK) << 16) | (read() << 8) | read()) 1438 + EncodingConstants.INTEGER_2ND_BIT_MEDIUM_LIMIT; 1439 1440 _attributes.addAttribute(name, 1441 _attributeValueTable._array[index]); 1442 break; 1443 } 1444 case DecoderStateTables.NISTRING_EMPTY: 1445 _attributes.addAttribute(name, ""); 1446 break; 1447 default: 1448 throw new IOException(CommonResourceBundle.getInstance().getString("message.decodingAIIValue")); 1449 } 1450 1451 } while (!_terminate); 1452 1453 // Reset duplication attribute verfifier 1454 _duplicateAttributeVerifier._poolCurrent = _duplicateAttributeVerifier._poolHead; 1455 1456 _terminate = _doubleTerminate; 1457 _doubleTerminate = false; 1458 } 1459 1460 protected final void processCommentII() throws FastInfosetException, IOException { 1461 switch(decodeNonIdentifyingStringOnFirstBit()) { 1462 case NISTRING_STRING: 1463 if (_addToTable) { 1464 _v.otherString.add(new CharArray(_charBuffer, 0, _charBufferLength, true)); 1465 } 1466 1467 try { 1468 _lexicalHandler.comment(_charBuffer, 0, _charBufferLength); 1469 } catch (SAXException e) { 1470 throw new FastInfosetException("processCommentII", e); 1471 } 1472 break; 1473 case NISTRING_ENCODING_ALGORITHM: 1474 throw new IOException(CommonResourceBundle.getInstance().getString("message.commentIIAlgorithmNotSupported")); 1475 case NISTRING_INDEX: 1476 final CharArray ca = _v.otherString.get(_integer); 1477 1478 try { 1479 _lexicalHandler.comment(ca.ch, ca.start, ca.length); 1480 } catch (SAXException e) { 1481 throw new FastInfosetException("processCommentII", e); 1482 } 1483 break; 1484 case NISTRING_EMPTY_STRING: 1485 try { 1486 _lexicalHandler.comment(_charBuffer, 0, 0); 1487 } catch (SAXException e) { 1488 throw new FastInfosetException("processCommentII", e); 1489 } 1490 break; 1491 } 1492 } 1493 1494 protected final void processProcessingII() throws FastInfosetException, IOException { 1495 final String target = decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherNCName); 1496 1497 switch(decodeNonIdentifyingStringOnFirstBit()) { 1498 case NISTRING_STRING: 1499 final String data = new String(_charBuffer, 0, _charBufferLength); 1500 if (_addToTable) { 1501 _v.otherString.add(new CharArrayString(data)); 1502 } 1503 try { 1504 _contentHandler.processingInstruction(target, data); 1505 } catch (SAXException e) { 1506 throw new FastInfosetException("processProcessingII", e); 1507 } 1508 break; 1509 case NISTRING_ENCODING_ALGORITHM: 1510 throw new IOException(CommonResourceBundle.getInstance().getString("message.processingIIWithEncodingAlgorithm")); 1511 case NISTRING_INDEX: 1512 try { 1513 _contentHandler.processingInstruction(target, _v.otherString.get(_integer).toString()); 1514 } catch (SAXException e) { 1515 throw new FastInfosetException("processProcessingII", e); 1516 } 1517 break; 1518 case NISTRING_EMPTY_STRING: 1519 try { 1520 _contentHandler.processingInstruction(target, ""); 1521 } catch (SAXException e) { 1522 throw new FastInfosetException("processProcessingII", e); 1523 } 1524 break; 1525 } 1526 } 1527 1528 protected final void processCIIEncodingAlgorithm(boolean addToTable) throws FastInfosetException, IOException { 1529 if (_identifier < EncodingConstants.ENCODING_ALGORITHM_BUILTIN_END) { 1530 if (_primitiveHandler != null) { 1531 processCIIBuiltInEncodingAlgorithmAsPrimitive(); 1532 } else if (_algorithmHandler != null) { 1533 Object array = processBuiltInEncodingAlgorithmAsObject(); 1534 1535 try { 1536 _algorithmHandler.object(null, _identifier, array); 1537 } catch (SAXException e) { 1538 throw new FastInfosetException(e); 1539 } 1540 } else { 1541 StringBuffer buffer = new StringBuffer(); 1542 processBuiltInEncodingAlgorithmAsCharacters(buffer); 1543 1544 try { 1545 _contentHandler.characters(buffer.toString().toCharArray(), 0, buffer.length()); 1546 } catch (SAXException e) { 1547 throw new FastInfosetException(e); 1548 } 1549 } 1550 1551 if (addToTable) { 1552 StringBuffer buffer = new StringBuffer(); 1553 processBuiltInEncodingAlgorithmAsCharacters(buffer); 1554 _characterContentChunkTable.add(buffer.toString().toCharArray(), buffer.length()); 1555 } 1556 } else if (_identifier == EncodingAlgorithmIndexes.CDATA) { 1557 // Set back buffer position to start of encoded string 1558 _octetBufferOffset -= _octetBufferLength; 1559 decodeUtf8StringIntoCharBuffer(); 1560 1561 try { 1562 _lexicalHandler.startCDATA(); 1563 _contentHandler.characters(_charBuffer, 0, _charBufferLength); 1564 _lexicalHandler.endCDATA(); 1565 } catch (SAXException e) { 1566 throw new FastInfosetException(e); 1567 } 1568 1569 if (addToTable) { 1570 _characterContentChunkTable.add(_charBuffer, _charBufferLength); 1571 } 1572 } else if (_identifier >= EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START && _algorithmHandler != null) { 1573 final String URI = _v.encodingAlgorithm.get(_identifier - EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START); 1574 if (URI == null) { 1575 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance(). 1576 getString("message.URINotPresent", new Object[]{Integer.valueOf(_identifier)})); 1577 } 1578 1579 final EncodingAlgorithm ea = (EncodingAlgorithm)_registeredEncodingAlgorithms.get(URI); 1580 if (ea != null) { 1581 final Object data = ea.decodeFromBytes(_octetBuffer, _octetBufferStart, _octetBufferLength); 1582 try { 1583 _algorithmHandler.object(URI, _identifier, data); 1584 } catch (SAXException e) { 1585 throw new FastInfosetException(e); 1586 } 1587 } else { 1588 try { 1589 _algorithmHandler.octets(URI, _identifier, _octetBuffer, _octetBufferStart, _octetBufferLength); 1590 } catch (SAXException e) { 1591 throw new FastInfosetException(e); 1592 } 1593 } 1594 if (addToTable) { 1595 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.addToTableNotSupported")); 1596 } 1597 } else if (_identifier >= EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START) { 1598 // TODO should have property to ignore 1599 throw new EncodingAlgorithmException( 1600 CommonResourceBundle.getInstance().getString("message.algorithmDataCannotBeReported")); 1601 } else { 1602 // Reserved built-in algorithms for future use 1603 // TODO should use sax property to decide if event will be 1604 // reported, allows for support through handler if required. 1605 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.identifiers10to31Reserved")); 1606 } 1607 } 1608 1609 protected final void processCIIBuiltInEncodingAlgorithmAsPrimitive() throws FastInfosetException, IOException { 1610 try { 1611 int length; 1612 switch(_identifier) { 1613 case EncodingAlgorithmIndexes.HEXADECIMAL: 1614 case EncodingAlgorithmIndexes.BASE64: 1615 _primitiveHandler.bytes(_octetBuffer, _octetBufferStart, _octetBufferLength); 1616 break; 1617 case EncodingAlgorithmIndexes.SHORT: 1618 length = BuiltInEncodingAlgorithmFactory.shortEncodingAlgorithm. 1619 getPrimtiveLengthFromOctetLength(_octetBufferLength); 1620 if (length > builtInAlgorithmState.shortArray.length) { 1621 final short[] array = new short[length * 3 / 2 + 1]; 1622 System.arraycopy(builtInAlgorithmState.shortArray, 0, 1623 array, 0, builtInAlgorithmState.shortArray.length); 1624 builtInAlgorithmState.shortArray = array; 1625 } 1626 1627 BuiltInEncodingAlgorithmFactory.shortEncodingAlgorithm. 1628 decodeFromBytesToShortArray(builtInAlgorithmState.shortArray, 0, 1629 _octetBuffer, _octetBufferStart, _octetBufferLength); 1630 _primitiveHandler.shorts(builtInAlgorithmState.shortArray, 0, length); 1631 break; 1632 case EncodingAlgorithmIndexes.INT: 1633 length = BuiltInEncodingAlgorithmFactory.intEncodingAlgorithm. 1634 getPrimtiveLengthFromOctetLength(_octetBufferLength); 1635 if (length > builtInAlgorithmState.intArray.length) { 1636 final int[] array = new int[length * 3 / 2 + 1]; 1637 System.arraycopy(builtInAlgorithmState.intArray, 0, 1638 array, 0, builtInAlgorithmState.intArray.length); 1639 builtInAlgorithmState.intArray = array; 1640 } 1641 1642 BuiltInEncodingAlgorithmFactory.intEncodingAlgorithm. 1643 decodeFromBytesToIntArray(builtInAlgorithmState.intArray, 0, 1644 _octetBuffer, _octetBufferStart, _octetBufferLength); 1645 _primitiveHandler.ints(builtInAlgorithmState.intArray, 0, length); 1646 break; 1647 case EncodingAlgorithmIndexes.LONG: 1648 length = BuiltInEncodingAlgorithmFactory.longEncodingAlgorithm. 1649 getPrimtiveLengthFromOctetLength(_octetBufferLength); 1650 if (length > builtInAlgorithmState.longArray.length) { 1651 final long[] array = new long[length * 3 / 2 + 1]; 1652 System.arraycopy(builtInAlgorithmState.longArray, 0, 1653 array, 0, builtInAlgorithmState.longArray.length); 1654 builtInAlgorithmState.longArray = array; 1655 } 1656 1657 BuiltInEncodingAlgorithmFactory.longEncodingAlgorithm. 1658 decodeFromBytesToLongArray(builtInAlgorithmState.longArray, 0, 1659 _octetBuffer, _octetBufferStart, _octetBufferLength); 1660 _primitiveHandler.longs(builtInAlgorithmState.longArray, 0, length); 1661 break; 1662 case EncodingAlgorithmIndexes.BOOLEAN: 1663 length = BuiltInEncodingAlgorithmFactory.booleanEncodingAlgorithm. 1664 getPrimtiveLengthFromOctetLength(_octetBufferLength, _octetBuffer[_octetBufferStart] & 0xFF); 1665 if (length > builtInAlgorithmState.booleanArray.length) { 1666 final boolean[] array = new boolean[length * 3 / 2 + 1]; 1667 System.arraycopy(builtInAlgorithmState.booleanArray, 0, 1668 array, 0, builtInAlgorithmState.booleanArray.length); 1669 builtInAlgorithmState.booleanArray = array; 1670 } 1671 1672 BuiltInEncodingAlgorithmFactory.booleanEncodingAlgorithm. 1673 decodeFromBytesToBooleanArray( 1674 builtInAlgorithmState.booleanArray, 0, length, 1675 _octetBuffer, _octetBufferStart, _octetBufferLength); 1676 _primitiveHandler.booleans(builtInAlgorithmState.booleanArray, 0, length); 1677 break; 1678 case EncodingAlgorithmIndexes.FLOAT: 1679 length = BuiltInEncodingAlgorithmFactory.floatEncodingAlgorithm. 1680 getPrimtiveLengthFromOctetLength(_octetBufferLength); 1681 if (length > builtInAlgorithmState.floatArray.length) { 1682 final float[] array = new float[length * 3 / 2 + 1]; 1683 System.arraycopy(builtInAlgorithmState.floatArray, 0, 1684 array, 0, builtInAlgorithmState.floatArray.length); 1685 builtInAlgorithmState.floatArray = array; 1686 } 1687 1688 BuiltInEncodingAlgorithmFactory.floatEncodingAlgorithm. 1689 decodeFromBytesToFloatArray(builtInAlgorithmState.floatArray, 0, 1690 _octetBuffer, _octetBufferStart, _octetBufferLength); 1691 _primitiveHandler.floats(builtInAlgorithmState.floatArray, 0, length); 1692 break; 1693 case EncodingAlgorithmIndexes.DOUBLE: 1694 length = BuiltInEncodingAlgorithmFactory.doubleEncodingAlgorithm. 1695 getPrimtiveLengthFromOctetLength(_octetBufferLength); 1696 if (length > builtInAlgorithmState.doubleArray.length) { 1697 final double[] array = new double[length * 3 / 2 + 1]; 1698 System.arraycopy(builtInAlgorithmState.doubleArray, 0, 1699 array, 0, builtInAlgorithmState.doubleArray.length); 1700 builtInAlgorithmState.doubleArray = array; 1701 } 1702 1703 BuiltInEncodingAlgorithmFactory.doubleEncodingAlgorithm. 1704 decodeFromBytesToDoubleArray(builtInAlgorithmState.doubleArray, 0, 1705 _octetBuffer, _octetBufferStart, _octetBufferLength); 1706 _primitiveHandler.doubles(builtInAlgorithmState.doubleArray, 0, length); 1707 break; 1708 case EncodingAlgorithmIndexes.UUID: 1709 length = BuiltInEncodingAlgorithmFactory.uuidEncodingAlgorithm. 1710 getPrimtiveLengthFromOctetLength(_octetBufferLength); 1711 if (length > builtInAlgorithmState.longArray.length) { 1712 final long[] array = new long[length * 3 / 2 + 1]; 1713 System.arraycopy(builtInAlgorithmState.longArray, 0, 1714 array, 0, builtInAlgorithmState.longArray.length); 1715 builtInAlgorithmState.longArray = array; 1716 } 1717 1718 BuiltInEncodingAlgorithmFactory.uuidEncodingAlgorithm. 1719 decodeFromBytesToLongArray(builtInAlgorithmState.longArray, 0, 1720 _octetBuffer, _octetBufferStart, _octetBufferLength); 1721 _primitiveHandler.uuids(builtInAlgorithmState.longArray, 0, length); 1722 break; 1723 case EncodingAlgorithmIndexes.CDATA: 1724 throw new UnsupportedOperationException("CDATA"); 1725 default: 1726 throw new FastInfosetException(CommonResourceBundle.getInstance(). 1727 getString("message.unsupportedAlgorithm", new Object[]{Integer.valueOf(_identifier)})); 1728 } 1729 } catch (SAXException e) { 1730 throw new FastInfosetException(e); 1731 } 1732 } 1733 1734 1735 protected final void processAIIEncodingAlgorithm(QualifiedName name, boolean addToTable) throws FastInfosetException, IOException { 1736 if (_identifier < EncodingConstants.ENCODING_ALGORITHM_BUILTIN_END) { 1737 if (_primitiveHandler != null || _algorithmHandler != null) { 1738 Object data = processBuiltInEncodingAlgorithmAsObject(); 1739 _attributes.addAttributeWithAlgorithmData(name, null, _identifier, data); 1740 } else { 1741 StringBuffer buffer = new StringBuffer(); 1742 processBuiltInEncodingAlgorithmAsCharacters(buffer); 1743 _attributes.addAttribute(name, buffer.toString()); 1744 } 1745 } else if (_identifier >= EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START && _algorithmHandler != null) { 1746 final String URI = _v.encodingAlgorithm.get(_identifier - EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START); 1747 if (URI == null) { 1748 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance(). 1749 getString("message.URINotPresent", new Object[]{Integer.valueOf(_identifier)})); 1750 } 1751 1752 final EncodingAlgorithm ea = (EncodingAlgorithm)_registeredEncodingAlgorithms.get(URI); 1753 if (ea != null) { 1754 final Object data = ea.decodeFromBytes(_octetBuffer, _octetBufferStart, _octetBufferLength); 1755 _attributes.addAttributeWithAlgorithmData(name, URI, _identifier, data); 1756 } else { 1757 final byte[] data = new byte[_octetBufferLength]; 1758 System.arraycopy(_octetBuffer, _octetBufferStart, data, 0, _octetBufferLength); 1759 _attributes.addAttributeWithAlgorithmData(name, URI, _identifier, data); 1760 } 1761 } else if (_identifier >= EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START) { 1762 // TODO should have property to ignore 1763 throw new EncodingAlgorithmException( 1764 CommonResourceBundle.getInstance().getString("message.algorithmDataCannotBeReported")); 1765 } else if (_identifier == EncodingAlgorithmIndexes.CDATA) { 1766 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.CDATAAlgorithmNotSupported")); 1767 } else { 1768 // Reserved built-in algorithms for future use 1769 // TODO should use sax property to decide if event will be 1770 // reported, allows for support through handler if required. 1771 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.identifiers10to31Reserved")); 1772 } 1773 1774 if (addToTable) { 1775 _attributeValueTable.add(_attributes.getValue(_attributes.getIndex(name.qName))); 1776 } 1777 } 1778 1779 protected final void processBuiltInEncodingAlgorithmAsCharacters(StringBuffer buffer) throws FastInfosetException, IOException { 1780 // TODO not very efficient, need to reuse buffers 1781 Object array = BuiltInEncodingAlgorithmFactory.getAlgorithm(_identifier). 1782 decodeFromBytes(_octetBuffer, _octetBufferStart, _octetBufferLength); 1783 1784 BuiltInEncodingAlgorithmFactory.getAlgorithm(_identifier).convertToCharacters(array, buffer); 1785 } 1786 1787 protected final Object processBuiltInEncodingAlgorithmAsObject() throws FastInfosetException, IOException { 1788 return BuiltInEncodingAlgorithmFactory.getAlgorithm(_identifier). 1789 decodeFromBytes(_octetBuffer, _octetBufferStart, _octetBufferLength); 1790 } 1791 }