/src/mozilla-central/parser/html/nsHtml5MetaScanner.cpp

Source (jump to first uncovered line)
/*
 * Copyright (c) 2007 Henri Sivonen
 * Copyright (c) 2008-2015 Mozilla Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

/*
 * THIS IS A GENERATED FILE. PLEASE DO NOT EDIT.
 * Please edit MetaScanner.java instead and regenerate.
 */

#define nsHtml5MetaScanner_cpp__

#include "nsAtom.h"
#include "nsHtml5AtomTable.h"
#include "nsHtml5String.h"
#include "nsNameSpaceManager.h"
#include "nsIContent.h"
#include "nsTraceRefcnt.h"
#include "jArray.h"
#include "nsHtml5ArrayCopy.h"
#include "nsAHtml5TreeBuilderState.h"
#include "nsGkAtoms.h"
#include "nsHtml5ByteReadable.h"
#include "nsHtml5Macros.h"
#include "nsIContentHandle.h"
#include "nsHtml5Portability.h"
#include "nsHtml5ContentCreatorFunction.h"

#include "nsHtml5AttributeName.h"
#include "nsHtml5ElementName.h"
#include "nsHtml5Tokenizer.h"
#include "nsHtml5TreeBuilder.h"
#include "nsHtml5StackNode.h"
#include "nsHtml5UTF16Buffer.h"
#include "nsHtml5StateSnapshot.h"
#include "nsHtml5Portability.h"

#include "nsHtml5MetaScanner.h"

static char16_t const CHARSET_DATA[] = { 'h', 'a', 'r', 's', 'e', 't' };
staticJArray<char16_t, int32_t> nsHtml5MetaScanner::CHARSET = {
  CHARSET_DATA,
  MOZ_ARRAY_LENGTH(CHARSET_DATA)
};
static char16_t const CONTENT_DATA[] = { 'o', 'n', 't', 'e', 'n', 't' };
staticJArray<char16_t, int32_t> nsHtml5MetaScanner::CONTENT = {
  CONTENT_DATA,
  MOZ_ARRAY_LENGTH(CONTENT_DATA)
};
static char16_t const HTTP_EQUIV_DATA[] = { 't', 't', 'p', '-', 'e',
                                            'q', 'u', 'i', 'v' };
staticJArray<char16_t, int32_t> nsHtml5MetaScanner::HTTP_EQUIV = {
  HTTP_EQUIV_DATA,
  MOZ_ARRAY_LENGTH(HTTP_EQUIV_DATA)
};
static char16_t const CONTENT_TYPE_DATA[] = { 'c', 'o', 'n', 't', 'e', 'n',
                                              't', '-', 't', 'y', 'p', 'e' };
staticJArray<char16_t, int32_t> nsHtml5MetaScanner::CONTENT_TYPE = {
  CONTENT_TYPE_DATA,
  MOZ_ARRAY_LENGTH(CONTENT_TYPE_DATA)
};

nsHtml5MetaScanner::nsHtml5MetaScanner(nsHtml5TreeBuilder* tb)
  : readable(nullptr)
  , metaState(NO)
  , contentIndex(INT32_MAX)
  , charsetIndex(INT32_MAX)
  , httpEquivIndex(INT32_MAX)
  , contentTypeIndex(INT32_MAX)
  , stateSave(DATA)
  , strBufLen(0)
  , strBuf(jArray<char16_t, int32_t>::newJArray(36))
  , content(nullptr)
  , charset(nullptr)
  , httpEquivState(HTTP_EQUIV_NOT_SEEN)
  , treeBuilder(tb)
  , mEncoding(nullptr)
{
  MOZ_COUNT_CTOR(nsHtml5MetaScanner);
}

nsHtml5MetaScanner::~nsHtml5MetaScanner()
{
  MOZ_COUNT_DTOR(nsHtml5MetaScanner);
  content.Release();
  charset.Release();
}

