xref: /external/jsilver/src/com/google/streamhtmlparser/impl/HtmlParserImpl.java

/*
 * Copyright (C) 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.streamhtmlparser.impl;

import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import com.google.streamhtmlparser.ExternalState;
import com.google.streamhtmlparser.HtmlParser;
import com.google.streamhtmlparser.ParseException;
import com.google.streamhtmlparser.util.CharacterRecorder;
import com.google.streamhtmlparser.util.EntityResolver;
import com.google.streamhtmlparser.util.HtmlUtils;

import java.util.Map;

/**
 * A custom specialized parser - ported from the main C++ version - used to
 * implement context-aware escaping of run-time data in web-application
 * templates.
 *
 * <p>This is the main class in the package. It implements the
 * {@code HtmlParser} interface.
 *
 * <p>This class is not thread-safe, in particular you cannot invoke any
 * state changing operations (such as {@code parse} from multiple threads
 * on the same object.
 *
 * <p>If you are looking at this class, chances are very high you are
 * implementing Auto-Escaping for a new template system. Please see the
 * landing page including a design document at
 * <a href="http://go/autoescape">Auto-Escape Landing Page</a>.
 */
public class HtmlParserImpl extends GenericParser implements HtmlParser {

  /*
   * Internal representation of the parser state, which is at a
   * finer-granularity than the external state as given to callers.
   * The relationship between <code>InternalState</code> and
   * <code>ExternalState</code> is a many-to-one relationship.
   */
  private static final InternalState TEXT;
  private static final InternalState TAG_START;
  private static final InternalState TAG_NAME;
  private static final InternalState DECL_START;
  private static final InternalState DECL_BODY;
  private static final InternalState COM_OPEN;
  private static final InternalState COM_BODY;
  private static final InternalState COM_DASH;
  private static final InternalState COM_DASH_DASH;
  private static final InternalState PI;
  private static final InternalState PI_MAY_END;
  private static final InternalState TAG_SPACE;
  private static final InternalState TAG_CLOSE;
  private static final InternalState ATTR;
  private static final InternalState ATTR_SPACE;
  private static final InternalState VALUE;
  private static final InternalState VALUE_TEXT;
  private static final InternalState VALUE_Q_START;
  private static final InternalState VALUE_Q;
  private static final InternalState VALUE_DQ_START;
  private static final InternalState VALUE_DQ;
  private static final InternalState CDATA_COM_START;
  private static final InternalState CDATA_COM_START_DASH;
  private static final InternalState CDATA_COM_BODY;
  private static final InternalState CDATA_COM_DASH;
  private static final InternalState CDATA_COM_DASH_DASH;
  private static final InternalState CDATA_TEXT;
  private static final InternalState CDATA_LT;
  private static final InternalState CDATA_MAY_CLOSE;
  private static final InternalState JS_FILE;
  private static final InternalState CSS_FILE;

