/*

 * Copyright (c) 2007 Henri Sivonen

 * Copyright (c) 2007-2015 Mozilla Foundation

 * Portions of comments Copyright 2004-2008 Apple Computer, Inc., Mozilla

 * Foundation, and Opera Software ASA.

 *

 * 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 TreeBuilder.java instead and regenerate.

 */

#define nsHtml5TreeBuilder_cpp__

#include "nsContentUtils.h"

#include "nsAtom.h"

#include "nsHtml5AtomTable.h"

#include "nsITimer.h"

#include "nsHtml5String.h"

#include "nsNameSpaceManager.h"

#include "nsIContent.h"

#include "nsTraceRefcnt.h"

#include "jArray.h"

#include "nsHtml5DocumentMode.h"

#include "nsHtml5ArrayCopy.h"

#include "nsHtml5Parser.h"

#include "nsGkAtoms.h"

#include "nsHtml5TreeOperation.h"

#include "nsHtml5StateSnapshot.h"

#include "nsHtml5StackNode.h"

#include "nsHtml5TreeOpExecutor.h"

#include "nsHtml5StreamParser.h"

#include "nsAHtml5TreeBuilderState.h"

#include "nsHtml5Highlighter.h"

#include "nsHtml5PlainTextUtils.h"

#include "nsHtml5ViewSourceUtils.h"

#include "mozilla/Likely.h"

#include "nsIContentHandle.h"

#include "nsHtml5OplessBuilder.h"

#include "nsHtml5AttributeName.h"

#include "nsHtml5ElementName.h"

#include "nsHtml5Tokenizer.h"

#include "nsHtml5MetaScanner.h"

#include "nsHtml5StackNode.h"

#include "nsHtml5UTF16Buffer.h"

#include "nsHtml5StateSnapshot.h"

#include "nsHtml5Portability.h"

#include "nsHtml5TreeBuilder.h"

char16_t nsHtml5TreeBuilder::REPLACEMENT_CHARACTER[] = { 0xfffd };

static const char* const QUIRKY_PUBLIC_IDS_DATA[] = {

  "+//silmaril//dtd html pro v0r11 19970101//",

  "-//advasoft ltd//dtd html 3.0 aswedit + extensions//",

  "-//as//dtd html 3.0 aswedit + extensions//",

  "-//ietf//dtd html 2.0 level 1//",

  "-//ietf//dtd html 2.0 level 2//",

  "-//ietf//dtd html 2.0 strict level 1//",

  "-//ietf//dtd html 2.0 strict level 2//",

  "-//ietf//dtd html 2.0 strict//",

  "-//ietf//dtd html 2.0//",

  "-//ietf//dtd html 2.1e//",

  "-//ietf//dtd html 3.0//",

  "-//ietf//dtd html 3.2 final//",

  "-//ietf//dtd html 3.2//",

  "-//ietf//dtd html 3//",

  "-//ietf//dtd html level 0//",

  "-//ietf//dtd html level 1//",

  "-//ietf//dtd html level 2//",

  "-//ietf//dtd html level 3//",

  "-//ietf//dtd html strict level 0//",

  "-//ietf//dtd html strict level 1//",

  "-//ietf//dtd html strict level 2//",

  "-//ietf//dtd html strict level 3//",

  "-//ietf//dtd html strict//",

  "-//ietf//dtd html//",

  "-//metrius//dtd metrius presentational//",

  "-//microsoft//dtd internet explorer 2.0 html strict//",

  "-//microsoft//dtd internet explorer 2.0 html//",

  "-//microsoft//dtd internet explorer 2.0 tables//",

  "-//microsoft//dtd internet explorer 3.0 html strict//",

  "-//microsoft//dtd internet explorer 3.0 html//",

  "-//microsoft//dtd internet explorer 3.0 tables//",

  "-//netscape comm. corp.//dtd html//",

  "-//netscape comm. corp.//dtd strict html//",

  "-//o'reilly and associates//dtd html 2.0//",

  "-//o'reilly and associates//dtd html extended 1.0//",

  "-//o'reilly and associates//dtd html extended relaxed 1.0//",

  "-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html "

  "4.0//",

  "-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//",

  "-//spyglass//dtd html 2.0 extended//",

  "-//sq//dtd html 2.0 hotmetal + extensions//",

  "-//sun microsystems corp.//dtd hotjava html//",

  "-//sun microsystems corp.//dtd hotjava strict html//",

  "-//w3c//dtd html 3 1995-03-24//",

  "-//w3c//dtd html 3.2 draft//",

  "-//w3c//dtd html 3.2 final//",

  "-//w3c//dtd html 3.2//",

  "-//w3c//dtd html 3.2s draft//",

  "-//w3c//dtd html 4.0 frameset//",

  "-//w3c//dtd html 4.0 transitional//",

  "-//w3c//dtd html experimental 19960712//",

  "-//w3c//dtd html experimental 970421//",

  "-//w3c//dtd w3 html//",

  "-//w3o//dtd w3 html 3.0//",

  "-//webtechs//dtd mozilla html 2.0//",

  "-//webtechs//dtd mozilla html//"

};