void
nsHtml5MetaScanner::stateLoop(int32_t state)
{
  int32_t c = -1;
  bool reconsume = false;
stateloop:
  for (;;) {
    switch (state) {
      case DATA: {
        for (;;) {
          if (reconsume) {
            reconsume = false;
          } else {
            c = read();
          }
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case '<': {
              state = nsHtml5MetaScanner::TAG_OPEN;
              NS_HTML5_BREAK(dataloop);
            }
            default: {
              continue;
            }
          }
        }
      dataloop_end:;
        MOZ_FALLTHROUGH;
      }
      case TAG_OPEN: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case 'm':
            case 'M': {
              metaState = M;
              state = nsHtml5MetaScanner::TAG_NAME;
              NS_HTML5_BREAK(tagopenloop);
            }
            case '!': {
              state = nsHtml5MetaScanner::MARKUP_DECLARATION_OPEN;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '\?':
            case '/': {
              state = nsHtml5MetaScanner::SCAN_UNTIL_GT;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '>': {
              state = nsHtml5MetaScanner::DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            default: {
              if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
                metaState = NO;
                state = nsHtml5MetaScanner::TAG_NAME;
                NS_HTML5_BREAK(tagopenloop);
              }
              state = nsHtml5MetaScanner::DATA;
              reconsume = true;
              NS_HTML5_CONTINUE(stateloop);
            }
          }
        }
      tagopenloop_end:;
        MOZ_FALLTHROUGH;
      }
      case TAG_NAME: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case ' ':
            case '\t':
            case '\n':
            case '\f': {
              state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_NAME;
              NS_HTML5_BREAK(tagnameloop);
            }
            case '/': {
              state = nsHtml5MetaScanner::SELF_CLOSING_START_TAG;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '>': {
              state = nsHtml5MetaScanner::DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            case 'e':
            case 'E': {
              if (metaState == M) {
                metaState = E;
              } else {
                metaState = NO;
              }
              continue;
            }
            case 't':
            case 'T': {
              if (metaState == E) {
                metaState = T;
              } else {
                metaState = NO;
              }
              continue;
            }
            case 'a':
            case 'A': {
              if (metaState == T) {
                metaState = A;
              } else {
                metaState = NO;
              }
              continue;
            }
            default: {
              metaState = NO;
              continue;
            }
          }
        }
      tagnameloop_end:;
        MOZ_FALLTHROUGH;
      }
      case BEFORE_ATTRIBUTE_NAME: {
        for (;;) {
          if (reconsume) {
            reconsume = false;
          } else {
            c = read();
          }
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case ' ':
            case '\t':
            case '\n':
            case '\f': {
              continue;
            }
            case '/': {
              state = nsHtml5MetaScanner::SELF_CLOSING_START_TAG;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '>': {
              if (handleTag()) {
                NS_HTML5_BREAK(stateloop);
              }
              state = DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            case 'c':
            case 'C': {
              contentIndex = 0;
              charsetIndex = 0;
              httpEquivIndex = INT32_MAX;
              contentTypeIndex = INT32_MAX;
              state = nsHtml5MetaScanner::ATTRIBUTE_NAME;
              NS_HTML5_BREAK(beforeattributenameloop);
            }
            case 'h':
            case 'H': {
              contentIndex = INT32_MAX;
              charsetIndex = INT32_MAX;
              httpEquivIndex = 0;
              contentTypeIndex = INT32_MAX;
              state = nsHtml5MetaScanner::ATTRIBUTE_NAME;
              NS_HTML5_BREAK(beforeattributenameloop);
            }
            default: {
              contentIndex = INT32_MAX;
              charsetIndex = INT32_MAX;
              httpEquivIndex = INT32_MAX;
              contentTypeIndex = INT32_MAX;
              state = nsHtml5MetaScanner::ATTRIBUTE_NAME;
              NS_HTML5_BREAK(beforeattributenameloop);
            }
          }
        }
      beforeattributenameloop_end:;
        MOZ_FALLTHROUGH;
      }
      case ATTRIBUTE_NAME: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case ' ':
            case '\t':
            case '\n':
            case '\f': {
              state = nsHtml5MetaScanner::AFTER_ATTRIBUTE_NAME;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '/': {
              state = nsHtml5MetaScanner::SELF_CLOSING_START_TAG;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '=': {
              strBufLen = 0;
              contentTypeIndex = 0;
              state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_VALUE;
              NS_HTML5_BREAK(attributenameloop);
            }
            case '>': {
              if (handleTag()) {
                NS_HTML5_BREAK(stateloop);
              }
              state = nsHtml5MetaScanner::DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            default: {
              if (metaState == A) {
                if (c >= 'A' && c <= 'Z') {
                  c += 0x20;
                }
                if (contentIndex < CONTENT.length &&
                    c == CONTENT[contentIndex]) {
                  ++contentIndex;
                } else {
                  contentIndex = INT32_MAX;
                }
                if (charsetIndex < CHARSET.length &&
                    c == CHARSET[charsetIndex]) {
                  ++charsetIndex;
                } else {
                  charsetIndex = INT32_MAX;
                }
                if (httpEquivIndex < HTTP_EQUIV.length &&
                    c == HTTP_EQUIV[httpEquivIndex]) {
                  ++httpEquivIndex;
                } else {
                  httpEquivIndex = INT32_MAX;
                }
              }
              continue;
            }
          }
        }
      attributenameloop_end:;
        MOZ_FALLTHROUGH;
      }
      case BEFORE_ATTRIBUTE_VALUE: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case ' ':
            case '\t':
            case '\n':
            case '\f': {
              continue;
            }
            case '\"': {
              state = nsHtml5MetaScanner::ATTRIBUTE_VALUE_DOUBLE_QUOTED;
              NS_HTML5_BREAK(beforeattributevalueloop);
            }
            case '\'': {
              state = nsHtml5MetaScanner::ATTRIBUTE_VALUE_SINGLE_QUOTED;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '>': {
              if (handleTag()) {
                NS_HTML5_BREAK(stateloop);
              }
              state = nsHtml5MetaScanner::DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            default: {
              handleCharInAttributeValue(c);
              state = nsHtml5MetaScanner::ATTRIBUTE_VALUE_UNQUOTED;
              NS_HTML5_CONTINUE(stateloop);
            }
          }
        }
      beforeattributevalueloop_end:;
        MOZ_FALLTHROUGH;
      }
      case ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
        for (;;) {
          if (reconsume) {
            reconsume = false;
          } else {
            c = read();
          }
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case '\"': {
              handleAttributeValue();
              state = nsHtml5MetaScanner::AFTER_ATTRIBUTE_VALUE_QUOTED;
              NS_HTML5_BREAK(attributevaluedoublequotedloop);
            }
            default: {
              handleCharInAttributeValue(c);
              continue;
            }
          }
        }
      attributevaluedoublequotedloop_end:;
        MOZ_FALLTHROUGH;
      }
      case AFTER_ATTRIBUTE_VALUE_QUOTED: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case ' ':
            case '\t':
            case '\n':
            case '\f': {
              state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_NAME;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '/': {
              state = nsHtml5MetaScanner::SELF_CLOSING_START_TAG;
              NS_HTML5_BREAK(afterattributevaluequotedloop);
            }
            case '>': {
              if (handleTag()) {
                NS_HTML5_BREAK(stateloop);
              }
              state = nsHtml5MetaScanner::DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            default: {
              state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_NAME;
              reconsume = true;
              NS_HTML5_CONTINUE(stateloop);
            }
          }
        }
      afterattributevaluequotedloop_end:;
        MOZ_FALLTHROUGH;
      }
      case SELF_CLOSING_START_TAG: {
        c = read();
        switch (c) {
          case -1: {
            NS_HTML5_BREAK(stateloop);
          }
          case '>': {
            if (handleTag()) {
              NS_HTML5_BREAK(stateloop);
            }
            state = nsHtml5MetaScanner::DATA;
            NS_HTML5_CONTINUE(stateloop);
          }
          default: {
            state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_NAME;
            reconsume = true;
            NS_HTML5_CONTINUE(stateloop);
          }
        }
      }
      case ATTRIBUTE_VALUE_UNQUOTED: {
        for (;;) {
          if (reconsume) {
            reconsume = false;
          } else {
            c = read();
          }
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case ' ':
            case '\t':
            case '\n':
            case '\f': {
              handleAttributeValue();
              state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_NAME;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '>': {
              handleAttributeValue();
              if (handleTag()) {
                NS_HTML5_BREAK(stateloop);
              }
              state = nsHtml5MetaScanner::DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            default: {
              handleCharInAttributeValue(c);
              continue;
            }
          }
        }
      }
      case AFTER_ATTRIBUTE_NAME: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case ' ':
            case '\t':
            case '\n':
            case '\f': {
              continue;
            }
            case '/': {
              handleAttributeValue();
              state = nsHtml5MetaScanner::SELF_CLOSING_START_TAG;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '=': {
              strBufLen = 0;
              contentTypeIndex = 0;
              state = nsHtml5MetaScanner::BEFORE_ATTRIBUTE_VALUE;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '>': {
              handleAttributeValue();
              if (handleTag()) {
                NS_HTML5_BREAK(stateloop);
              }
              state = nsHtml5MetaScanner::DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            case 'c':
            case 'C': {
              contentIndex = 0;
              charsetIndex = 0;
              state = nsHtml5MetaScanner::ATTRIBUTE_NAME;
              NS_HTML5_CONTINUE(stateloop);
            }
            default: {
              contentIndex = INT32_MAX;
              charsetIndex = INT32_MAX;
              state = nsHtml5MetaScanner::ATTRIBUTE_NAME;
              NS_HTML5_CONTINUE(stateloop);
            }
          }
        }
      }
      case MARKUP_DECLARATION_OPEN: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case '-': {
              state = nsHtml5MetaScanner::MARKUP_DECLARATION_HYPHEN;
              NS_HTML5_BREAK(markupdeclarationopenloop);
            }
            default: {
              state = nsHtml5MetaScanner::SCAN_UNTIL_GT;
              reconsume = true;
              NS_HTML5_CONTINUE(stateloop);
            }
          }
        }
      markupdeclarationopenloop_end:;
        MOZ_FALLTHROUGH;
      }
      case MARKUP_DECLARATION_HYPHEN: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case '-': {
              state = nsHtml5MetaScanner::COMMENT_START;
              NS_HTML5_BREAK(markupdeclarationhyphenloop);
            }
            default: {
              state = nsHtml5MetaScanner::SCAN_UNTIL_GT;
              reconsume = true;
              NS_HTML5_CONTINUE(stateloop);
            }
          }
        }
      markupdeclarationhyphenloop_end:;
        MOZ_FALLTHROUGH;
      }
      case COMMENT_START: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case '-': {
              state = nsHtml5MetaScanner::COMMENT_START_DASH;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '>': {
              state = nsHtml5MetaScanner::DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            default: {
              state = nsHtml5MetaScanner::COMMENT;
              NS_HTML5_BREAK(commentstartloop);
            }
          }
        }
      commentstartloop_end:;
        MOZ_FALLTHROUGH;
      }
      case COMMENT: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case '-': {
              state = nsHtml5MetaScanner::COMMENT_END_DASH;
              NS_HTML5_BREAK(commentloop);
            }
            default: {
              continue;
            }
          }
        }
      commentloop_end:;
        MOZ_FALLTHROUGH;
      }
      case COMMENT_END_DASH: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case '-': {
              state = nsHtml5MetaScanner::COMMENT_END;
              NS_HTML5_BREAK(commentenddashloop);
            }
            default: {
              state = nsHtml5MetaScanner::COMMENT;
              NS_HTML5_CONTINUE(stateloop);
            }
          }
        }
      commentenddashloop_end:;
        MOZ_FALLTHROUGH;
      }
      case COMMENT_END: {
        for (;;) {
          c = read();
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case '>': {
              state = nsHtml5MetaScanner::DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            case '-': {
              continue;
            }
            default: {
              state = nsHtml5MetaScanner::COMMENT;
              NS_HTML5_CONTINUE(stateloop);
            }
          }
        }
      }
      case COMMENT_START_DASH: {
        c = read();
        switch (c) {
          case -1: {
            NS_HTML5_BREAK(stateloop);
          }
          case '-': {
            state = nsHtml5MetaScanner::COMMENT_END;
            NS_HTML5_CONTINUE(stateloop);
          }
          case '>': {
            state = nsHtml5MetaScanner::DATA;
            NS_HTML5_CONTINUE(stateloop);
          }
          default: {
            state = nsHtml5MetaScanner::COMMENT;
            NS_HTML5_CONTINUE(stateloop);
          }
        }
      }
      case ATTRIBUTE_VALUE_SINGLE_QUOTED: {
        for (;;) {
          if (reconsume) {
            reconsume = false;
          } else {
            c = read();
          }
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case '\'': {
              handleAttributeValue();
              state = nsHtml5MetaScanner::AFTER_ATTRIBUTE_VALUE_QUOTED;
              NS_HTML5_CONTINUE(stateloop);
            }
            default: {
              handleCharInAttributeValue(c);
              continue;
            }
          }
        }
      }
      case SCAN_UNTIL_GT: {
        for (;;) {
          if (reconsume) {
            reconsume = false;
          } else {
            c = read();
          }
          switch (c) {
            case -1: {
              NS_HTML5_BREAK(stateloop);
            }
            case '>': {
              state = nsHtml5MetaScanner::DATA;
              NS_HTML5_CONTINUE(stateloop);
            }
            default: {
              continue;
            }
          }
        }
      }
    }
  }