  static {
    TEXT = InternalState.getInstanceHtml("TEXT");
    TAG_START = InternalState.getInstanceHtml("TAG_START");
    TAG_NAME = InternalState.getInstanceHtml("TAG_NAME");
    DECL_START = InternalState.getInstanceHtml("DECL_START");
    DECL_BODY = InternalState.getInstanceHtml("DECL_BODY");
    COM_OPEN = InternalState.getInstanceHtml("COM_OPEN");
    COM_BODY = InternalState.getInstanceHtml("COM_BODY");
    COM_DASH = InternalState.getInstanceHtml("COM_DASH");
    COM_DASH_DASH = InternalState.getInstanceHtml("COM_DASH_DASH");
    PI =InternalState.getInstanceHtml("PI");
    PI_MAY_END = InternalState.getInstanceHtml("PI_MAY_END");
    TAG_SPACE = InternalState.getInstanceHtml("TAG_SPACE");
    TAG_CLOSE = InternalState.getInstanceHtml("TAG_CLOSE");
    ATTR = InternalState.getInstanceHtml("ATTR");
    ATTR_SPACE = InternalState.getInstanceHtml("ATTR_SPACE");
    VALUE = InternalState.getInstanceHtml("VALUE");
    VALUE_TEXT = InternalState.getInstanceHtml("VALUE_TEXT");
    VALUE_Q_START = InternalState.getInstanceHtml("VALUE_Q_START");
    VALUE_Q = InternalState.getInstanceHtml("VALUE_Q");
    VALUE_DQ_START = InternalState.getInstanceHtml("VALUE_DQ_START");
    VALUE_DQ = InternalState.getInstanceHtml("VALUE_DQ");
    CDATA_COM_START = InternalState.getInstanceHtml("CDATA_COM_START");
    CDATA_COM_START_DASH =
        InternalState.getInstanceHtml("CDATA_COM_START_DASH");
    CDATA_COM_BODY = InternalState.getInstanceHtml("CDATA_COM_BODY");
    CDATA_COM_DASH = InternalState.getInstanceHtml("CDATA_COM_DASH");
    CDATA_COM_DASH_DASH = InternalState.getInstanceHtml("CDATA_COM_DASH_DASH");
    CDATA_TEXT = InternalState.getInstanceHtml("CDATA_TEXT");
    CDATA_LT = InternalState.getInstanceHtml("CDATA_LT");
    CDATA_MAY_CLOSE = InternalState.getInstanceHtml("CDATA_MAY_CLOSE");
    JS_FILE = InternalState.getInstanceHtml("JS_FILE");
    CSS_FILE = InternalState.getInstanceHtml("CSS_FILE");
  }

  private static final Map<InternalState, ExternalState> STATE_MAPPING =
      Maps.newHashMap();
  static {
    initializeStateMapping();
  }

  private static final ParserStateTable STATE_TABLE = new ParserStateTable();
  static {
    initializeParserStateTable();
  }

  private final CharacterRecorder tag;
  private final CharacterRecorder attr;
  private final CharacterRecorder value;
  private final CharacterRecorder cdataCloseTag;
  private final EntityResolver entityResolver;
  private final JavascriptParserImpl jsParser;
  private boolean insideJavascript;
  private int valueIndex;
  // True iff InsertText() was called at the start of a URL attribute value.
  private boolean textInsideUrlValue;

  /**
   * Creates an {@code HtmlParserImpl} object.
   *
   * <p>Both for performance reasons and to leverage code a state-flow machine
   * that is automatically generated from Python for multiple target
   * languages, this object uses a static {@code ParserStateTable} that
   * is read-only and obtained from the generated code in {@code HtmlParserFsm}.
   * That code also maintains the mapping from internal states
   * ({@code InternalState}) to external states ({@code ExternalState}).
   */
  public HtmlParserImpl() {
    super(STATE_TABLE, STATE_MAPPING, TEXT);
    tag = new CharacterRecorder();
    attr = new CharacterRecorder();
    value = new CharacterRecorder();
    cdataCloseTag = new CharacterRecorder();
    entityResolver = new EntityResolver();
    jsParser = new JavascriptParserImpl();
    insideJavascript = false;
    valueIndex = 0;
    textInsideUrlValue = false;
  }

  /**
   * Creates an {@code HtmlParserImpl} that is a copy of the one provided.
   *
   * @param aHtmlParserImpl the {@code HtmlParserImpl} object to copy
   */
  public HtmlParserImpl(HtmlParserImpl aHtmlParserImpl) {
    super(aHtmlParserImpl);
    tag = new CharacterRecorder(aHtmlParserImpl.tag);
    attr = new CharacterRecorder(aHtmlParserImpl.attr);
    value = new CharacterRecorder(aHtmlParserImpl.value);
    cdataCloseTag = new CharacterRecorder(aHtmlParserImpl.cdataCloseTag);
    entityResolver = new EntityResolver(aHtmlParserImpl.entityResolver);
    jsParser = new JavascriptParserImpl(aHtmlParserImpl.jsParser);
    insideJavascript = aHtmlParserImpl.insideJavascript;
    valueIndex = aHtmlParserImpl.valueIndex;
    textInsideUrlValue = aHtmlParserImpl.textInsideUrlValue;
  }