staticJArray<const char*, int32_t> nsHtml5TreeBuilder::QUIRKY_PUBLIC_IDS = {

  QUIRKY_PUBLIC_IDS_DATA,

  MOZ_ARRAY_LENGTH(QUIRKY_PUBLIC_IDS_DATA)

};

void

nsHtml5TreeBuilder::startTokenization(nsHtml5Tokenizer* self)

{

  tokenizer = self;

  stackNodes = jArray<nsHtml5StackNode*, int32_t>::newJArray(64);

  stack = jArray<nsHtml5StackNode*, int32_t>::newJArray(64);

  templateModeStack = jArray<int32_t, int32_t>::newJArray(64);

  listOfActiveFormattingElements =

    jArray<nsHtml5StackNode*, int32_t>::newJArray(64);

  needToDropLF = false;

  originalMode = INITIAL;

  templateModePtr = -1;

  stackNodesIdx = 0;

  numStackNodes = 0;

  currentPtr = -1;

  listPtr = -1;

  formPointer = nullptr;

  headPointer = nullptr;

  deepTreeSurrogateParent = nullptr;

  start(fragment);

  charBufferLen = 0;

  charBuffer = nullptr;

  framesetOk = true;

  if (fragment) {

    nsIContentHandle* elt;

    if (contextNode) {

      elt = contextNode;

    } else {

      elt = createHtmlElementSetAsRoot(tokenizer->emptyAttributes());

    }

    if (contextNamespace == kNameSpaceID_SVG) {

      nsHtml5ElementName* elementName = nsHtml5ElementName::ELT_SVG;

      if (nsGkAtoms::title == contextName || nsGkAtoms::desc == contextName ||

          nsGkAtoms::foreignObject == contextName) {

        elementName = nsHtml5ElementName::ELT_FOREIGNOBJECT;

      }

      nsHtml5StackNode* node =

        createStackNode(elementName, elementName->getCamelCaseName(), elt);

      currentPtr++;

      stack[currentPtr] = node;

      tokenizer->setStateAndEndTagExpectation(nsHtml5Tokenizer::DATA,

                                              contextName);

      mode = FRAMESET_OK;

    } else if (contextNamespace == kNameSpaceID_MathML) {

      nsHtml5ElementName* elementName = nsHtml5ElementName::ELT_MATH;

      if (nsGkAtoms::mi_ == contextName || nsGkAtoms::mo_ == contextName ||

          nsGkAtoms::mn_ == contextName || nsGkAtoms::ms_ == contextName ||

          nsGkAtoms::mtext_ == contextName) {

        elementName = nsHtml5ElementName::ELT_MTEXT;

      } else if (nsGkAtoms::annotation_xml_ == contextName) {

        elementName = nsHtml5ElementName::ELT_ANNOTATION_XML;

      }

      nsHtml5StackNode* node =

        createStackNode(elementName, elt, elementName->getName(), false);

      currentPtr++;

      stack[currentPtr] = node;

      tokenizer->setStateAndEndTagExpectation(nsHtml5Tokenizer::DATA,

                                              contextName);

      mode = FRAMESET_OK;

    } else {

      nsHtml5StackNode* node =

        createStackNode(nsHtml5ElementName::ELT_HTML, elt);

      currentPtr++;

      stack[currentPtr] = node;

      if (nsGkAtoms::_template == contextName) {

        pushTemplateMode(IN_TEMPLATE);

      }

      resetTheInsertionMode();

      formPointer = getFormPointerForContext(contextNode);

      if (nsGkAtoms::title == contextName ||

          nsGkAtoms::textarea == contextName) {

        tokenizer->setStateAndEndTagExpectation(nsHtml5Tokenizer::RCDATA,

                                                contextName);

      } else if (nsGkAtoms::style == contextName ||

                 nsGkAtoms::xmp == contextName ||

                 nsGkAtoms::iframe == contextName ||

                 nsGkAtoms::noembed == contextName ||

                 nsGkAtoms::noframes == contextName ||

                 (scriptingEnabled && nsGkAtoms::noscript == contextName)) {

        tokenizer->setStateAndEndTagExpectation(nsHtml5Tokenizer::RAWTEXT,

                                                contextName);

      } else if (nsGkAtoms::plaintext == contextName) {

        tokenizer->setStateAndEndTagExpectation(nsHtml5Tokenizer::PLAINTEXT,

                                                contextName);

      } else if (nsGkAtoms::script == contextName) {

        tokenizer->setStateAndEndTagExpectation(nsHtml5Tokenizer::SCRIPT_DATA,

                                                contextName);

      } else {

        tokenizer->setStateAndEndTagExpectation(nsHtml5Tokenizer::DATA,

                                                contextName);

      }

    }

    contextName = nullptr;

    contextNode = nullptr;

  } else {

    mode = INITIAL;

    if (tokenizer->isViewingXmlSource()) {

      nsIContentHandle* elt = createElement(kNameSpaceID_SVG,

                                            nsGkAtoms::svg,

                                            tokenizer->emptyAttributes(),

                                            nullptr,

                                            svgCreator(NS_NewSVGSVGElement));

      nsHtml5StackNode* node =

        createStackNode(nsHtml5ElementName::ELT_SVG, nsGkAtoms::svg, elt);

      currentPtr++;

      stack[currentPtr] = node;

    }

  }

}

