parser/html/nsHtml5MetaScanner.cpp

   1 /*
   2  * Copyright (c) 2007 Henri Sivonen
   3  * Copyright (c) 2008-2015 Mozilla Foundation
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /*
  25  * THIS IS A GENERATED FILE. PLEASE DO NOT EDIT.
  26  * Please edit MetaScanner.java instead and regenerate.
  27  */
  28
  29 #define nsHtml5MetaScanner_cpp__
  30
  31 #include "nsAtom.h"
  32 #include "nsHtml5AtomTable.h"
  33 #include "nsHtml5String.h"
  34 #include "nsNameSpaceManager.h"
  35 #include "nsIContent.h"
  36 #include "nsTraceRefcnt.h"
  37 #include "jArray.h"
  38 #include "nsHtml5ArrayCopy.h"
  39 #include "nsAHtml5TreeBuilderState.h"
  40 #include "nsGkAtoms.h"
  41 #include "nsHtml5ByteReadable.h"
  42 #include "nsHtml5Macros.h"
  43 #include "nsIContentHandle.h"
  44 #include "nsHtml5Portability.h"
  45 #include "nsHtml5ContentCreatorFunction.h"
  46
  47 #include "nsHtml5AttributeName.h"
  48 #include "nsHtml5ElementName.h"
  49 #include "nsHtml5Tokenizer.h"
  50 #include "nsHtml5TreeBuilder.h"
  51 #include "nsHtml5StackNode.h"
  52 #include "nsHtml5UTF16Buffer.h"
  53 #include "nsHtml5StateSnapshot.h"
  54 #include "nsHtml5Portability.h"
  55
  56 #include "nsHtml5MetaScanner.h"
  57
  58 static char16_t const CHARSET_DATA[] = {'h', 'a', 'r', 's', 'e', 't'};
  59 staticJArray<char16_t, int32_t> nsHtml5MetaScanner::CHARSET = {
  60     CHARSET_DATA, MOZ_ARRAY_LENGTH(CHARSET_DATA)};
  61 static char16_t const CONTENT_DATA[] = {'o', 'n', 't', 'e', 'n', 't'};
  62 staticJArray<char16_t, int32_t> nsHtml5MetaScanner::CONTENT = {
  63     CONTENT_DATA, MOZ_ARRAY_LENGTH(CONTENT_DATA)};
  64 static char16_t const HTTP_EQUIV_DATA[] = {'t', 't', 'p', '-', 'e',
  65                                            'q', 'u', 'i', 'v'};
  66 staticJArray<char16_t, int32_t> nsHtml5MetaScanner::HTTP_EQUIV = {
  67     HTTP_EQUIV_DATA, MOZ_ARRAY_LENGTH(HTTP_EQUIV_DATA)};
  68 static char16_t const CONTENT_TYPE_DATA[] = {'c', 'o', 'n', 't', 'e', 'n',
  69                                              't', '-', 't', 'y', 'p', 'e'};
  70 staticJArray<char16_t, int32_t> nsHtml5MetaScanner::CONTENT_TYPE = {
  71     CONTENT_TYPE_DATA, MOZ_ARRAY_LENGTH(CONTENT_TYPE_DATA)};
  72
  73 nsHtml5MetaScanner::nsHtml5MetaScanner(nsHtml5TreeBuilder* tb)
  74     : readable(nullptr),
  75       metaState(NO),
  76       contentIndex(INT32_MAX),
  77       charsetIndex(INT32_MAX),
  78       httpEquivIndex(INT32_MAX),
  79       contentTypeIndex(INT32_MAX),
  80       stateSave(DATA),
  81       strBufLen(0),
  82       strBuf(jArray<char16_t, int32_t>::newJArray(36)),
  83       content(nullptr),
  84       charset(nullptr),
  85       httpEquivState(HTTP_EQUIV_NOT_SEEN),
  86       treeBuilder(tb),
  87       mEncoding(nullptr) {
  88   MOZ_COUNT_CTOR(nsHtml5MetaScanner);
  89 }
  90
  91 nsHtml5MetaScanner::~nsHtml5MetaScanner() {
  92   MOZ_COUNT_DTOR(nsHtml5MetaScanner);
  93   content.Release();
  94   charset.Release();
  95 }
  96
  97 void nsHtml5MetaScanner::stateLoop(int32_t state) {
  98   int32_t c = -1;
  99   bool reconsume = false;
 100 stateloop:
 101   for (;;) {
 102     switch (state) {
 103       case DATA: {
 104         for (;;) {
 105           if (reconsume) {
 106             reconsume = false;
 107           } else {
 108             c = read();
 109           }
 110           switch (c) {
 111             case -1: {
 112               NS_HTML5_BREAK(stateloop);
 113             }
 114             case '<': {
 115               state = nsHtml5MetaScanner::TAG_OPEN;
 116               NS_HTML5_BREAK(dataloop);
 117             }
 118             default: { continue; }
 119           }
 120         }
 121       dataloop_end:;
 122         MOZ_FALLTHROUGH;
 123       }
 124       case TAG_OPEN: {
 125         for (;;) {
 126           c = read();
 127           switch (c) {
 128             case -1: {
 129               NS_HTML5_BREAK(stateloop);
 130             }
 131             case 'm':
 132             case 'M': {
 133               metaState = M;
 134               state = nsHtml5MetaScanner::TAG_NAME;
 135               NS_HTML5_BREAK(tagopenloop);
 136             }
 137             case '!': {
 138               state = nsHtml5MetaScanner::MARKUP_DECLARATION_OPEN;
 139               NS_HTML5_CONTINUE(stateloop);
 140             }
 141             case '\?':
 142             case '/': {
 143               state = nsHtml5MetaScanner::SCAN_UNTIL_GT;
 144               NS_HTML5_CONTINUE(stateloop);
 145             }
 146             case '>': {
 147               state = nsHtml5MetaScanner::DATA;
 148               NS_HTML5_CONTINUE(stateloop);
 149             }
 150             default: {
 151               if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
 152                 metaState = NO;
 153                 state = nsHtml5MetaScanner::TAG_NAME;
 154                 NS_HTML5_BREAK(tagopenloop);
 155               }
 156               state = nsHtml5MetaScanner::DATA;
 157               reconsume = true;
 158               NS_HTML5_CONTINUE(stateloop);
 159             }
 160           }
 161         }
 162       tagopenloop_end:;
 163         MOZ_FALLTHROUGH;
 164       }
 165       case TAG_NAME: {
 166         for (;;) {
 167           c = read();
 168           switch (c) {
 169             case -1: {
 170               NS_HTML5_BREAK(stateloop);
 171             }
 172             case ' ':
 173             case '\t':
 174             case '\n':
 175             case '\f': {
 176               state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_NAME;
 177               NS_HTML5_BREAK(tagnameloop);
 178             }
 179             case '/': {
 180               state = nsHtml5MetaScanner::SELF_CLOSING_START_TAG;
 181               NS_HTML5_CONTINUE(stateloop);
 182             }
 183             case '>': {
 184               state = nsHtml5MetaScanner::DATA;
 185               NS_HTML5_CONTINUE(stateloop);
 186             }
 187             case 'e':
 188             case 'E': {
 189               if (metaState == M) {
 190                 metaState = E;
 191               } else {
 192                 metaState = NO;
 193               }
 194               continue;
 195             }
 196             case 't':
 197             case 'T': {
 198               if (metaState == E) {
 199                 metaState = T;
 200               } else {
 201                 metaState = NO;
 202               }
 203               continue;
 204             }
 205             case 'a':
 206             case 'A': {
 207               if (metaState == T) {
 208                 metaState = A;
 209               } else {
 210                 metaState = NO;
 211               }
 212               continue;
 213             }
 214             default: {
 215               metaState = NO;
 216               continue;
 217             }
 218           }
 219         }
 220       tagnameloop_end:;
 221         MOZ_FALLTHROUGH;
 222       }
 223       case BEFORE_ATTRIBUTE_NAME: {
 224         for (;;) {
 225           if (reconsume) {
 226             reconsume = false;
 227           } else {
 228             c = read();
 229           }
 230           switch (c) {
 231             case -1: {
 232               NS_HTML5_BREAK(stateloop);
 233             }
 234             case ' ':
 235             case '\t':
 236             case '\n':
 237             case '\f': {
 238               continue;
 239             }
 240             case '/': {
 241               state = nsHtml5MetaScanner::SELF_CLOSING_START_TAG;
 242               NS_HTML5_CONTINUE(stateloop);
 243             }
 244             case '>': {
 245               if (handleTag()) {
 246                 NS_HTML5_BREAK(stateloop);
 247               }
 248               state = DATA;
 249               NS_HTML5_CONTINUE(stateloop);
 250             }
 251             case 'c':
 252             case 'C': {
 253               contentIndex = 0;
 254               charsetIndex = 0;
 255               httpEquivIndex = INT32_MAX;
 256               contentTypeIndex = INT32_MAX;
 257               state = nsHtml5MetaScanner::ATTRIBUTE_NAME;
 258               NS_HTML5_BREAK(beforeattributenameloop);
 259             }
 260             case 'h':
 261             case 'H': {
 262               contentIndex = INT32_MAX;
 263               charsetIndex = INT32_MAX;
 264               httpEquivIndex = 0;
 265               contentTypeIndex = INT32_MAX;
 266               state = nsHtml5MetaScanner::ATTRIBUTE_NAME;
 267               NS_HTML5_BREAK(beforeattributenameloop);
 268             }
 269             default: {
 270               contentIndex = INT32_MAX;
 271               charsetIndex = INT32_MAX;
 272               httpEquivIndex = INT32_MAX;
 273               contentTypeIndex = INT32_MAX;
 274               state = nsHtml5MetaScanner::ATTRIBUTE_NAME;
 275               NS_HTML5_BREAK(beforeattributenameloop);
 276             }
 277           }
 278         }
 279       beforeattributenameloop_end:;
 280         MOZ_FALLTHROUGH;
 281       }
 282       case ATTRIBUTE_NAME: {
 283         for (;;) {
 284           c = read();
 285           switch (c) {
 286             case -1: {
 287               NS_HTML5_BREAK(stateloop);
 288             }
 289             case ' ':
 290             case '\t':
 291             case '\n':
 292             case '\f': {
 293               state = nsHtml5MetaScanner::AFTER_ATTRIBUTE_NAME;
 294               NS_HTML5_CONTINUE(stateloop);
 295             }
 296             case '/': {
 297               state = nsHtml5MetaScanner::SELF_CLOSING_START_TAG;
 298               NS_HTML5_CONTINUE(stateloop);
 299             }
 300             case '=': {
 301               strBufLen = 0;
 302               contentTypeIndex = 0;
 303               state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_VALUE;
 304               NS_HTML5_BREAK(attributenameloop);
 305             }
 306             case '>': {
 307               if (handleTag()) {
 308                 NS_HTML5_BREAK(stateloop);
 309               }
 310               state = nsHtml5MetaScanner::DATA;
 311               NS_HTML5_CONTINUE(stateloop);
 312             }
 313             default: {
 314               if (metaState == A) {
 315                 if (c >= 'A' && c <= 'Z') {
 316                   c += 0x20;
 317                 }
 318                 if (contentIndex < CONTENT.length &&
 319                     c == CONTENT[contentIndex]) {
 320                   ++contentIndex;
 321                 } else {
 322                   contentIndex = INT32_MAX;
 323                 }
 324                 if (charsetIndex < CHARSET.length &&
 325                     c == CHARSET[charsetIndex]) {
 326                   ++charsetIndex;
 327                 } else {
 328                   charsetIndex = INT32_MAX;
 329                 }
 330                 if (httpEquivIndex < HTTP_EQUIV.length &&
 331                     c == HTTP_EQUIV[httpEquivIndex]) {
 332                   ++httpEquivIndex;
 333                 } else {
 334                   httpEquivIndex = INT32_MAX;
 335                 }
 336               }
 337               continue;
 338             }
 339           }
 340         }
 341       attributenameloop_end:;
 342         MOZ_FALLTHROUGH;
 343       }
 344       case BEFORE_ATTRIBUTE_VALUE: {
 345         for (;;) {
 346           c = read();
 347           switch (c) {
 348             case -1: {
 349               NS_HTML5_BREAK(stateloop);
 350             }
 351             case ' ':
 352             case '\t':
 353             case '\n':
 354             case '\f': {
 355               continue;
 356             }
 357             case '\"': {
 358               state = nsHtml5MetaScanner::ATTRIBUTE_VALUE_DOUBLE_QUOTED;
 359               NS_HTML5_BREAK(beforeattributevalueloop);
 360             }
 361             case '\'': {
 362               state = nsHtml5MetaScanner::ATTRIBUTE_VALUE_SINGLE_QUOTED;
 363               NS_HTML5_CONTINUE(stateloop);
 364             }
 365             case '>': {
 366               if (handleTag()) {
 367                 NS_HTML5_BREAK(stateloop);
 368               }
 369               state = nsHtml5MetaScanner::DATA;
 370               NS_HTML5_CONTINUE(stateloop);
 371             }
 372             default: {
 373               handleCharInAttributeValue(c);
 374               state = nsHtml5MetaScanner::ATTRIBUTE_VALUE_UNQUOTED;
 375               NS_HTML5_CONTINUE(stateloop);
 376             }
 377           }
 378         }
 379       beforeattributevalueloop_end:;
 380         MOZ_FALLTHROUGH;
 381       }
 382       case ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
 383         for (;;) {
 384           if (reconsume) {
 385             reconsume = false;
 386           } else {
 387             c = read();
 388           }
 389           switch (c) {
 390             case -1: {
 391               NS_HTML5_BREAK(stateloop);
 392             }
 393             case '\"': {
 394               handleAttributeValue();
 395               state = nsHtml5MetaScanner::AFTER_ATTRIBUTE_VALUE_QUOTED;
 396               NS_HTML5_BREAK(attributevaluedoublequotedloop);
 397             }
 398             default: {
 399               handleCharInAttributeValue(c);
 400               continue;
 401             }
 402           }
 403         }
 404       attributevaluedoublequotedloop_end:;
 405         MOZ_FALLTHROUGH;
 406       }
 407       case AFTER_ATTRIBUTE_VALUE_QUOTED: {
 408         for (;;) {
 409           c = read();
 410           switch (c) {
 411             case -1: {
 412               NS_HTML5_BREAK(stateloop);
 413             }
 414             case ' ':
 415             case '\t':
 416             case '\n':
 417             case '\f': {
 418               state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_NAME;
 419               NS_HTML5_CONTINUE(stateloop);
 420             }
 421             case '/': {
 422               state = nsHtml5MetaScanner::SELF_CLOSING_START_TAG;
 423               NS_HTML5_BREAK(afterattributevaluequotedloop);
 424             }
 425             case '>': {
 426               if (handleTag()) {
 427                 NS_HTML5_BREAK(stateloop);
 428               }
 429               state = nsHtml5MetaScanner::DATA;
 430               NS_HTML5_CONTINUE(stateloop);
 431             }
 432             default: {
 433               state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_NAME;
 434               reconsume = true;
 435               NS_HTML5_CONTINUE(stateloop);
 436             }
 437           }
 438         }
 439       afterattributevaluequotedloop_end:;
 440         MOZ_FALLTHROUGH;
 441       }
 442       case SELF_CLOSING_START_TAG: {
 443         c = read();
 444         switch (c) {
 445           case -1: {
 446             NS_HTML5_BREAK(stateloop);
 447           }
 448           case '>': {
 449             if (handleTag()) {
 450               NS_HTML5_BREAK(stateloop);
 451             }
 452             state = nsHtml5MetaScanner::DATA;
 453             NS_HTML5_CONTINUE(stateloop);
 454           }
 455           default: {
 456             state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_NAME;
 457             reconsume = true;
 458             NS_HTML5_CONTINUE(stateloop);
 459           }
 460         }
 461       }
 462       case ATTRIBUTE_VALUE_UNQUOTED: {
 463         for (;;) {
 464           if (reconsume) {
 465             reconsume = false;
 466           } else {
 467             c = read();
 468           }
 469           switch (c) {
 470             case -1: {
 471               NS_HTML5_BREAK(stateloop);
 472             }
 473             case ' ':
 474             case '\t':
 475             case '\n':
 476             case '\f': {
 477               handleAttributeValue();
 478               state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_NAME;
 479               NS_HTML5_CONTINUE(stateloop);
 480             }
 481             case '>': {
 482               handleAttributeValue();
 483               if (handleTag()) {
 484                 NS_HTML5_BREAK(stateloop);
 485               }
 486               state = nsHtml5MetaScanner::DATA;
 487               NS_HTML5_CONTINUE(stateloop);
 488             }
 489             default: {
 490               handleCharInAttributeValue(c);
 491               continue;
 492             }
 493           }
 494         }
 495       }
 496       case AFTER_ATTRIBUTE_NAME: {
 497         for (;;) {
 498           c = read();
 499           switch (c) {
 500             case -1: {
 501               NS_HTML5_BREAK(stateloop);
 502             }
 503             case ' ':
 504             case '\t':
 505             case '\n':
 506             case '\f': {
 507               continue;
 508             }
 509             case '/': {
 510               handleAttributeValue();
 511               state = nsHtml5MetaScanner::SELF_CLOSING_START_TAG;
 512               NS_HTML5_CONTINUE(stateloop);
 513             }
 514             case '=': {
 515               strBufLen = 0;
 516               contentTypeIndex = 0;
 517               state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_VALUE;
 518               NS_HTML5_CONTINUE(stateloop);
 519             }
 520             case '>': {
 521               handleAttributeValue();
 522               if (handleTag()) {
 523                 NS_HTML5_BREAK(stateloop);
 524               }
 525               state = nsHtml5MetaScanner::DATA;
 526               NS_HTML5_CONTINUE(stateloop);
 527             }
 528             case 'c':
 529             case 'C': {
 530               contentIndex = 0;
 531               charsetIndex = 0;
 532               state = nsHtml5MetaScanner::ATTRIBUTE_NAME;
 533               NS_HTML5_CONTINUE(stateloop);
 534             }
 535             default: {
 536               contentIndex = INT32_MAX;
 537               charsetIndex = INT32_MAX;
 538               state = nsHtml5MetaScanner::ATTRIBUTE_NAME;
 539               NS_HTML5_CONTINUE(stateloop);
 540             }
 541           }
 542         }
 543       }
 544       case MARKUP_DECLARATION_OPEN: {
 545         for (;;) {
 546           c = read();
 547           switch (c) {
 548             case -1: {
 549               NS_HTML5_BREAK(stateloop);
 550             }
 551             case '-': {
 552               state = nsHtml5MetaScanner::MARKUP_DECLARATION_HYPHEN;
 553               NS_HTML5_BREAK(markupdeclarationopenloop);
 554             }
 555             default: {
 556               state = nsHtml5MetaScanner::SCAN_UNTIL_GT;
 557               reconsume = true;
 558               NS_HTML5_CONTINUE(stateloop);
 559             }
 560           }
 561         }
 562       markupdeclarationopenloop_end:;
 563         MOZ_FALLTHROUGH;
 564       }
 565       case MARKUP_DECLARATION_HYPHEN: {
 566         for (;;) {
 567           c = read();
 568           switch (c) {
 569             case -1: {
 570               NS_HTML5_BREAK(stateloop);
 571             }
 572             case '-': {
 573               state = nsHtml5MetaScanner::COMMENT_START;
 574               NS_HTML5_BREAK(markupdeclarationhyphenloop);
 575             }
 576             default: {
 577               state = nsHtml5MetaScanner::SCAN_UNTIL_GT;
 578               reconsume = true;
 579               NS_HTML5_CONTINUE(stateloop);
 580             }
 581           }
 582         }
 583       markupdeclarationhyphenloop_end:;
 584         MOZ_FALLTHROUGH;
 585       }
 586       case COMMENT_START: {
 587         for (;;) {
 588           c = read();
 589           switch (c) {
 590             case -1: {
 591               NS_HTML5_BREAK(stateloop);
 592             }
 593             case '-': {
 594               state = nsHtml5MetaScanner::COMMENT_START_DASH;
 595               NS_HTML5_CONTINUE(stateloop);
 596             }
 597             case '>': {
 598               state = nsHtml5MetaScanner::DATA;
 599               NS_HTML5_CONTINUE(stateloop);
 600             }
 601             default: {
 602               state = nsHtml5MetaScanner::COMMENT;
 603               NS_HTML5_BREAK(commentstartloop);
 604             }
 605           }
 606         }
 607       commentstartloop_end:;
 608         MOZ_FALLTHROUGH;
 609       }
 610       case COMMENT: {
 611         for (;;) {
 612           c = read();
 613           switch (c) {
 614             case -1: {
 615               NS_HTML5_BREAK(stateloop);
 616             }
 617             case '-': {
 618               state = nsHtml5MetaScanner::COMMENT_END_DASH;
 619               NS_HTML5_BREAK(commentloop);
 620             }
 621             default: { continue; }
 622           }
 623         }
 624       commentloop_end:;
 625         MOZ_FALLTHROUGH;
 626       }
 627       case COMMENT_END_DASH: {
 628         for (;;) {
 629           c = read();
 630           switch (c) {
 631             case -1: {
 632               NS_HTML5_BREAK(stateloop);
 633             }
 634             case '-': {
 635               state = nsHtml5MetaScanner::COMMENT_END;
 636               NS_HTML5_BREAK(commentenddashloop);
 637             }
 638             default: {
 639               state = nsHtml5MetaScanner::COMMENT;
 640               NS_HTML5_CONTINUE(stateloop);
 641             }
 642           }
 643         }
 644       commentenddashloop_end:;
 645         MOZ_FALLTHROUGH;
 646       }
 647       case COMMENT_END: {
 648         for (;;) {
 649           c = read();
 650           switch (c) {
 651             case -1: {
 652               NS_HTML5_BREAK(stateloop);
 653             }
 654             case '>': {
 655               state = nsHtml5MetaScanner::DATA;
 656               NS_HTML5_CONTINUE(stateloop);
 657             }
 658             case '-': {
 659               continue;
 660             }
 661             default: {
 662               state = nsHtml5MetaScanner::COMMENT;
 663               NS_HTML5_CONTINUE(stateloop);
 664             }
 665           }
 666         }
 667       }
 668       case COMMENT_START_DASH: {
 669         c = read();
 670         switch (c) {
 671           case -1: {
 672             NS_HTML5_BREAK(stateloop);
 673           }
 674           case '-': {
 675             state = nsHtml5MetaScanner::COMMENT_END;
 676             NS_HTML5_CONTINUE(stateloop);
 677           }
 678           case '>': {
 679             state = nsHtml5MetaScanner::DATA;
 680             NS_HTML5_CONTINUE(stateloop);
 681           }
 682           default: {
 683             state = nsHtml5MetaScanner::COMMENT;
 684             NS_HTML5_CONTINUE(stateloop);
 685           }
 686         }
 687       }
 688       case ATTRIBUTE_VALUE_SINGLE_QUOTED: {
 689         for (;;) {
 690           if (reconsume) {
 691             reconsume = false;
 692           } else {
 693             c = read();
 694           }
 695           switch (c) {
 696             case -1: {
 697               NS_HTML5_BREAK(stateloop);
 698             }
 699             case '\'': {
 700               handleAttributeValue();
 701               state = nsHtml5MetaScanner::AFTER_ATTRIBUTE_VALUE_QUOTED;
 702               NS_HTML5_CONTINUE(stateloop);
 703             }
 704             default: {
 705               handleCharInAttributeValue(c);
 706               continue;
 707             }
 708           }
 709         }
 710       }
 711       case SCAN_UNTIL_GT: {
 712         for (;;) {
 713           if (reconsume) {
 714             reconsume = false;
 715           } else {
 716             c = read();
 717           }
 718           switch (c) {
 719             case -1: {
 720               NS_HTML5_BREAK(stateloop);
 721             }
 722             case '>': {
 723               state = nsHtml5MetaScanner::DATA;
 724               NS_HTML5_CONTINUE(stateloop);
 725             }
 726             default: { continue; }
 727           }
 728         }
 729       }
 730     }
 731   }
 732 stateloop_end:;
 733   stateSave = state;
 734 }
 735
 736 void nsHtml5MetaScanner::handleCharInAttributeValue(int32_t c) {
 737   if (metaState == A) {
 738     if (contentIndex == CONTENT.length || charsetIndex == CHARSET.length) {
 739       addToBuffer(c);
 740     } else if (httpEquivIndex == HTTP_EQUIV.length) {
 741       if (contentTypeIndex < CONTENT_TYPE.length &&
 742           toAsciiLowerCase(c) == CONTENT_TYPE[contentTypeIndex]) {
 743         ++contentTypeIndex;
 744       } else {
 745         contentTypeIndex = INT32_MAX;
 746       }
 747     }
 748   }
 749 }
 750
 751 void nsHtml5MetaScanner::addToBuffer(int32_t c) {
 752   if (strBufLen == strBuf.length) {
 753     jArray<char16_t, int32_t> newBuf = jArray<char16_t, int32_t>::newJArray(
 754         strBuf.length + (strBuf.length << 1));
 755     nsHtml5ArrayCopy::arraycopy(strBuf, newBuf, strBuf.length);
 756     strBuf = newBuf;
 757   }
 758   strBuf[strBufLen++] = (char16_t)c;
 759 }
 760
 761 void nsHtml5MetaScanner::handleAttributeValue() {
 762   if (metaState != A) {
 763     return;
 764   }
 765   if (contentIndex == CONTENT.length && !content) {
 766     content = nsHtml5Portability::newStringFromBuffer(strBuf, 0, strBufLen,
 767                                                       treeBuilder, false);
 768     return;
 769   }
 770   if (charsetIndex == CHARSET.length && !charset) {
 771     charset = nsHtml5Portability::newStringFromBuffer(strBuf, 0, strBufLen,
 772                                                       treeBuilder, false);
 773     return;
 774   }
 775   if (httpEquivIndex == HTTP_EQUIV.length &&
 776       httpEquivState == HTTP_EQUIV_NOT_SEEN) {
 777     httpEquivState = (contentTypeIndex == CONTENT_TYPE.length)
 778                          ? HTTP_EQUIV_CONTENT_TYPE
 779                          : HTTP_EQUIV_OTHER;
 780     return;
 781   }
 782 }
 783
 784 bool nsHtml5MetaScanner::handleTag() {
 785   bool stop = handleTagInner();
 786   content.Release();
 787   content = nullptr;
 788   charset.Release();
 789   charset = nullptr;
 790   httpEquivState = HTTP_EQUIV_NOT_SEEN;
 791   return stop;
 792 }
 793
 794 bool nsHtml5MetaScanner::handleTagInner() {
 795   if (!!charset && tryCharset(charset)) {
 796     return true;
 797   }
 798   if (!!content && httpEquivState == HTTP_EQUIV_CONTENT_TYPE) {
 799     nsHtml5String extract =
 800         nsHtml5TreeBuilder::extractCharsetFromContent(content, treeBuilder);
 801     if (!extract) {
 802       return false;
 803     }
 804     bool success = tryCharset(extract);
 805     extract.Release();
 806     return success;
 807   }
 808   return false;
 809 }
 810
 811 void nsHtml5MetaScanner::initializeStatics() {}
 812
 813 void nsHtml5MetaScanner::releaseStatics() {}
 814
 815 #include "nsHtml5MetaScannerCppSupplement.h"