  @Override
  public boolean inJavascript() {
    return (insideJavascript
            && ( (getState() == STATE_VALUE)
                 || (currentState == CDATA_TEXT)
                 || (currentState == CDATA_COM_START)
                 || (currentState == CDATA_COM_START_DASH)
                 || (currentState == CDATA_COM_BODY)
                 || (currentState == CDATA_COM_DASH)
                 || (currentState == CDATA_COM_DASH_DASH)
                 || (currentState == CDATA_LT)
                 || (currentState == CDATA_MAY_CLOSE)
                 || (currentState == JS_FILE) ));
  }

  @Override
  public boolean isJavascriptQuoted() {
    if (inJavascript()) {
      ExternalState jsParserState = jsParser.getState();
      return (jsParserState == JavascriptParserImpl.STATE_Q
              || jsParserState == JavascriptParserImpl.STATE_DQ);
    }
    return false;
  }

  @Override
  public boolean inAttribute() {
    ExternalState extState = getState();
    return (extState != null && (extState == STATE_ATTR
                                 || extState == STATE_VALUE));
  }

  /**
   * Returns {@code true} if and only if the parser is currently within
   * a CSS context. A CSS context is one of the below:
   * <ul>
   * <li>Inside a STYLE tag.
   * <li>Inside a STYLE attribute.
   * <li>Inside a CSS file when the parser was reset in the CSS mode.
   * </ul>
   *
   * @return {@code true} if and only if the parser is inside CSS
   */
  @Override
  public boolean inCss() {
    return (currentState == CSS_FILE
            || (getState() == STATE_VALUE
                && (getAttributeType() == ATTR_TYPE.STYLE))
            || ("style".equals(getTag())));
  }

  @Override
  public ATTR_TYPE getAttributeType() {
    String attribute = getAttribute();
    if (!inAttribute()) {
      return ATTR_TYPE.NONE;
    }
    if (HtmlUtils.isAttributeJavascript(attribute)) {
      return ATTR_TYPE.JS;
    }
    if (HtmlUtils.isAttributeUri(attribute)) {
      return ATTR_TYPE.URI;
    }
    if (HtmlUtils.isAttributeStyle(attribute)) {
      return ATTR_TYPE.STYLE;
    }

    // Special logic to handle the "content" attribute of the "meta" tag.
    if ("meta".equals(getTag()) && "content".equals(getAttribute())) {
      HtmlUtils.META_REDIRECT_TYPE redirectType =
          HtmlUtils.parseContentAttributeForUrl(getValue());
      if (redirectType == HtmlUtils.META_REDIRECT_TYPE.URL_START ||
          redirectType == HtmlUtils.META_REDIRECT_TYPE.URL)
        return ATTR_TYPE.URI;
    }

    return ATTR_TYPE.REGULAR;
  }

  @Override
  public ExternalState getJavascriptState() {
    return jsParser.getState();
  }

  @Override
  public boolean isAttributeQuoted() {
    return (currentState == VALUE_Q_START
            || currentState == VALUE_Q
            || currentState == VALUE_DQ_START
            || currentState == VALUE_DQ);
  }

  @Override
  public String getTag() {
    return tag.getContent().toLowerCase();
  }

  @Override
  public String getAttribute() {
    return inAttribute() ? attr.getContent().toLowerCase() : "";
  }

  @Override
  public String getValue() {
    return (getState() == STATE_VALUE) ? value.getContent() : "";
  }

  @Override
  public int getValueIndex() {
    if (getState() != STATE_VALUE) {
      return 0;
    }
    return valueIndex;
  }

  @Override
  public boolean isUrlStart() {
    // False when not inside an HTML attribute value
    if (getState() != STATE_VALUE) {
      return false;
    }

    //  Or when the HTML attribute is not of URI type.
    if (getAttributeType() != ATTR_TYPE.URI) {
      return false;
    }

    // Or when we received an InsertText() directive at the start of a URL.
    if (textInsideUrlValue) {
      return false;
    }

    if ("meta".equals(getTag())) {
      // At this point, we know we are in the "content" attribute
      // or we would not have the URI attribute type.
      return (HtmlUtils.parseContentAttributeForUrl(getValue()) ==
              HtmlUtils.META_REDIRECT_TYPE.URL_START);
    }

    // For all other URI attributes, check if we are at index 0.
    return (getValueIndex() == 0);
}