void

nsHtml5TreeBuilder::doctype(nsAtom* name,

                            nsHtml5String publicIdentifier,

                            nsHtml5String systemIdentifier,

                            bool forceQuirks)

{

  needToDropLF = false;

  if (!isInForeign() && mode == INITIAL) {

    nsHtml5String emptyString = nsHtml5Portability::newEmptyString();

    appendDoctypeToDocument(!name ? nsGkAtoms::_empty : name,

                            !publicIdentifier ? emptyString : publicIdentifier,

                            !systemIdentifier ? emptyString : systemIdentifier);

    emptyString.Release();

    if (isQuirky(name, publicIdentifier, systemIdentifier, forceQuirks)) {

      errQuirkyDoctype();

      documentModeInternal(

        QUIRKS_MODE, publicIdentifier, systemIdentifier, false);

    } else if (isAlmostStandards(publicIdentifier, systemIdentifier)) {

      errAlmostStandardsDoctype();

      documentModeInternal(

        ALMOST_STANDARDS_MODE, publicIdentifier, systemIdentifier, false);

    } else {

      documentModeInternal(

        STANDARDS_MODE, publicIdentifier, systemIdentifier, false);

    }

    mode = BEFORE_HTML;

    return;

  }

  errStrayDoctype();

  return;

}

void

nsHtml5TreeBuilder::comment(char16_t* buf, int32_t start, int32_t length)

