jaxp/src/java.xml/share/classes/com/sun/org/apache/xerces/internal/impl/XML11EntityScanner.java
changeset 39798 550955727ef7
parent 37626 d4fb6a5dc001
child 39799 2847de5336f2
equal deleted inserted replaced
39678:5bf88dce615f 39798:550955727ef7
   308         }
   308         }
   309         else {
   309         else {
   310             return null;
   310             return null;
   311         }
   311         }
   312 
   312 
       
   313         int length = 0;
   313         do {
   314         do {
   314             ch = fCurrentEntity.ch[fCurrentEntity.position];
   315             ch = fCurrentEntity.ch[fCurrentEntity.position];
   315             if (XML11Char.isXML11Name(ch)) {
   316             if (XML11Char.isXML11Name(ch)) {
   316                 if (++fCurrentEntity.position == fCurrentEntity.count) {
   317                 if ((length = checkBeforeLoad(fCurrentEntity, offset, offset)) > 0) {
   317                     int length = fCurrentEntity.position - offset;
       
   318                     invokeListeners(length);
       
   319                     if (length == fCurrentEntity.ch.length) {
       
   320                         // bad luck we have to resize our buffer
       
   321                         char[] tmp = new char[fCurrentEntity.ch.length << 1];
       
   322                         System.arraycopy(fCurrentEntity.ch, offset,
       
   323                                          tmp, 0, length);
       
   324                         fCurrentEntity.ch = tmp;
       
   325                     }
       
   326                     else {
       
   327                         System.arraycopy(fCurrentEntity.ch, offset,
       
   328                                          fCurrentEntity.ch, 0, length);
       
   329                     }
       
   330                     offset = 0;
   318                     offset = 0;
   331                     if (load(length, false, false)) {
   319                     if (load(length, false, false)) {
   332                         break;
   320                         break;
   333                     }
   321                     }
   334                 }
   322                 }
   335             }
   323             }
   336             else if (XML11Char.isXML11NameHighSurrogate(ch)) {
   324             else if (XML11Char.isXML11NameHighSurrogate(ch)) {
   337                 if (++fCurrentEntity.position == fCurrentEntity.count) {
   325                 if ((length = checkBeforeLoad(fCurrentEntity, offset, offset)) > 0) {
   338                     int length = fCurrentEntity.position - offset;
       
   339                     invokeListeners(length);
       
   340                     if (length == fCurrentEntity.ch.length) {
       
   341                         // bad luck we have to resize our buffer
       
   342                         char[] tmp = new char[fCurrentEntity.ch.length << 1];
       
   343                         System.arraycopy(fCurrentEntity.ch, offset,
       
   344                                          tmp, 0, length);
       
   345                         fCurrentEntity.ch = tmp;
       
   346                     }
       
   347                     else {
       
   348                         System.arraycopy(fCurrentEntity.ch, offset,
       
   349                                          fCurrentEntity.ch, 0, length);
       
   350                     }
       
   351                     offset = 0;
   326                     offset = 0;
   352                     if (load(length, false, false)) {
   327                     if (load(length, false, false)) {
   353                         --fCurrentEntity.position;
   328                         --fCurrentEntity.position;
   354                         --fCurrentEntity.startPosition;
   329                         --fCurrentEntity.startPosition;
   355                         break;
   330                         break;
   359                 if ( !XMLChar.isLowSurrogate(ch2) ||
   334                 if ( !XMLChar.isLowSurrogate(ch2) ||
   360                      !XML11Char.isXML11Name(XMLChar.supplemental(ch, ch2)) ) {
   335                      !XML11Char.isXML11Name(XMLChar.supplemental(ch, ch2)) ) {
   361                     --fCurrentEntity.position;
   336                     --fCurrentEntity.position;
   362                     break;
   337                     break;
   363                 }
   338                 }
   364                 if (++fCurrentEntity.position == fCurrentEntity.count) {
   339                 if ((length = checkBeforeLoad(fCurrentEntity, offset, offset)) > 0) {
   365                     int length = fCurrentEntity.position - offset;
       
   366                     invokeListeners(length);
       
   367                     if (length == fCurrentEntity.ch.length) {
       
   368                         // bad luck we have to resize our buffer
       
   369                         char[] tmp = new char[fCurrentEntity.ch.length << 1];
       
   370                         System.arraycopy(fCurrentEntity.ch, offset,
       
   371                                          tmp, 0, length);
       
   372                         fCurrentEntity.ch = tmp;
       
   373                     }
       
   374                     else {
       
   375                         System.arraycopy(fCurrentEntity.ch, offset,
       
   376                                          fCurrentEntity.ch, 0, length);
       
   377                     }
       
   378                     offset = 0;
   340                     offset = 0;
   379                     if (load(length, false, false)) {
   341                     if (load(length, false, false)) {
   380                         break;
   342                         break;
   381                     }
   343                     }
   382                 }
   344                 }
   385                 break;
   347                 break;
   386             }
   348             }
   387         }
   349         }
   388         while (true);
   350         while (true);
   389 
   351 
   390         int length = fCurrentEntity.position - offset;
   352         length = fCurrentEntity.position - offset;
   391         fCurrentEntity.columnNumber += length;
   353         fCurrentEntity.columnNumber += length;
   392 
   354 
   393         // return name
   355         // return name
   394         String symbol = null;
   356         String symbol = null;
   395         if (length > 0) {
   357         if (length > 0) {
       
   358             checkLimit(Limit.MAX_NAME_LIMIT, fCurrentEntity, offset, length);
   396             symbol = fSymbolTable.addSymbol(fCurrentEntity.ch, offset, length);
   359             symbol = fSymbolTable.addSymbol(fCurrentEntity.ch, offset, length);
   397         }
   360         }
   398         return symbol;
   361         return symbol;
   399 
   362 
   400     } // scanName():String
   363     } // scanName():String
   639         else {
   602         else {
   640             return false;
   603             return false;
   641         }
   604         }
   642 
   605 
   643         int index = -1;
   606         int index = -1;
       
   607         int length = 0;
   644         boolean sawIncompleteSurrogatePair = false;
   608         boolean sawIncompleteSurrogatePair = false;
   645         do {
   609         do {
   646             ch = fCurrentEntity.ch[fCurrentEntity.position];
   610             ch = fCurrentEntity.ch[fCurrentEntity.position];
   647             if (XML11Char.isXML11Name(ch)) {
   611             if (XML11Char.isXML11Name(ch)) {
   648                 if (ch == ':') {
   612                 if (ch == ':') {
   651                     }
   615                     }
   652                     index = fCurrentEntity.position;
   616                     index = fCurrentEntity.position;
   653                     //check prefix before further read
   617                     //check prefix before further read
   654                     checkLimit(Limit.MAX_NAME_LIMIT, fCurrentEntity, offset, index - offset);
   618                     checkLimit(Limit.MAX_NAME_LIMIT, fCurrentEntity, offset, index - offset);
   655                 }
   619                 }
   656                 if (++fCurrentEntity.position == fCurrentEntity.count) {
   620                 if ((length = checkBeforeLoad(fCurrentEntity, offset, index)) > 0) {
   657                     int length = fCurrentEntity.position - offset;
       
   658                     //check localpart before loading more data
       
   659                     checkLimit(Limit.MAX_NAME_LIMIT, fCurrentEntity, offset, length - index - 1);
       
   660                     invokeListeners(length);
       
   661                     if (length == fCurrentEntity.ch.length) {
       
   662                         // bad luck we have to resize our buffer
       
   663                         char[] tmp = new char[fCurrentEntity.ch.length << 1];
       
   664                         System.arraycopy(fCurrentEntity.ch, offset,
       
   665                                          tmp, 0, length);
       
   666                         fCurrentEntity.ch = tmp;
       
   667                     }
       
   668                     else {
       
   669                         System.arraycopy(fCurrentEntity.ch, offset,
       
   670                                          fCurrentEntity.ch, 0, length);
       
   671                     }
       
   672                     if (index != -1) {
   621                     if (index != -1) {
   673                         index = index - offset;
   622                         index = index - offset;
   674                     }
   623                     }
   675                     offset = 0;
   624                     offset = 0;
   676                     if (load(length, false, false)) {
   625                     if (load(length, false, false)) {
   677                         break;
   626                         break;
   678                     }
   627                     }
   679                 }
   628                 }
   680             }
   629             }
   681             else if (XML11Char.isXML11NameHighSurrogate(ch)) {
   630             else if (XML11Char.isXML11NameHighSurrogate(ch)) {
   682                 if (++fCurrentEntity.position == fCurrentEntity.count) {
   631                 if ((length = checkBeforeLoad(fCurrentEntity, offset, index)) > 0) {
   683                     int length = fCurrentEntity.position - offset;
       
   684                     invokeListeners(length);
       
   685                     if (length == fCurrentEntity.ch.length) {
       
   686                         // bad luck we have to resize our buffer
       
   687                         char[] tmp = new char[fCurrentEntity.ch.length << 1];
       
   688                         System.arraycopy(fCurrentEntity.ch, offset,
       
   689                                          tmp, 0, length);
       
   690                         fCurrentEntity.ch = tmp;
       
   691                     }
       
   692                     else {
       
   693                         System.arraycopy(fCurrentEntity.ch, offset,
       
   694                                          fCurrentEntity.ch, 0, length);
       
   695                     }
       
   696                     if (index != -1) {
   632                     if (index != -1) {
   697                         index = index - offset;
   633                         index = index - offset;
   698                     }
   634                     }
   699                     offset = 0;
   635                     offset = 0;
   700                     if (load(length, false, false)) {
   636                     if (load(length, false, false)) {
   709                      !XML11Char.isXML11Name(XMLChar.supplemental(ch, ch2)) ) {
   645                      !XML11Char.isXML11Name(XMLChar.supplemental(ch, ch2)) ) {
   710                     sawIncompleteSurrogatePair = true;
   646                     sawIncompleteSurrogatePair = true;
   711                     --fCurrentEntity.position;
   647                     --fCurrentEntity.position;
   712                     break;
   648                     break;
   713                 }
   649                 }
   714                 if (++fCurrentEntity.position == fCurrentEntity.count) {
   650                 if ((length = checkBeforeLoad(fCurrentEntity, offset, index)) > 0) {
   715                     int length = fCurrentEntity.position - offset;
       
   716                     invokeListeners(length);
       
   717                     if (length == fCurrentEntity.ch.length) {
       
   718                         // bad luck we have to resize our buffer
       
   719                         char[] tmp = new char[fCurrentEntity.ch.length << 1];
       
   720                         System.arraycopy(fCurrentEntity.ch, offset,
       
   721                                          tmp, 0, length);
       
   722                         fCurrentEntity.ch = tmp;
       
   723                     }
       
   724                     else {
       
   725                         System.arraycopy(fCurrentEntity.ch, offset,
       
   726                                          fCurrentEntity.ch, 0, length);
       
   727                     }
       
   728                     if (index != -1) {
   651                     if (index != -1) {
   729                         index = index - offset;
   652                         index = index - offset;
   730                     }
   653                     }
   731                     offset = 0;
   654                     offset = 0;
   732                     if (load(length, false, false)) {
   655                     if (load(length, false, false)) {
   738                 break;
   661                 break;
   739             }
   662             }
   740         }
   663         }
   741         while (true);
   664         while (true);
   742 
   665 
   743         int length = fCurrentEntity.position - offset;
   666         length = fCurrentEntity.position - offset;
   744         fCurrentEntity.columnNumber += length;
   667         fCurrentEntity.columnNumber += length;
   745 
   668 
   746         if (length > 0) {
   669         if (length > 0) {
   747             String prefix = null;
   670             String prefix = null;
   748             String localpart = null;
   671             String localpart = null;
   943      * the character data.
   866      * the character data.
   944      *
   867      *
   945      * @param quote   The quote character that signifies the end of the
   868      * @param quote   The quote character that signifies the end of the
   946      *                attribute value data.
   869      *                attribute value data.
   947      * @param content The content structure to fill.
   870      * @param content The content structure to fill.
       
   871      * @param isNSURI a flag indicating whether the content is a Namespace URI
   948      *
   872      *
   949      * @return Returns the next character on the input, if known. This
   873      * @return Returns the next character on the input, if known. This
   950      *         value may be -1 but this does <em>note</em> designate
   874      *         value may be -1 but this does <em>note</em> designate
   951      *         end of file.
   875      *         end of file.
   952      *
   876      *
   953      * @throws IOException  Thrown if i/o error occurs.
   877      * @throws IOException  Thrown if i/o error occurs.
   954      * @throws EOFException Thrown on end of file.
   878      * @throws EOFException Thrown on end of file.
   955      */
   879      */
   956     public int scanLiteral(int quote, XMLString content)
   880     public int scanLiteral(int quote, XMLString content, boolean isNSURI)
   957         throws IOException {
   881         throws IOException {
   958         // load more characters, if needed
   882         // load more characters, if needed
   959         if (fCurrentEntity.position == fCurrentEntity.count) {
   883         if (fCurrentEntity.position == fCurrentEntity.count) {
   960             load(0, true, true);
   884             load(0, true, true);
   961         }
   885         }
  1051         }
   975         }
  1052         int length = fCurrentEntity.position - offset;
   976         int length = fCurrentEntity.position - offset;
  1053         fCurrentEntity.columnNumber += length - newlines;
   977         fCurrentEntity.columnNumber += length - newlines;
  1054         if (fCurrentEntity.isGE) {
   978         if (fCurrentEntity.isGE) {
  1055             checkLimit(Limit.TOTAL_ENTITY_SIZE_LIMIT, fCurrentEntity, offset, length);
   979             checkLimit(Limit.TOTAL_ENTITY_SIZE_LIMIT, fCurrentEntity, offset, length);
       
   980         }
       
   981         if (isNSURI) {
       
   982             checkLimit(Limit.MAX_NAME_LIMIT, fCurrentEntity, offset, length);
  1056         }
   983         }
  1057         content.setValues(fCurrentEntity.ch, offset, length);
   984         content.setValues(fCurrentEntity.ch, offset, length);
  1058 
   985 
  1059         // return next character
   986         // return next character
  1060         if (fCurrentEntity.position != fCurrentEntity.count) {
   987         if (fCurrentEntity.position != fCurrentEntity.count) {