  /**
   * {@inheritDoc}
   *
   * Resets the state of the parser to a state consistent with the
   * {@code Mode} provided. This will reset finer-grained state
   * information back to a default value, hence use only when
   * you want to parse text from a very clean slate.
   *
   * <p>See the {@link HtmlParser.Mode} enum for information on all
   * the valid modes.
   *
   * @param mode is an enum representing the high-level state of the parser
   */
  @Override
  public void resetMode(Mode mode) {
    insideJavascript = false;
    tag.reset();
    attr.reset();
    value.reset();
    cdataCloseTag.reset();
    valueIndex = 0;
    textInsideUrlValue = false;
    jsParser.reset();

    switch (mode) {
      case HTML:
        currentState = TEXT;
        break;
      case JS:
        currentState = JS_FILE;
        insideJavascript = true;
        break;
      case CSS:
        currentState = CSS_FILE;
        break;
      case HTML_IN_TAG:
        currentState = TAG_SPACE;
        break;
      default:
        throw new IllegalArgumentException("Did not recognize Mode: " +
                                           mode.toString());
    }
  }

  /**
   * Resets the state of the parser to the initial state of parsing HTML.
   */
  public void reset() {
    super.reset();
    resetMode(Mode.HTML);
  }

  /**
   * A specialized directive to tell the parser there is some content
   * that will be inserted here but that it will not get to parse. Used
   * by the template system that may not be able to give some content
   * to the parser but wants it to know there typically will be content
   * inserted at that point.  This is a hint used in corner cases within
   * parsing of HTML attribute names and values where content we do not
   * get to see could affect our parsing and alter our current state.
   *
   * <p>The two cases where {@code #insertText()} affects our parsing are:
   * <ul>
   * <li>We are at the start of the value of a URL-accepting HTML attribute. In
   * that case, we change internal state to no longer be considered at the
   * start of the URL. This may affect what escaping template systems may want
   * to perform on the HTML attribute value. We avoid injecting fake data and
   * hence not modify the current index of the value as determined by
   * {@link #getValueIndex()}</li>
   * <li>We just transitioned from an attribute name to an attribute value
   * (by parsing the separating {@code '='} character). In that case, we
   * change internal state to be now inside a non-quoted HTML attribute
   * value.</li>
   * </ul>
   *
   * @throws ParseException if an unrecoverable error occurred during parsing
   */
  @Override
  public void insertText() throws ParseException {
    // Case: Inside URL attribute value.
    if (getState() == STATE_VALUE
        && getAttributeType() == ATTR_TYPE.URI
        && isUrlStart()) {
      textInsideUrlValue = true;
    }
    // Case: Before parsing any attribute value.
    if (currentState == VALUE) {
      setNextState(VALUE_TEXT);
    }
  }

  @Override
  protected InternalState handleEnterState(InternalState currentState,
                                           InternalState expectedNextState,
                                           char input) {
    InternalState nextState = expectedNextState;
    if (currentState == TAG_NAME) {
      enterTagName();
    } else if (currentState == ATTR) {
      enterAttribute();
    } else if (currentState == TAG_CLOSE) {
      nextState = tagClose(currentState);
    } else if (currentState == CDATA_MAY_CLOSE) {
      enterStateCdataMayClose();
    } else if (currentState == VALUE) {
      enterValue();
    } else
    if (currentState == VALUE_TEXT || currentState == VALUE_Q
        || currentState == VALUE_DQ) {
      enterValueContent();
    }
    return nextState;
  }

