parser/html/nsHtml5MetaScanner.cpp

   1 /*
   2  * Copyright (c) 2007 Henri Sivonen
   3  * Copyright (c) 2008-2010 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 "nsIAtom.h"
  32 #include "nsHtml5AtomTable.h"
  33 #include "nsString.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 "nsHtml5Atoms.h"
  41 #include "nsHtml5ByteReadable.h"
  42 #include "nsIUnicodeDecoder.h"
  43 #include "nsHtml5Macros.h"
  44 #include "nsIContentHandle.h"
  45
  46 #include "nsHtml5Tokenizer.h"
  47 #include "nsHtml5TreeBuilder.h"
  48 #include "nsHtml5AttributeName.h"
  49 #include "nsHtml5ElementName.h"
  50 #include "nsHtml5HtmlAttributes.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 = { CHARSET_DATA, MOZ_ARRAY_LENGTH(CHARSET_DATA) };
  60 static char16_t const CONTENT_DATA[] = { 'o', 'n', 't', 'e', 'n', 't' };
  61 staticJArray<char16_t,int32_t> nsHtml5MetaScanner::CONTENT = { CONTENT_DATA, MOZ_ARRAY_LENGTH(CONTENT_DATA) };
  62 static char16_t const HTTP_EQUIV_DATA[] = { 't', 't', 'p', '-', 'e', 'q', 'u', 'i', 'v' };
  63 staticJArray<char16_t,int32_t> nsHtml5MetaScanner::HTTP_EQUIV = { HTTP_EQUIV_DATA, MOZ_ARRAY_LENGTH(HTTP_EQUIV_DATA) };
  64 static char16_t const CONTENT_TYPE_DATA[] = { 'c', 'o', 'n', 't', 'e', 'n', 't', '-', 't', 'y', 'p', 'e' };
  65 staticJArray<char16_t,int32_t> nsHtml5MetaScanner::CONTENT_TYPE = { CONTENT_TYPE_DATA, MOZ_ARRAY_LENGTH(CONTENT_TYPE_DATA) };
  66
  67 nsHtml5MetaScanner::nsHtml5MetaScanner()
  68   : readable(nullptr),
  69     metaState(NS_HTML5META_SCANNER_NO),
  70     contentIndex(INT32_MAX),
  71     charsetIndex(INT32_MAX),
  72     httpEquivIndex(INT32_MAX),
  73     contentTypeIndex(INT32_MAX),
  74     stateSave(NS_HTML5META_SCANNER_DATA),
  75     strBufLen(0),
  76     strBuf(jArray<char16_t,int32_t>::newJArray(36)),
  77     content(nullptr),
  78     charset(nullptr),
  79     httpEquivState(NS_HTML5META_SCANNER_HTTP_EQUIV_NOT_SEEN)
  80 {
  81   MOZ_COUNT_CTOR(nsHtml5MetaScanner);
  82 }
  83
  84
  85 nsHtml5MetaScanner::~nsHtml5MetaScanner()
  86 {
  87   MOZ_COUNT_DTOR(nsHtml5MetaScanner);
  88   nsHtml5Portability::releaseString(content);
  89   nsHtml5Portability::releaseString(charset);
  90 }
  91
  92 void
  93 nsHtml5MetaScanner::stateLoop(int32_t state)
  94 {
  95   int32_t c = -1;
  96   bool reconsume = false;
  97   stateloop: for (; ; ) {
  98     switch(state) {
  99       case NS_HTML5META_SCANNER_DATA: {
 100         for (; ; ) {
 101           if (reconsume) {
 102             reconsume = false;
 103           } else {
 104             c = read();
 105           }
 106           switch(c) {
 107             case -1: {
 108               NS_HTML5_BREAK(stateloop);
 109             }
 110             case '<': {
 111               state = NS_HTML5META_SCANNER_TAG_OPEN;
 112               NS_HTML5_BREAK(dataloop);
 113             }
 114             default: {
 115               continue;
 116             }
 117           }
 118         }
 119         dataloop_end: ;
 120       }
 121       case NS_HTML5META_SCANNER_TAG_OPEN: {
 122         for (; ; ) {
 123           c = read();
 124           switch(c) {
 125             case -1: {
 126               NS_HTML5_BREAK(stateloop);
 127             }
 128             case 'm':
 129             case 'M': {
 130               metaState = NS_HTML5META_SCANNER_M;
 131               state = NS_HTML5META_SCANNER_TAG_NAME;
 132               NS_HTML5_BREAK(tagopenloop);
 133             }
 134             case '!': {
 135               state = NS_HTML5META_SCANNER_MARKUP_DECLARATION_OPEN;
 136               NS_HTML5_CONTINUE(stateloop);
 137             }
 138             case '\?':
 139             case '/': {
 140               state = NS_HTML5META_SCANNER_SCAN_UNTIL_GT;
 141               NS_HTML5_CONTINUE(stateloop);
 142             }
 143             case '>': {
 144               state = NS_HTML5META_SCANNER_DATA;
 145               NS_HTML5_CONTINUE(stateloop);
 146             }
 147             default: {
 148               if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
 149                 metaState = NS_HTML5META_SCANNER_NO;
 150                 state = NS_HTML5META_SCANNER_TAG_NAME;
 151                 NS_HTML5_BREAK(tagopenloop);
 152               }
 153               state = NS_HTML5META_SCANNER_DATA;
 154               reconsume = true;
 155               NS_HTML5_CONTINUE(stateloop);
 156             }
 157           }
 158         }
 159         tagopenloop_end: ;
 160       }
 161       case NS_HTML5META_SCANNER_TAG_NAME: {
 162         for (; ; ) {
 163           c = read();
 164           switch(c) {
 165             case -1: {
 166               NS_HTML5_BREAK(stateloop);
 167             }
 168             case ' ':
 169             case '\t':
 170             case '\n':
 171             case '\f': {
 172               state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME;
 173               NS_HTML5_BREAK(tagnameloop);
 174             }
 175             case '/': {
 176               state = NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG;
 177               NS_HTML5_CONTINUE(stateloop);
 178             }
 179             case '>': {
 180               state = NS_HTML5META_SCANNER_DATA;
 181               NS_HTML5_CONTINUE(stateloop);
 182             }
 183             case 'e':
 184             case 'E': {
 185               if (metaState == NS_HTML5META_SCANNER_M) {
 186                 metaState = NS_HTML5META_SCANNER_E;
 187               } else {
 188                 metaState = NS_HTML5META_SCANNER_NO;
 189               }
 190               continue;
 191             }
 192             case 't':
 193             case 'T': {
 194               if (metaState == NS_HTML5META_SCANNER_E) {
 195                 metaState = NS_HTML5META_SCANNER_T;
 196               } else {
 197                 metaState = NS_HTML5META_SCANNER_NO;
 198               }
 199               continue;
 200             }
 201             case 'a':
 202             case 'A': {
 203               if (metaState == NS_HTML5META_SCANNER_T) {
 204                 metaState = NS_HTML5META_SCANNER_A;
 205               } else {
 206                 metaState = NS_HTML5META_SCANNER_NO;
 207               }
 208               continue;
 209             }
 210             default: {
 211               metaState = NS_HTML5META_SCANNER_NO;
 212               continue;
 213             }
 214           }
 215         }
 216         tagnameloop_end: ;
 217       }
 218       case NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME: {
 219         for (; ; ) {
 220           if (reconsume) {
 221             reconsume = false;
 222           } else {
 223             c = read();
 224           }
 225           switch(c) {
 226             case -1: {
 227               NS_HTML5_BREAK(stateloop);
 228             }
 229             case ' ':
 230             case '\t':
 231             case '\n':
 232             case '\f': {
 233               continue;
 234             }
 235             case '/': {
 236               state = NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG;
 237               NS_HTML5_CONTINUE(stateloop);
 238             }
 239             case '>': {
 240               if (handleTag()) {
 241                 NS_HTML5_BREAK(stateloop);
 242               }
 243               state = NS_HTML5META_SCANNER_DATA;
 244               NS_HTML5_CONTINUE(stateloop);
 245             }
 246             case 'c':
 247             case 'C': {
 248               contentIndex = 0;
 249               charsetIndex = 0;
 250               httpEquivIndex = INT32_MAX;
 251               contentTypeIndex = INT32_MAX;
 252               state = NS_HTML5META_SCANNER_ATTRIBUTE_NAME;
 253               NS_HTML5_BREAK(beforeattributenameloop);
 254             }
 255             case 'h':
 256             case 'H': {
 257               contentIndex = INT32_MAX;
 258               charsetIndex = INT32_MAX;
 259               httpEquivIndex = 0;
 260               contentTypeIndex = INT32_MAX;
 261               state = NS_HTML5META_SCANNER_ATTRIBUTE_NAME;
 262               NS_HTML5_BREAK(beforeattributenameloop);
 263             }
 264             default: {
 265               contentIndex = INT32_MAX;
 266               charsetIndex = INT32_MAX;
 267               httpEquivIndex = INT32_MAX;
 268               contentTypeIndex = INT32_MAX;
 269               state = NS_HTML5META_SCANNER_ATTRIBUTE_NAME;
 270               NS_HTML5_BREAK(beforeattributenameloop);
 271             }
 272           }
 273         }
 274         beforeattributenameloop_end: ;
 275       }
 276       case NS_HTML5META_SCANNER_ATTRIBUTE_NAME: {
 277         for (; ; ) {
 278           c = read();
 279           switch(c) {
 280             case -1: {
 281               NS_HTML5_BREAK(stateloop);
 282             }
 283             case ' ':
 284             case '\t':
 285             case '\n':
 286             case '\f': {
 287               state = NS_HTML5META_SCANNER_AFTER_ATTRIBUTE_NAME;
 288               NS_HTML5_CONTINUE(stateloop);
 289             }
 290             case '/': {
 291               state = NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG;
 292               NS_HTML5_CONTINUE(stateloop);
 293             }
 294             case '=': {
 295               strBufLen = 0;
 296               contentTypeIndex = 0;
 297               state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_VALUE;
 298               NS_HTML5_BREAK(attributenameloop);
 299             }
 300             case '>': {
 301               if (handleTag()) {
 302                 NS_HTML5_BREAK(stateloop);
 303               }
 304               state = NS_HTML5META_SCANNER_DATA;
 305               NS_HTML5_CONTINUE(stateloop);
 306             }
 307             default: {
 308               if (metaState == NS_HTML5META_SCANNER_A) {
 309                 if (c >= 'A' && c <= 'Z') {
 310                   c += 0x20;
 311                 }
 312                 if (contentIndex < CONTENT.length && c == CONTENT[contentIndex]) {
 313                   ++contentIndex;
 314                 } else {
 315                   contentIndex = INT32_MAX;
 316                 }
 317                 if (charsetIndex < CHARSET.length && c == CHARSET[charsetIndex]) {
 318                   ++charsetIndex;
 319                 } else {
 320                   charsetIndex = INT32_MAX;
 321                 }
 322                 if (httpEquivIndex < HTTP_EQUIV.length && c == HTTP_EQUIV[httpEquivIndex]) {
 323                   ++httpEquivIndex;
 324                 } else {
 325                   httpEquivIndex = INT32_MAX;
 326                 }
 327               }
 328               continue;
 329             }
 330           }
 331         }
 332         attributenameloop_end: ;
 333       }
 334       case NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_VALUE: {
 335         for (; ; ) {
 336           c = read();
 337           switch(c) {
 338             case -1: {
 339               NS_HTML5_BREAK(stateloop);
 340             }
 341             case ' ':
 342             case '\t':
 343             case '\n':
 344             case '\f': {
 345               continue;
 346             }
 347             case '\"': {
 348               state = NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_DOUBLE_QUOTED;
 349               NS_HTML5_BREAK(beforeattributevalueloop);
 350             }
 351             case '\'': {
 352               state = NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_SINGLE_QUOTED;
 353               NS_HTML5_CONTINUE(stateloop);
 354             }
 355             case '>': {
 356               if (handleTag()) {
 357                 NS_HTML5_BREAK(stateloop);
 358               }
 359               state = NS_HTML5META_SCANNER_DATA;
 360               NS_HTML5_CONTINUE(stateloop);
 361             }
 362             default: {
 363               handleCharInAttributeValue(c);
 364               state = NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_UNQUOTED;
 365               NS_HTML5_CONTINUE(stateloop);
 366             }
 367           }
 368         }
 369         beforeattributevalueloop_end: ;
 370       }
 371       case NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
 372         for (; ; ) {
 373           if (reconsume) {
 374             reconsume = false;
 375           } else {
 376             c = read();
 377           }
 378           switch(c) {
 379             case -1: {
 380               NS_HTML5_BREAK(stateloop);
 381             }
 382             case '\"': {
 383               handleAttributeValue();
 384               state = NS_HTML5META_SCANNER_AFTER_ATTRIBUTE_VALUE_QUOTED;
 385               NS_HTML5_BREAK(attributevaluedoublequotedloop);
 386             }
 387             default: {
 388               handleCharInAttributeValue(c);
 389               continue;
 390             }
 391           }
 392         }
 393         attributevaluedoublequotedloop_end: ;
 394       }
 395       case NS_HTML5META_SCANNER_AFTER_ATTRIBUTE_VALUE_QUOTED: {
 396         for (; ; ) {
 397           c = read();
 398           switch(c) {
 399             case -1: {
 400               NS_HTML5_BREAK(stateloop);
 401             }
 402             case ' ':
 403             case '\t':
 404             case '\n':
 405             case '\f': {
 406               state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME;
 407               NS_HTML5_CONTINUE(stateloop);
 408             }
 409             case '/': {
 410               state = NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG;
 411               NS_HTML5_BREAK(afterattributevaluequotedloop);
 412             }
 413             case '>': {
 414               if (handleTag()) {
 415                 NS_HTML5_BREAK(stateloop);
 416               }
 417               state = NS_HTML5META_SCANNER_DATA;
 418               NS_HTML5_CONTINUE(stateloop);
 419             }
 420             default: {
 421               state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME;
 422               reconsume = true;
 423               NS_HTML5_CONTINUE(stateloop);
 424             }
 425           }
 426         }
 427         afterattributevaluequotedloop_end: ;
 428       }
 429       case NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG: {
 430         c = read();
 431         switch(c) {
 432           case -1: {
 433             NS_HTML5_BREAK(stateloop);
 434           }
 435           case '>': {
 436             if (handleTag()) {
 437               NS_HTML5_BREAK(stateloop);
 438             }
 439             state = NS_HTML5META_SCANNER_DATA;
 440             NS_HTML5_CONTINUE(stateloop);
 441           }
 442           default: {
 443             state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME;
 444             reconsume = true;
 445             NS_HTML5_CONTINUE(stateloop);
 446           }
 447         }
 448       }
 449       case NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_UNQUOTED: {
 450         for (; ; ) {
 451           if (reconsume) {
 452             reconsume = false;
 453           } else {
 454             c = read();
 455           }
 456           switch(c) {
 457             case -1: {
 458               NS_HTML5_BREAK(stateloop);
 459             }
 460             case ' ':
 461             case '\t':
 462             case '\n':
 463             case '\f': {
 464               handleAttributeValue();
 465               state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME;
 466               NS_HTML5_CONTINUE(stateloop);
 467             }
 468             case '>': {
 469               handleAttributeValue();
 470               if (handleTag()) {
 471                 NS_HTML5_BREAK(stateloop);
 472               }
 473               state = NS_HTML5META_SCANNER_DATA;
 474               NS_HTML5_CONTINUE(stateloop);
 475             }
 476             default: {
 477               handleCharInAttributeValue(c);
 478               continue;
 479             }
 480           }
 481         }
 482       }
 483       case NS_HTML5META_SCANNER_AFTER_ATTRIBUTE_NAME: {
 484         for (; ; ) {
 485           c = read();
 486           switch(c) {
 487             case -1: {
 488               NS_HTML5_BREAK(stateloop);
 489             }
 490             case ' ':
 491             case '\t':
 492             case '\n':
 493             case '\f': {
 494               continue;
 495             }
 496             case '/': {
 497               handleAttributeValue();
 498               state = NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG;
 499               NS_HTML5_CONTINUE(stateloop);
 500             }
 501             case '=': {
 502               strBufLen = 0;
 503               contentTypeIndex = 0;
 504               state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_VALUE;
 505               NS_HTML5_CONTINUE(stateloop);
 506             }
 507             case '>': {
 508               handleAttributeValue();
 509               if (handleTag()) {
 510                 NS_HTML5_BREAK(stateloop);
 511               }
 512               state = NS_HTML5META_SCANNER_DATA;
 513               NS_HTML5_CONTINUE(stateloop);
 514             }
 515             case 'c':
 516             case 'C': {
 517               contentIndex = 0;
 518               charsetIndex = 0;
 519               state = NS_HTML5META_SCANNER_ATTRIBUTE_NAME;
 520               NS_HTML5_CONTINUE(stateloop);
 521             }
 522             default: {
 523               contentIndex = INT32_MAX;
 524               charsetIndex = INT32_MAX;
 525               state = NS_HTML5META_SCANNER_ATTRIBUTE_NAME;
 526               NS_HTML5_CONTINUE(stateloop);
 527             }
 528           }
 529         }
 530       }
 531       case NS_HTML5META_SCANNER_MARKUP_DECLARATION_OPEN: {
 532         for (; ; ) {
 533           c = read();
 534           switch(c) {
 535             case -1: {
 536               NS_HTML5_BREAK(stateloop);
 537             }
 538             case '-': {
 539               state = NS_HTML5META_SCANNER_MARKUP_DECLARATION_HYPHEN;
 540               NS_HTML5_BREAK(markupdeclarationopenloop);
 541             }
 542             default: {
 543               state = NS_HTML5META_SCANNER_SCAN_UNTIL_GT;
 544               reconsume = true;
 545               NS_HTML5_CONTINUE(stateloop);
 546             }
 547           }
 548         }
 549         markupdeclarationopenloop_end: ;
 550       }
 551       case NS_HTML5META_SCANNER_MARKUP_DECLARATION_HYPHEN: {
 552         for (; ; ) {
 553           c = read();
 554           switch(c) {
 555             case -1: {
 556               NS_HTML5_BREAK(stateloop);
 557             }
 558             case '-': {
 559               state = NS_HTML5META_SCANNER_COMMENT_START;
 560               NS_HTML5_BREAK(markupdeclarationhyphenloop);
 561             }
 562             default: {
 563               state = NS_HTML5META_SCANNER_SCAN_UNTIL_GT;
 564               reconsume = true;
 565               NS_HTML5_CONTINUE(stateloop);
 566             }
 567           }
 568         }
 569         markupdeclarationhyphenloop_end: ;
 570       }
 571       case NS_HTML5META_SCANNER_COMMENT_START: {
 572         for (; ; ) {
 573           c = read();
 574           switch(c) {
 575             case -1: {
 576               NS_HTML5_BREAK(stateloop);
 577             }
 578             case '-': {
 579               state = NS_HTML5META_SCANNER_COMMENT_START_DASH;
 580               NS_HTML5_CONTINUE(stateloop);
 581             }
 582             case '>': {
 583               state = NS_HTML5META_SCANNER_DATA;
 584               NS_HTML5_CONTINUE(stateloop);
 585             }
 586             default: {
 587               state = NS_HTML5META_SCANNER_COMMENT;
 588               NS_HTML5_BREAK(commentstartloop);
 589             }
 590           }
 591         }
 592         commentstartloop_end: ;
 593       }
 594       case NS_HTML5META_SCANNER_COMMENT: {
 595         for (; ; ) {
 596           c = read();
 597           switch(c) {
 598             case -1: {
 599               NS_HTML5_BREAK(stateloop);
 600             }
 601             case '-': {
 602               state = NS_HTML5META_SCANNER_COMMENT_END_DASH;
 603               NS_HTML5_BREAK(commentloop);
 604             }
 605             default: {
 606               continue;
 607             }
 608           }
 609         }
 610         commentloop_end: ;
 611       }
 612       case NS_HTML5META_SCANNER_COMMENT_END_DASH: {
 613         for (; ; ) {
 614           c = read();
 615           switch(c) {
 616             case -1: {
 617               NS_HTML5_BREAK(stateloop);
 618             }
 619             case '-': {
 620               state = NS_HTML5META_SCANNER_COMMENT_END;
 621               NS_HTML5_BREAK(commentenddashloop);
 622             }
 623             default: {
 624               state = NS_HTML5META_SCANNER_COMMENT;
 625               NS_HTML5_CONTINUE(stateloop);
 626             }
 627           }
 628         }
 629         commentenddashloop_end: ;
 630       }
 631       case NS_HTML5META_SCANNER_COMMENT_END: {
 632         for (; ; ) {
 633           c = read();
 634           switch(c) {
 635             case -1: {
 636               NS_HTML5_BREAK(stateloop);
 637             }
 638             case '>': {
 639               state = NS_HTML5META_SCANNER_DATA;
 640               NS_HTML5_CONTINUE(stateloop);
 641             }
 642             case '-': {
 643               continue;
 644             }
 645             default: {
 646               state = NS_HTML5META_SCANNER_COMMENT;
 647               NS_HTML5_CONTINUE(stateloop);
 648             }
 649           }
 650         }
 651       }
 652       case NS_HTML5META_SCANNER_COMMENT_START_DASH: {
 653         c = read();
 654         switch(c) {
 655           case -1: {
 656             NS_HTML5_BREAK(stateloop);
 657           }
 658           case '-': {
 659             state = NS_HTML5META_SCANNER_COMMENT_END;
 660             NS_HTML5_CONTINUE(stateloop);
 661           }
 662           case '>': {
 663             state = NS_HTML5META_SCANNER_DATA;
 664             NS_HTML5_CONTINUE(stateloop);
 665           }
 666           default: {
 667             state = NS_HTML5META_SCANNER_COMMENT;
 668             NS_HTML5_CONTINUE(stateloop);
 669           }
 670         }
 671       }
 672       case NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_SINGLE_QUOTED: {
 673         for (; ; ) {
 674           if (reconsume) {
 675             reconsume = false;
 676           } else {
 677             c = read();
 678           }
 679           switch(c) {
 680             case -1: {
 681               NS_HTML5_BREAK(stateloop);
 682             }
 683             case '\'': {
 684               handleAttributeValue();
 685               state = NS_HTML5META_SCANNER_AFTER_ATTRIBUTE_VALUE_QUOTED;
 686               NS_HTML5_CONTINUE(stateloop);
 687             }
 688             default: {
 689               handleCharInAttributeValue(c);
 690               continue;
 691             }
 692           }
 693         }
 694       }
 695       case NS_HTML5META_SCANNER_SCAN_UNTIL_GT: {
 696         for (; ; ) {
 697           if (reconsume) {
 698             reconsume = false;
 699           } else {
 700             c = read();
 701           }
 702           switch(c) {
 703             case -1: {
 704               NS_HTML5_BREAK(stateloop);
 705             }
 706             case '>': {
 707               state = NS_HTML5META_SCANNER_DATA;
 708               NS_HTML5_CONTINUE(stateloop);
 709             }
 710             default: {
 711               continue;
 712             }
 713           }
 714         }
 715       }
 716     }
 717   }
 718   stateloop_end: ;
 719   stateSave = state;
 720 }
 721
 722 void
 723 nsHtml5MetaScanner::handleCharInAttributeValue(int32_t c)
 724 {
 725   if (metaState == NS_HTML5META_SCANNER_A) {
 726     if (contentIndex == CONTENT.length || charsetIndex == CHARSET.length) {
 727       addToBuffer(c);
 728     } else if (httpEquivIndex == HTTP_EQUIV.length) {
 729       if (contentTypeIndex < CONTENT_TYPE.length && toAsciiLowerCase(c) == CONTENT_TYPE[contentTypeIndex]) {
 730         ++contentTypeIndex;
 731       } else {
 732         contentTypeIndex = INT32_MAX;
 733       }
 734     }
 735   }
 736 }
 737
 738 void
 739 nsHtml5MetaScanner::addToBuffer(int32_t c)
 740 {
 741   if (strBufLen == strBuf.length) {
 742     jArray<char16_t,int32_t> newBuf = jArray<char16_t,int32_t>::newJArray(strBuf.length + (strBuf.length << 1));
 743     nsHtml5ArrayCopy::arraycopy(strBuf, newBuf, strBuf.length);
 744     strBuf = newBuf;
 745   }
 746   strBuf[strBufLen++] = (char16_t) c;
 747 }
 748
 749 void
 750 nsHtml5MetaScanner::handleAttributeValue()
 751 {
 752   if (metaState != NS_HTML5META_SCANNER_A) {
 753     return;
 754   }
 755   if (contentIndex == CONTENT.length && !content) {
 756     content = nsHtml5Portability::newStringFromBuffer(strBuf, 0, strBufLen);
 757     return;
 758   }
 759   if (charsetIndex == CHARSET.length && !charset) {
 760     charset = nsHtml5Portability::newStringFromBuffer(strBuf, 0, strBufLen);
 761     return;
 762   }
 763   if (httpEquivIndex == HTTP_EQUIV.length && httpEquivState == NS_HTML5META_SCANNER_HTTP_EQUIV_NOT_SEEN) {
 764     httpEquivState = (contentTypeIndex == CONTENT_TYPE.length) ? NS_HTML5META_SCANNER_HTTP_EQUIV_CONTENT_TYPE : NS_HTML5META_SCANNER_HTTP_EQUIV_OTHER;
 765     return;
 766   }
 767 }
 768
 769 bool
 770 nsHtml5MetaScanner::handleTag()
 771 {
 772   bool stop = handleTagInner();
 773   nsHtml5Portability::releaseString(content);
 774   content = nullptr;
 775   nsHtml5Portability::releaseString(charset);
 776   charset = nullptr;
 777   httpEquivState = NS_HTML5META_SCANNER_HTTP_EQUIV_NOT_SEEN;
 778   return stop;
 779 }
 780
 781 bool
 782 nsHtml5MetaScanner::handleTagInner()
 783 {
 784   if (!!charset && tryCharset(charset)) {
 785     return true;
 786   }
 787   if (!!content && httpEquivState == NS_HTML5META_SCANNER_HTTP_EQUIV_CONTENT_TYPE) {
 788     nsString* extract = nsHtml5TreeBuilder::extractCharsetFromContent(content);
 789     if (!extract) {
 790       return false;
 791     }
 792     bool success = tryCharset(extract);
 793     nsHtml5Portability::releaseString(extract);
 794     return success;
 795   }
 796   return false;
 797 }
 798
 799 void
 800 nsHtml5MetaScanner::initializeStatics()
 801 {
 802 }
 803
 804 void
 805 nsHtml5MetaScanner::releaseStatics()
 806 {
 807 }
 808
 809
 810 #include "nsHtml5MetaScannerCppSupplement.h"
 811