{

  needToDropLF = false;

  if (!isInForeign()) {

    switch (mode) {

      case INITIAL:

      case BEFORE_HTML:

      case AFTER_AFTER_BODY:

      case AFTER_AFTER_FRAMESET: {

        appendCommentToDocument(buf, start, length);

        return;

      }

      case AFTER_BODY: {

        flushCharacters();

        appendComment(stack[0]->node, buf, start, length);

        return;

      }

      default: {

        break;

      }

    }

  }

  flushCharacters();

  appendComment(stack[currentPtr]->node, buf, start, length);

  return;

}

void

nsHtml5TreeBuilder::characters(const char16_t* buf,

                               int32_t start,

                               int32_t length)

{

  if (tokenizer->isViewingXmlSource()) {

    return;

  }

  if (needToDropLF) {

    needToDropLF = false;

    if (buf[start] == '\n') {

      start++;

      length--;

      if (!length) {

        return;

      }

    }

  }

  switch (mode) {

    case IN_BODY:

    case IN_CELL:

    case IN_CAPTION: {

      if (!isInForeignButNotHtmlOrMathTextIntegrationPoint()) {

        reconstructTheActiveFormattingElements();

      }

      MOZ_FALLTHROUGH;

    }

    case TEXT: {

      accumulateCharacters(buf, start, length);

      return;

    }

    case IN_TABLE:

    case IN_TABLE_BODY:

    case IN_ROW: {

      accumulateCharactersForced(buf, start, length);

      return;

    }

    default: {

      int32_t end = start + length;

      for (int32_t i = start; i < end; i++) {

        switch (buf[i]) {

          case ' ':

          case '\t':

          case '\n':

          case '\r':

          case '\f': {

            switch (mode) {

              case INITIAL:

              case BEFORE_HTML:

              case BEFORE_HEAD: {

                start = i + 1;

                continue;

              }

              case IN_HEAD:

              case IN_HEAD_NOSCRIPT:

              case AFTER_HEAD:

              case IN_COLUMN_GROUP:

              case IN_FRAMESET:

              case AFTER_FRAMESET: {

                continue;

              }

              case FRAMESET_OK:

              case IN_TEMPLATE:

              case IN_BODY:

              case IN_CELL:

              case IN_CAPTION: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                  start = i;

                }

                if (!isInForeignButNotHtmlOrMathTextIntegrationPoint()) {

                  flushCharacters();

                  reconstructTheActiveFormattingElements();

                }

                NS_HTML5_BREAK(charactersloop);

              }

              case IN_SELECT:

              case IN_SELECT_IN_TABLE: {

                NS_HTML5_BREAK(charactersloop);

              }

              case IN_TABLE:

              case IN_TABLE_BODY:

              case IN_ROW: {

                accumulateCharactersForced(buf, i, 1);

                start = i + 1;

                continue;

              }

              case AFTER_BODY:

              case AFTER_AFTER_BODY:

              case AFTER_AFTER_FRAMESET: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                  start = i;

                }

                flushCharacters();

                reconstructTheActiveFormattingElements();

                continue;

              }

            }

            MOZ_FALLTHROUGH_ASSERT();

          }

          default: {

            switch (mode) {

              case INITIAL: {

                documentModeInternal(QUIRKS_MODE, nullptr, nullptr, false);

                mode = BEFORE_HTML;

                i--;

                continue;

              }

              case BEFORE_HTML: {

                appendHtmlElementToDocumentAndPush();

                mode = BEFORE_HEAD;

                i--;

                continue;

              }

              case BEFORE_HEAD: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                  start = i;

                }

                flushCharacters();

                appendToCurrentNodeAndPushHeadElement(

                  nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES);

                mode = IN_HEAD;

                i--;

                continue;

              }

              case IN_HEAD: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                  start = i;

                }

                flushCharacters();

                pop();

                mode = AFTER_HEAD;

                i--;

                continue;

              }

              case IN_HEAD_NOSCRIPT: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                  start = i;

                }

                errNonSpaceInNoscriptInHead();

                flushCharacters();

                pop();

                mode = IN_HEAD;

                i--;

                continue;

              }

              case AFTER_HEAD: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                  start = i;

                }

                flushCharacters();

                appendToCurrentNodeAndPushBodyElement();

                mode = FRAMESET_OK;

                i--;

                continue;

              }

              case FRAMESET_OK: {

                framesetOk = false;

                mode = IN_BODY;

                i--;

                continue;

              }

              case IN_TEMPLATE:

              case IN_BODY:

              case IN_CELL:

              case IN_CAPTION: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                  start = i;

                }

                if (!isInForeignButNotHtmlOrMathTextIntegrationPoint()) {

                  flushCharacters();

                  reconstructTheActiveFormattingElements();

                }

                NS_HTML5_BREAK(charactersloop);

              }

              case IN_TABLE:

              case IN_TABLE_BODY:

              case IN_ROW: {

                accumulateCharactersForced(buf, i, 1);

                start = i + 1;

                continue;

              }

              case IN_COLUMN_GROUP: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                  start = i;

                }

                if (!currentPtr || stack[currentPtr]->getGroup() ==

                                     nsHtml5TreeBuilder::TEMPLATE) {

                  errNonSpaceInColgroupInFragment();

                  start = i + 1;

                  continue;

                }

                flushCharacters();

                pop();

                mode = IN_TABLE;

                i--;

                continue;

              }

              case IN_SELECT:

              case IN_SELECT_IN_TABLE: {

                NS_HTML5_BREAK(charactersloop);

              }

              case AFTER_BODY: {

                errNonSpaceAfterBody();

                mode = framesetOk ? FRAMESET_OK : IN_BODY;

                i--;

                continue;

              }

              case IN_FRAMESET: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                }

                errNonSpaceInFrameset();

                start = i + 1;

                continue;

              }

              case AFTER_FRAMESET: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                }

                errNonSpaceAfterFrameset();

                start = i + 1;

                continue;

              }

              case AFTER_AFTER_BODY: {

                errNonSpaceInTrailer();

                mode = framesetOk ? FRAMESET_OK : IN_BODY;

                i--;

                continue;

              }

              case AFTER_AFTER_FRAMESET: {

                if (start < i) {

                  accumulateCharacters(buf, start, i - start);

                }

                errNonSpaceInTrailer();

                start = i + 1;

                continue;

              }

            }

          }

        }

      }

    charactersloop_end:;

      if (start < end) {

        accumulateCharacters(buf, start, end - start);

      }

    }

  }

}