  @Override
  protected InternalState handleExitState(InternalState currentState,
                                          InternalState expectedNextState,
                                          char input) {
    InternalState nextState = expectedNextState;
    if (currentState == TAG_NAME) {
      exitTagName();
    } else if (currentState == ATTR) {
      exitAttribute();
    } else if (currentState == CDATA_MAY_CLOSE) {
      nextState = exitStateCdataMayClose(nextState, input);
    } else
    if ((currentState == VALUE_TEXT) || (currentState == VALUE_Q)
        || (currentState == VALUE_DQ)) {
      exitValueContent();
    }
    return nextState;
  }

  @Override
  protected InternalState handleInState(InternalState currentState,
                                        char input) throws ParseException {
    if ((currentState == CDATA_TEXT)
        || (currentState == CDATA_COM_START)
        || (currentState == CDATA_COM_START_DASH)
        || (currentState == CDATA_COM_BODY)
        || (currentState == CDATA_COM_DASH)
        || (currentState == CDATA_COM_DASH_DASH)
        || (currentState == CDATA_LT)
        || (currentState == CDATA_MAY_CLOSE)
        || (currentState == JS_FILE)) {
      inStateCdata(input);
    } else if ((currentState == VALUE_TEXT)
               || (currentState == VALUE_Q)
               || (currentState == VALUE_DQ)) {
      inStateValue(input);
    }
    return currentState;
  }

  /**
   * Invokes recording on all CharacterRecorder objects. Currently we do
   * not check that one and only one of them is recording. I did a fair
   * bit of testing on the C++ parser and was not convinced there is
   * such a guarantee.
   */
  @Override
  protected void record(char input) {
    attr.maybeRecord(input);
    tag.maybeRecord(input);
    value.maybeRecord(input);
    cdataCloseTag.maybeRecord(input);
  }

  /**
   * Starts recording the name of the HTML tag. Called when the parser
   * enters a new tag.
   */
  private void enterTagName() {
    tag.startRecording();
  }

  private void exitTagName() {
    tag.stopRecording();
    String tagString = tag.getContent();
    if (!tagString.isEmpty() && tagString.charAt(0) == '/') {
      tag.reset();
    }
  }

  /**
   * Starts recording the name of the HTML attribute. Called when the parser
   * enters a new HTML attribute.
   */
  private void enterAttribute() {
    attr.startRecording();
  }

  private void exitAttribute() {
    attr.stopRecording();
  }

  /**
   * Tracks the index within the HTML attribute value and initializes
   * the javascript parser for attributes that take javascript.
   *
   * Called when the parser enters a new HTML attribute value.
   */
  private void enterValue() {
    valueIndex = 0;
    textInsideUrlValue = false;
    if (HtmlUtils.isAttributeJavascript(getAttribute())) {
      entityResolver.reset();
      jsParser.reset();
      insideJavascript = true;
    } else {
      insideJavascript = false;
    }
  }

  /**
   * Starts recordning the contents of the attribute value.
   *
   * Called when entering an attribute value.
   */
  private void enterValueContent() {
    value.startRecording();
  }

  /**
   * Stops the recording of the attribute value and exits javascript
   * (in case we were inside it).
   */
  private void exitValueContent() {
    value.stopRecording();
    insideJavascript = false;
  }

  /**
   * Processes javascript after performing entity resolution and updates
   * the position within the attribute value.
   * If the status of the entity resolution is <code>IN_PROGRESS</code>,
   * we don't invoke the javascript parser.
   *
   * <p>Called for every character inside an attribute value.
   *
   * @param input character read
   * @throws ParseException if an unrecoverable error occurred during parsing
   */
  private void inStateValue(char input) throws ParseException {
    valueIndex++;
    if (insideJavascript) {
      EntityResolver.Status status = entityResolver.processChar(input);
      if (status == EntityResolver.Status.COMPLETED) {
        jsParser.parse(entityResolver.getEntity());
        entityResolver.reset();
      } else if (status == EntityResolver.Status.NOT_STARTED) {
        jsParser.parse(input);
      }
    }
  }

