/*
* 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);
}
}