void

nsHtml5TreeBuilder::zeroOriginatingReplacementCharacter()

{

  if (mode == TEXT) {

    accumulateCharacters(REPLACEMENT_CHARACTER, 0, 1);

    return;

  }

  if (currentPtr >= 0) {

    if (isSpecialParentInForeign(stack[currentPtr])) {

      return;

    }

    accumulateCharacters(REPLACEMENT_CHARACTER, 0, 1);

  }

}

void

nsHtml5TreeBuilder::eof()

{

  flushCharacters();

  for (;;) {

    switch (mode) {

      case INITIAL: {

        documentModeInternal(QUIRKS_MODE, nullptr, nullptr, false);

        mode = BEFORE_HTML;

        continue;

      }

      case BEFORE_HTML: {

        appendHtmlElementToDocumentAndPush();

        mode = BEFORE_HEAD;

        continue;

      }

      case BEFORE_HEAD: {

        appendToCurrentNodeAndPushHeadElement(

          nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES);

        mode = IN_HEAD;

        continue;

      }

      case IN_HEAD: {

        while (currentPtr > 0) {

          popOnEof();

        }

        mode = AFTER_HEAD;

        continue;

      }

      case IN_HEAD_NOSCRIPT: {

        while (currentPtr > 1) {

          popOnEof();

        }

        mode = IN_HEAD;

        continue;

      }

      case AFTER_HEAD: {

        appendToCurrentNodeAndPushBodyElement();

        mode = IN_BODY;

        continue;

      }

      case IN_TABLE_BODY:

      case IN_ROW:

      case IN_TABLE:

      case IN_SELECT_IN_TABLE:

      case IN_SELECT:

      case IN_COLUMN_GROUP:

      case FRAMESET_OK:

      case IN_CAPTION:

      case IN_CELL:

      case IN_BODY: {

        if (isTemplateModeStackEmpty()) {

          NS_HTML5_BREAK(eofloop);

        }

        MOZ_FALLTHROUGH;

      }

      case IN_TEMPLATE: {

        int32_t eltPos = findLast(nsGkAtoms::_template);

        if (eltPos == nsHtml5TreeBuilder::NOT_FOUND_ON_STACK) {

          MOZ_ASSERT(fragment);

          NS_HTML5_BREAK(eofloop);

        }

        if (MOZ_UNLIKELY(mViewSource)) {

          errUnclosedElements(eltPos, nsGkAtoms::_template);

        }

        while (currentPtr >= eltPos) {

          pop();

        }

        clearTheListOfActiveFormattingElementsUpToTheLastMarker();

        popTemplateMode();

        resetTheInsertionMode();

        continue;

      }

      case TEXT: {

        if (originalMode == AFTER_HEAD) {

          popOnEof();

        }

        popOnEof();

        mode = originalMode;

        continue;

      }

      case IN_FRAMESET: {

        NS_HTML5_BREAK(eofloop);

      }

      case AFTER_BODY:

      case AFTER_FRAMESET:

      case AFTER_AFTER_BODY:

      case AFTER_AFTER_FRAMESET:

      default: {

        NS_HTML5_BREAK(eofloop);

      }

    }

  }

eofloop_end:;

  while (currentPtr > 0) {

    popOnEof();

  }

  if (!fragment) {

    popOnEof();

  }

}