stateloop_end:;
  stateSave = state;
}

void
nsHtml5MetaScanner::handleCharInAttributeValue(int32_t c)
{
  if (metaState == A) {
    if (contentIndex == CONTENT.length || charsetIndex == CHARSET.length) {
      addToBuffer(c);
    } else if (httpEquivIndex == HTTP_EQUIV.length) {
      if (contentTypeIndex < CONTENT_TYPE.length &&
          toAsciiLowerCase(c) == CONTENT_TYPE[contentTypeIndex]) {
        ++contentTypeIndex;
      } else {
        contentTypeIndex = INT32_MAX;
      }
    }
  }
}

void
nsHtml5MetaScanner::addToBuffer(int32_t c)
{
  if (strBufLen == strBuf.length) {
    jArray<char16_t, int32_t> newBuf = jArray<char16_t, int32_t>::newJArray(
      strBuf.length + (strBuf.length << 1));
    nsHtml5ArrayCopy::arraycopy(strBuf, newBuf, strBuf.length);
    strBuf = newBuf;
  }
  strBuf[strBufLen++] = (char16_t)c;
}

void
nsHtml5MetaScanner::handleAttributeValue()
{
  if (metaState != A) {
    return;
  }
  if (contentIndex == CONTENT.length && !content) {
    content = nsHtml5Portability::newStringFromBuffer(
      strBuf, 0, strBufLen, treeBuilder, false);
    return;
  }
  if (charsetIndex == CHARSET.length && !charset) {
    charset = nsHtml5Portability::newStringFromBuffer(
      strBuf, 0, strBufLen, treeBuilder, false);
    return;
  }
  if (httpEquivIndex == HTTP_EQUIV.length &&
      httpEquivState == HTTP_EQUIV_NOT_SEEN) {
    httpEquivState = (contentTypeIndex == CONTENT_TYPE.length)
                       ? HTTP_EQUIV_CONTENT_TYPE
                       : HTTP_EQUIV_OTHER;
    return;
  }
}

bool
nsHtml5MetaScanner::handleTag()
{
  bool stop = handleTagInner();
  content.Release();
  content = nullptr;
  charset.Release();
  charset = nullptr;
  httpEquivState = HTTP_EQUIV_NOT_SEEN;
  return stop;
}

bool
nsHtml5MetaScanner::handleTagInner()
{
  if (!!charset && tryCharset(charset)) {
    return true;
  }
  if (!!content && httpEquivState == HTTP_EQUIV_CONTENT_TYPE) {
    nsHtml5String extract =
      nsHtml5TreeBuilder::extractCharsetFromContent(content, treeBuilder);
    if (!extract) {
      return false;
    }
    bool success = tryCharset(extract);
    extract.Release();
    return success;
  }
  return false;
}

void
nsHtml5MetaScanner::initializeStatics()
{
}

void
nsHtml5MetaScanner::releaseStatics()
{
}

#include "nsHtml5MetaScannerCppSupplement.h"

Coverage Report

Created: 2018-09-25 14:53

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