  /**
   * Handles the tag it finished reading.
   *
   * <p>For a script tag, it initializes the javascript parser. For all
   * tags that are recognized to have CDATA values
   * (including the script tag), it switches the CDATA state to handle them
   * properly. For code simplification, CDATA and RCDATA sections are
   * treated the same.
   *
   * <p>Called when the parser leaves a tag definition.
   *
   * @param state current state
   * @return state next state, could be the same as current state
   */
  private InternalState tagClose(InternalState state) {
    InternalState nextState = state;
    String tagName = getTag();
    if ("script".equals(tagName)) {
      nextState = CDATA_TEXT;
      jsParser.reset();
      insideJavascript = true;
    } else if ("style".equals(tagName)
                 || "title".equals(tagName)
                 || "textarea".equals(tagName)) {
      nextState = CDATA_TEXT;
      insideJavascript = false;
    }
    return nextState;
  }

  /**
   * Feeds the character to the javascript parser for processing.
   *
   * <p>Called inside CDATA blocks to parse javascript.
   *
   * @param input character read
   * @throws ParseException if an unrecoverable error occurred during parsing
   */
  private void inStateCdata(char input) throws ParseException {
    if (insideJavascript) {
      jsParser.parse(input);
    }
  }

  /**
   * Starts recording. This is so we find the closing tag name in order to
   * know if the tag is going to be closed or not.
   *
   * <p>Called when encountering a '<' character in a CDATA section.
   */
  private void enterStateCdataMayClose() {
    cdataCloseTag.startRecording();
  }

  /**
   * Determines whether to close the tag element, It closes it if it finds
   * the corresponding end tag. Called when reading what could be a
   * closing CDATA tag.
   *
   * @param input the character read
   * @param expectedNextState the expected state to go to next
   *        unless we want to change it here
   * @return the next state to go to
   */
  private InternalState exitStateCdataMayClose(
      InternalState expectedNextState,
      char input) {
    InternalState nextState = expectedNextState;
    cdataCloseTag.stopRecording();
    String cdataCloseTagString = cdataCloseTag.getContent();
    Preconditions.checkState(!cdataCloseTagString.isEmpty()
        && cdataCloseTagString.charAt(0) == '/');  // Developer error.

    if (cdataCloseTagString.substring(1).equalsIgnoreCase(getTag())
        && (input == '>' || HtmlUtils.isHtmlSpace(input))) {
      tag.clear();
      insideJavascript = false;
    } else {
      nextState = CDATA_TEXT;
    }
    return nextState;
  }


  // ======================================================= //
  // SECTION BELOW WILL ALL BE AUTO-GENERATED IN FUTURE.     //
  // ======================================================= //

  private static void registerMapping(InternalState internalState,
                                      ExternalState externalState) {
    STATE_MAPPING.put(internalState, externalState);
  }

  private static void initializeStateMapping() {
    // Each parser implementation must map the error state appropriately.
    registerMapping(InternalState.INTERNAL_ERROR_STATE, HtmlParser.STATE_ERROR);

    registerMapping(TEXT, HtmlParser.STATE_TEXT);
    registerMapping(TAG_START, HtmlParser.STATE_TAG);
    registerMapping(TAG_NAME, HtmlParser.STATE_TAG);
    registerMapping(DECL_START, HtmlParser.STATE_TEXT);
    registerMapping(DECL_BODY, HtmlParser.STATE_TEXT);
    registerMapping(COM_OPEN, HtmlParser.STATE_TEXT);
    registerMapping(COM_BODY, HtmlParser.STATE_COMMENT);
    registerMapping(COM_DASH, HtmlParser.STATE_COMMENT);
    registerMapping(COM_DASH_DASH, HtmlParser.STATE_COMMENT);
    registerMapping(PI, HtmlParser.STATE_TEXT);
    registerMapping(PI_MAY_END, HtmlParser.STATE_TEXT);
    registerMapping(TAG_SPACE, HtmlParser.STATE_TAG);
    registerMapping(TAG_CLOSE, HtmlParser.STATE_TEXT);
    registerMapping(ATTR, HtmlParser.STATE_ATTR);
    registerMapping(ATTR_SPACE, HtmlParser.STATE_ATTR);
    registerMapping(VALUE, HtmlParser.STATE_VALUE);
    registerMapping(VALUE_TEXT, HtmlParser.STATE_VALUE);
    registerMapping(VALUE_Q_START, HtmlParser.STATE_VALUE);
    registerMapping(VALUE_Q, HtmlParser.STATE_VALUE);
    registerMapping(VALUE_DQ_START, HtmlParser.STATE_VALUE);
    registerMapping(VALUE_DQ, HtmlParser.STATE_VALUE);
    registerMapping(CDATA_COM_START, HtmlParser.STATE_TEXT);
    registerMapping(CDATA_COM_START_DASH, HtmlParser.STATE_TEXT);
    registerMapping(CDATA_COM_BODY, HtmlParser.STATE_TEXT);
    registerMapping(CDATA_COM_DASH, HtmlParser.STATE_TEXT);
    registerMapping(CDATA_COM_DASH_DASH, HtmlParser.STATE_TEXT);
    registerMapping(CDATA_TEXT, HtmlParser.STATE_TEXT);
    registerMapping(CDATA_LT, HtmlParser.STATE_TEXT);
    registerMapping(CDATA_MAY_CLOSE, HtmlParser.STATE_TEXT);
    registerMapping(JS_FILE, HtmlParser.STATE_JS_FILE);
    registerMapping(CSS_FILE, HtmlParser.STATE_CSS_FILE);
  }