void

nsHtml5TreeBuilder::endTokenization()

{

  formPointer = nullptr;

  headPointer = nullptr;

  deepTreeSurrogateParent = nullptr;

  templateModeStack = nullptr;

  if (stack) {

    while (currentPtr > -1) {

      stack[currentPtr]->release(this);

      currentPtr--;

    }

    stack = nullptr;

  }

  if (listOfActiveFormattingElements) {

    while (listPtr > -1) {

      if (listOfActiveFormattingElements[listPtr]) {

        listOfActiveFormattingElements[listPtr]->release(this);

      }

      listPtr--;

    }

    listOfActiveFormattingElements = nullptr;

  }

  if (stackNodes) {

    for (int32_t i = 0; i < numStackNodes; i++) {

      MOZ_ASSERT(stackNodes[i]->isUnused());

      delete stackNodes[i];

    }

    numStackNodes = 0;

    stackNodesIdx = 0;

    stackNodes = nullptr;

  }

  charBuffer = nullptr;

  end();

}

void

nsHtml5TreeBuilder::startTag(nsHtml5ElementName* elementName,

                             nsHtml5HtmlAttributes* attributes,

                             bool selfClosing)

{

  flushCharacters();

  int32_t eltPos;

  needToDropLF = false;

starttagloop:

  for (;;) {

    int32_t group = elementName->getGroup();

    nsAtom* name = elementName->getName();

    if (isInForeign()) {

      nsHtml5StackNode* currentNode = stack[currentPtr];

      int32_t currNs = currentNode->ns;

      if (!(currentNode->isHtmlIntegrationPoint() ||

            (currNs == kNameSpaceID_MathML &&

             ((currentNode->getGroup() == MI_MO_MN_MS_MTEXT &&

               group != MGLYPH_OR_MALIGNMARK) ||

              (currentNode->getGroup() == ANNOTATION_XML && group == SVG))))) {

        switch (group) {

          case B_OR_BIG_OR_CODE_OR_EM_OR_I_OR_S_OR_SMALL_OR_STRIKE_OR_STRONG_OR_TT_OR_U:

          case DIV_OR_BLOCKQUOTE_OR_CENTER_OR_MENU:

          case BODY:

          case BR:

          case RUBY_OR_SPAN_OR_SUB_OR_SUP_OR_VAR:

          case DD_OR_DT:

          case UL_OR_OL_OR_DL:

          case EMBED:

          case IMG:

          case H1_OR_H2_OR_H3_OR_H4_OR_H5_OR_H6:

          case HEAD:

          case HR:

          case LI:

          case META:

          case NOBR:

          case P:

          case PRE_OR_LISTING:

          case TABLE:

          case FONT: {

            if (!(group == FONT &&

                  !(attributes->contains(nsHtml5AttributeName::ATTR_COLOR) ||

                    attributes->contains(nsHtml5AttributeName::ATTR_FACE) ||

                    attributes->contains(nsHtml5AttributeName::ATTR_SIZE)))) {

              errHtmlStartTagInForeignContext(name);

              if (!fragment) {

                while (!isSpecialParentInForeign(stack[currentPtr])) {

                  pop();

                }

                NS_HTML5_CONTINUE(starttagloop);

              }

            }

            MOZ_FALLTHROUGH;

          }

          default: {

            if (kNameSpaceID_SVG == currNs) {

              attributes->adjustForSvg();

              if (selfClosing) {

                appendVoidElementToCurrentMayFosterSVG(elementName, attributes);

                selfClosing = false;

              } else {

                appendToCurrentNodeAndPushElementMayFosterSVG(elementName,

                                                              attributes);

              }

              attributes = nullptr;

              NS_HTML5_BREAK(starttagloop);

            } else {

              attributes->adjustForMath();

              if (selfClosing) {

                appendVoidElementToCurrentMayFosterMathML(elementName,

                                                          attributes);

                selfClosing = false;

              } else {

                appendToCurrentNodeAndPushElementMayFosterMathML(elementName,

                                                                 attributes);

              }

              attributes = nullptr;

              NS_HTML5_BREAK(starttagloop);

            }

          }

        }

      }

    }

    switch (mode) {

      case IN_TEMPLATE: {

        switch (group) {

          case COL: {

            popTemplateMode();

            pushTemplateMode(IN_COLUMN_GROUP);

            mode = IN_COLUMN_GROUP;

            continue;

          }

          case CAPTION:

          case COLGROUP:

          case TBODY_OR_THEAD_OR_TFOOT: {

            popTemplateMode();

            pushTemplateMode(IN_TABLE);

            mode = IN_TABLE;

            continue;

          }

          case TR: {

            popTemplateMode();

            pushTemplateMode(IN_TABLE_BODY);

            mode = IN_TABLE_BODY;

            continue;

          }

          case TD_OR_TH: {

            popTemplateMode();

            pushTemplateMode(IN_ROW);

            mode = IN_ROW;

            continue;

          }

          case META: {

            checkMetaCharset(attributes);

            appendVoidElementToCurrentMayFoster(elementName, attributes);

            selfClosing = false;

            attributes = nullptr;

            NS_HTML5_BREAK(starttagloop);

          }

          case TITLE: {

            startTagTitleInHead(elementName, attributes);

            attributes = nullptr;

            NS_HTML5_BREAK(starttagloop);

          }

          case BASE:

          case LINK_OR_BASEFONT_OR_BGSOUND: {

            appendVoidElementToCurrentMayFoster(elementName, attributes);

            selfClosing = false;

            attributes = nullptr;

            NS_HTML5_BREAK(starttagloop);

          }

          case SCRIPT: {

            startTagScriptInHead(elementName, attributes);

            attributes = nullptr;

            NS_HTML5_BREAK(starttagloop);

          }

          case NOFRAMES:

          case STYLE: {

            startTagGenericRawText(elementName, attributes);

            attributes = nullptr;

            NS_HTML5_BREAK(starttagloop);

          }

          case TEMPLATE: {

            startTagTemplateInHead(elementName, attributes);

            attributes = nullptr;

            NS_HTML5_BREAK(starttagloop);

          }

          default: {

            popTemplateMode();

            pushTemplateMode(IN_BODY);