  private static void registerTransition(String expression,
                                         InternalState source,
                                         InternalState to) {
    // It seems to silly to go through a StateTableTransition here
    // but it adds extra data checking.
    StateTableTransition stt = new StateTableTransition(expression,
                                                        source, to);
    STATE_TABLE.setExpression(stt.getExpression(), stt.getFrom(),
                              stt.getTo());
  }

  // NOTE: The "[:default:]" transition should be registered before any
  //   other transitions for a given state or it will over-write them.
  private static void initializeParserStateTable() {
    registerTransition("[:default:]", CSS_FILE, CSS_FILE);
    registerTransition("[:default:]", JS_FILE, JS_FILE);
    registerTransition("[:default:]", CDATA_MAY_CLOSE, CDATA_TEXT);
    registerTransition(" \t\n\r", CDATA_MAY_CLOSE, TAG_SPACE);
    registerTransition(">", CDATA_MAY_CLOSE, TEXT);
    registerTransition("A-Za-z0-9/_:-", CDATA_MAY_CLOSE, CDATA_MAY_CLOSE);
    registerTransition("[:default:]", CDATA_LT, CDATA_TEXT);
    registerTransition("!", CDATA_LT, CDATA_COM_START);
    registerTransition("/", CDATA_LT, CDATA_MAY_CLOSE);
    registerTransition("[:default:]", CDATA_TEXT, CDATA_TEXT);
    registerTransition("<", CDATA_TEXT, CDATA_LT);
    registerTransition("[:default:]", CDATA_COM_DASH_DASH, CDATA_COM_BODY);
    registerTransition(">", CDATA_COM_DASH_DASH, CDATA_TEXT);
    registerTransition("-", CDATA_COM_DASH_DASH, CDATA_COM_DASH_DASH);
    registerTransition("[:default:]", CDATA_COM_DASH, CDATA_COM_BODY);
    registerTransition("-", CDATA_COM_DASH, CDATA_COM_DASH_DASH);
    registerTransition("[:default:]", CDATA_COM_BODY, CDATA_COM_BODY);
    registerTransition("-", CDATA_COM_BODY, CDATA_COM_DASH);
    registerTransition("[:default:]", CDATA_COM_START_DASH, CDATA_TEXT);
    registerTransition("-", CDATA_COM_START_DASH, CDATA_COM_BODY);
    registerTransition("[:default:]", CDATA_COM_START, CDATA_TEXT);
    registerTransition("-", CDATA_COM_START, CDATA_COM_START_DASH);
    registerTransition("[:default:]", VALUE_DQ, VALUE_DQ);
    registerTransition("\"", VALUE_DQ, TAG_SPACE);
    registerTransition("[:default:]", VALUE_DQ_START, VALUE_DQ);
    registerTransition("\"", VALUE_DQ_START, TAG_SPACE);
    registerTransition("[:default:]", VALUE_Q, VALUE_Q);
    registerTransition("\'", VALUE_Q, TAG_SPACE);
    registerTransition("[:default:]", VALUE_Q_START, VALUE_Q);
    registerTransition("\'", VALUE_Q_START, TAG_SPACE);
    registerTransition("[:default:]", VALUE_TEXT, VALUE_TEXT);
    registerTransition(" \t\n\r", VALUE_TEXT, TAG_SPACE);
    registerTransition(">", VALUE_TEXT, TAG_CLOSE);
    registerTransition("[:default:]", VALUE, VALUE_TEXT);
    registerTransition(">", VALUE, TAG_CLOSE);
    registerTransition(" \t\n\r", VALUE, VALUE);
    registerTransition("\"", VALUE, VALUE_DQ_START);
    registerTransition("\'", VALUE, VALUE_Q_START);
    registerTransition("=", ATTR_SPACE, VALUE);
    registerTransition("/", ATTR_SPACE, TAG_SPACE);
    registerTransition("A-Za-z0-9_:-", ATTR_SPACE, ATTR);
    registerTransition(" \t\n\r", ATTR_SPACE, ATTR_SPACE);
    registerTransition(">", ATTR_SPACE, TAG_CLOSE);
    registerTransition(" \t\n\r", ATTR, ATTR_SPACE);
    registerTransition("=", ATTR, VALUE);
    registerTransition("/", ATTR, TAG_SPACE);
    registerTransition(">", ATTR, TAG_CLOSE);
    registerTransition("A-Za-z0-9_:.-", ATTR, ATTR);
    registerTransition("[:default:]", TAG_CLOSE, TEXT);
    registerTransition("<", TAG_CLOSE, TAG_START);
    registerTransition("/", TAG_SPACE, TAG_SPACE);
    registerTransition("A-Za-z0-9_:-", TAG_SPACE, ATTR);
    registerTransition(" \t\n\r", TAG_SPACE, TAG_SPACE);
    registerTransition(">", TAG_SPACE, TAG_CLOSE);
    registerTransition("[:default:]", PI_MAY_END, PI);
    registerTransition(">", PI_MAY_END, TEXT);
    registerTransition("[:default:]", PI, PI);
    registerTransition("?", PI, PI_MAY_END);
    registerTransition("[:default:]", COM_DASH_DASH, COM_BODY);
    registerTransition(">", COM_DASH_DASH, TEXT);
    registerTransition("-", COM_DASH_DASH, COM_DASH_DASH);
    registerTransition("[:default:]", COM_DASH, COM_BODY);
    registerTransition("-", COM_DASH, COM_DASH_DASH);
    registerTransition("[:default:]", COM_BODY, COM_BODY);
    registerTransition("-", COM_BODY, COM_DASH);
    registerTransition("[:default:]", COM_OPEN, TEXT);
    registerTransition("-", COM_OPEN, COM_BODY);
    registerTransition("[:default:]", DECL_BODY, DECL_BODY);
    registerTransition(">", DECL_BODY, TEXT);
    registerTransition("[:default:]", DECL_START, DECL_BODY);
    registerTransition(">", DECL_START, TEXT);
    registerTransition("-", DECL_START, COM_OPEN);
    registerTransition(">", TAG_NAME, TAG_CLOSE);
    registerTransition(" \t\n\r", TAG_NAME, TAG_SPACE);
    registerTransition("A-Za-z0-9/_:-", TAG_NAME, TAG_NAME);

    // Manual change to remain in-sync with CL 10597850 in C HtmlParser.
    registerTransition("[:default:]", TAG_START, TEXT);
    registerTransition("<", TAG_START, TAG_START);
    // End of manual change.

    registerTransition("!", TAG_START, DECL_START);
    registerTransition("?", TAG_START, PI);
    registerTransition("A-Za-z0-9/_:-", TAG_START, TAG_NAME);
    registerTransition("[:default:]", TEXT, TEXT);
    registerTransition("<", TEXT, TAG_START);
  }
}