/*
* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
*/
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.sun.org.apache.xerces.internal.impl.dtd.models;
import com.sun.org.apache.xerces.internal.impl.dtd.XMLContentSpec;
import com.sun.org.apache.xerces.internal.xni.QName;
import java.util.HashMap;
import java.util.Map;
/**
* DFAContentModel is the derivative of ContentModel that does
* all of the non-trivial element content validation. This class does
* the conversion from the regular expression to the DFA that
* it then uses in its validation algorithm.
*
* Note: Upstream work insures that this class will never see
* a content model with PCDATA in it. Any model with PCDATA is 'mixed'
* and is handled via the MixedContentModel class since mixed models
* are very constrained in form and easily handled via a special case.
* This also makes implementation of this class much easier.
*
* @xerces.internal
*
* @LastModified: Oct 2017
*/
public class DFAContentModel
implements ContentModelValidator {
//
// Constants
//
// special strings
/** Epsilon string. */
private static String fEpsilonString = "<>";
/** End-of-content string. */
private static String fEOCString = "<>";
/** initializing static members **/
static {
fEpsilonString = fEpsilonString.intern();
fEOCString = fEOCString.intern();
}
// debugging
/** Set to true to debug content model validation. */
private static final boolean DEBUG_VALIDATE_CONTENT = false;
//
// Data
//
/* this is the EquivClassComparator object */
//private EquivClassComparator comparator = null;
/**
* This is the map of unique input symbol elements to indices into
* each state's per-input symbol transition table entry. This is part
* of the built DFA information that must be kept around to do the
* actual validation.
*/
private QName fElemMap[] = null;
/**
* This is a map of whether the element map contains information
* related to ANY models.
*/
private int fElemMapType[] = null;
/** The element map size. */
private int fElemMapSize = 0;
/** Boolean to distinguish Schema Mixed Content */
private boolean fMixed;
/**
* The NFA position of the special EOC (end of content) node. This
* is saved away since it's used during the DFA build.
*/
private int fEOCPos = 0;
/**
* This is an array of booleans, one per state (there are
* fTransTableSize states in the DFA) that indicates whether that
* state is a final state.
*/
private boolean fFinalStateFlags[] = null;
/**
* The list of follow positions for each NFA position (i.e. for each
* non-epsilon leaf node.) This is only used during the building of
* the DFA, and is let go afterwards.
*/
private CMStateSet fFollowList[] = null;
/**
* This is the head node of our intermediate representation. It is
* only non-null during the building of the DFA (just so that it
* does not have to be passed all around.) Once the DFA is built,
* this is no longer required so its nulled out.
*/
private CMNode fHeadNode = null;
/**
* The count of leaf nodes. This is an important number that set some
* limits on the sizes of data structures in the DFA process.
*/
private int fLeafCount = 0;
/**
* An array of non-epsilon leaf nodes, which is used during the DFA
* build operation, then dropped.
*/
private CMLeaf fLeafList[] = null;
/** Array mapping ANY types to the leaf list. */
private int fLeafListType[] = null;
//private ContentLeafNameTypeVector fLeafNameTypeVector = null;
/**
* The string pool of our parser session. This is set during construction
* and kept around.
*/
//private StringPool fStringPool = null;
/**
* This is the transition table that is the main by product of all
* of the effort here. It is an array of arrays of ints. The first
* dimension is the number of states we end up with in the DFA. The
* second dimensions is the number of unique elements in the content
* model (fElemMapSize). Each entry in the second dimension indicates
* the new state given that input for the first dimension's start
* state.
*
* The fElemMap array handles mapping from element indexes to
* positions in the second dimension of the transition table.
*/
private int fTransTable[][] = null;
/**
* The number of valid entries in the transition table, and in the other
* related tables such as fFinalStateFlags.
*/
private int fTransTableSize = 0;
/**
* Flag that indicates that even though we have a "complicated"
* content model, it is valid to have no content. In other words,
* all parts of the content model are optional. For example:
*
* <!ELEMENT AllOptional (Optional*,NotRequired?)>
*
*/
private boolean fEmptyContentIsValid = false;
// temp variables
/** Temporary qualified name. */
private final QName fQName = new QName();
//
// Constructors
//
//
// Constructors
//
/**
* Constructs a DFA content model.
*
* @param syntaxTree The syntax tree of the content model.
* @param leafCount The number of leaves.
* @param mixed
*
*/
public DFAContentModel(CMNode syntaxTree, int leafCount, boolean mixed) {
// Store away our index and pools in members
//fStringPool = stringPool;
fLeafCount = leafCount;
// this is for Schema Mixed Content
fMixed = mixed;
//
// Ok, so lets grind through the building of the DFA. This method
// handles the high level logic of the algorithm, but it uses a
// number of helper classes to do its thing.
//
// In order to avoid having hundreds of references to the error and
// string handlers around, this guy and all of his helper classes
// just throw a simple exception and we then pass it along.
//
buildDFA(syntaxTree);
}
//
// ContentModelValidator methods
//
/**
* Check that the specified content is valid according to this
* content model. This method can also be called to do 'what if'
* testing of content models just to see if they would be valid.
*
* A value of -1 in the children array indicates a PCDATA node. All other
* indexes will be positive and represent child elements. The count can be
* zero, since some elements have the EMPTY content model and that must be
* confirmed.
*
* @param children The children of this element. Each integer is an index within
* the StringPool
of the child element name. An index
* of -1 is used to indicate an occurrence of non-whitespace character
* data.
* @param offset Offset into the array where the children starts.
* @param length The number of entries in the children
array.
*
* @return The value -1 if fully valid, else the 0 based index of the child
* that first failed. If the value returned is equal to the number
* of children, then the specified children are valid but additional
* content is required to reach a valid ending state.
*
*/
public int validate(QName[] children, int offset, int length) {
if (DEBUG_VALIDATE_CONTENT)
System.out.println("DFAContentModel#validateContent");
//
// A DFA content model must *always* have at least 1 child
// so a failure is given if no children present.
//
// Defect 782: This is an incorrect statement because a DFA
// content model is also used for constructions such as:
//
// (Optional*,NotRequired?)
//
// where a perfectly valid content would be NO CHILDREN.
// Therefore, if there are no children, we must check to
// see if the CMNODE_EOC marker is a valid start state! -Ac
//
if (length == 0) {
if (DEBUG_VALIDATE_CONTENT) {
System.out.println("!!! no children");
System.out.println("elemMap="+fElemMap);
for (int i = 0; i < fElemMap.length; i++) {
String uri = fElemMap[i].uri;
String localpart = fElemMap[i].localpart;
System.out.println("fElemMap["+i+"]="+uri+","+
localpart+" ("+
uri+", "+
localpart+
')');
}
System.out.println("EOCIndex="+fEOCString);
}
return fEmptyContentIsValid ? -1 : 0;
} // if child count == 0
//
// Lets loop through the children in the array and move our way
// through the states. Note that we use the fElemMap array to map
// an element index to a state index.
//
int curState = 0;
for (int childIndex = 0; childIndex < length; childIndex++)
{
// Get the current element index out
final QName curElem = children[offset + childIndex];
// ignore mixed text
if (fMixed && curElem.localpart == null) {
continue;
}
// Look up this child in our element map
int elemIndex = 0;
for (; elemIndex < fElemMapSize; elemIndex++)
{
int type = fElemMapType[elemIndex] & 0x0f ;
if (type == XMLContentSpec.CONTENTSPECNODE_LEAF) {
//System.out.println("fElemMap["+elemIndex+"]: "+fElemMap[elemIndex]);
if (fElemMap[elemIndex].rawname == curElem.rawname) {
break;
}
}
else if (type == XMLContentSpec.CONTENTSPECNODE_ANY) {
String uri = fElemMap[elemIndex].uri;
if (uri == null || uri == curElem.uri) {
break;
}
}
else if (type == XMLContentSpec.CONTENTSPECNODE_ANY_LOCAL) {
if (curElem.uri == null) {
break;
}
}
else if (type == XMLContentSpec.CONTENTSPECNODE_ANY_OTHER) {
if (fElemMap[elemIndex].uri != curElem.uri) {
break;
}
}
}
// If we didn't find it, then obviously not valid
if (elemIndex == fElemMapSize) {
if (DEBUG_VALIDATE_CONTENT) {
System.out.println("!!! didn't find it");
System.out.println("curElem : " +curElem );
for (int i=0; i stateTable = new HashMap<>();
/* Optimization(Jan, 2001) */
//
// Ok, almost done with the algorithm... We now enter the
// loop where we go until the states done counter catches up with
// the states to do counter.
//
while (unmarkedState < curState)
{
//
// Get the first unmarked state out of the list of states to do.
// And get the associated transition table entry.
//
setT = statesToDo[unmarkedState];
int[] transEntry = fTransTable[unmarkedState];
// Mark this one final if it contains the EOC state
fFinalStateFlags[unmarkedState] = setT.getBit(fEOCPos);
// Bump up the unmarked state count, marking this state done
unmarkedState++;
// Loop through each possible input symbol in the element map
CMStateSet newSet = null;
/* Optimization(Jan, 2001) */
int sorterIndex = 0;
/* Optimization(Jan, 2001) */
for (int elemIndex = 0; elemIndex < fElemMapSize; elemIndex++)
{
//
// Build up a set of states which is the union of all of
// the follow sets of DFA positions that are in the current
// state. If we gave away the new set last time through then
// create a new one. Otherwise, zero out the existing one.
//
if (newSet == null)
newSet = new CMStateSet(fLeafCount);
else
newSet.zeroBits();
/* Optimization(Jan, 2001) */
int leafIndex = fLeafSorter[sorterIndex++];
while (leafIndex != -1) {
// If this leaf index (DFA position) is in the current set...
if (setT.getBit(leafIndex))
{
//
// If this leaf is the current input symbol, then we
// want to add its follow list to the set of states to
// transition to from the current state.
//
newSet.union(fFollowList[leafIndex]);
}
leafIndex = fLeafSorter[sorterIndex++];
}
/* Optimization(Jan, 2001) */
//
// If this new set is not empty, then see if its in the list
// of states to do. If not, then add it.
//
if (!newSet.isEmpty())
{
//
// Search the 'states to do' list to see if this new
// state set is already in there.
//
/* Optimization(Jan, 2001) */
Integer stateObj = stateTable.get(newSet);
int stateIndex = (stateObj == null ? curState : stateObj.intValue());
/* Optimization(Jan, 2001) */
// If we did not find it, then add it
if (stateIndex == curState)
{
//
// Put this new state into the states to do and init
// a new entry at the same index in the transition
// table.
//
statesToDo[curState] = newSet;
fTransTable[curState] = makeDefStateList();
/* Optimization(Jan, 2001) */
stateTable.put(newSet, curState);
/* Optimization(Jan, 2001) */
// We now have a new state to do so bump the count
curState++;
//
// Null out the new set to indicate we adopted it.
// This will cause the creation of a new set on the
// next time around the loop.
//
newSet = null;
}
//
// Now set this state in the transition table's entry
// for this element (using its index), with the DFA
// state we will move to from the current state when we
// see this input element.
//
transEntry[elemIndex] = stateIndex;
// Expand the arrays if we're full
if (curState == curArraySize)
{
//
// Yikes, we overflowed the initial array size, so
// we've got to expand all of these arrays. So adjust
// up the size by 50% and allocate new arrays.
//
final int newSize = (int)(curArraySize * 1.5);
CMStateSet[] newToDo = new CMStateSet[newSize];
boolean[] newFinalFlags = new boolean[newSize];
int[][] newTransTable = new int[newSize][];
// Copy over all of the existing content
System.arraycopy(statesToDo, 0, newToDo, 0, curArraySize);
System.arraycopy(fFinalStateFlags, 0, newFinalFlags, 0, curArraySize);
System.arraycopy(fTransTable, 0, newTransTable, 0, curArraySize);
// Store the new array size
curArraySize = newSize;
statesToDo = newToDo;
fFinalStateFlags = newFinalFlags;
fTransTable = newTransTable;
}
}
}
}
// Check to see if we can set the fEmptyContentIsValid flag.
fEmptyContentIsValid = ((CMBinOp)fHeadNode).getLeft().isNullable();
//
// And now we can say bye bye to the temp representation since we've
// built the DFA.
//
if (DEBUG_VALIDATE_CONTENT)
dumpTree(fHeadNode, 0);
fHeadNode = null;
fLeafList = null;
fFollowList = null;
}
/**
* Calculates the follow list of the current node.
*
* @param nodeCur The curent node.
*
* @exception CMException Thrown if follow list cannot be calculated.
*/
private void calcFollowList(CMNode nodeCur)
{
// Recurse as required
if (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_CHOICE)
{
// Recurse only
calcFollowList(((CMBinOp)nodeCur).getLeft());
calcFollowList(((CMBinOp)nodeCur).getRight());
}
else if (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_SEQ)
{
// Recurse first
calcFollowList(((CMBinOp)nodeCur).getLeft());
calcFollowList(((CMBinOp)nodeCur).getRight());
//
// Now handle our level. We use our left child's last pos
// set and our right child's first pos set, so go ahead and
// get them ahead of time.
//
final CMStateSet last = ((CMBinOp)nodeCur).getLeft().lastPos();
final CMStateSet first = ((CMBinOp)nodeCur).getRight().firstPos();
//
// Now, for every position which is in our left child's last set
// add all of the states in our right child's first set to the
// follow set for that position.
//
for (int index = 0; index < fLeafCount; index++)
{
if (last.getBit(index))
fFollowList[index].union(first);
}
}
/***
else if (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE)
{
// Recurse first
calcFollowList(((CMUniOp)nodeCur).getChild());
//
// Now handle our level. We use our own first and last position
// sets, so get them up front.
//
final CMStateSet first = nodeCur.firstPos();
final CMStateSet last = nodeCur.lastPos();
//
// For every position which is in our last position set, add all
// of our first position states to the follow set for that
// position.
//
for (int index = 0; index < fLeafCount; index++)
{
if (last.getBit(index))
fFollowList[index].union(first);
}
}
else if ((nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE)
|| (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE))
{
throw new RuntimeException("ImplementationMessages.VAL_NIICM");
}
/***/
else if (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE
|| nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE)
{
// Recurse first
calcFollowList(((CMUniOp)nodeCur).getChild());
//
// Now handle our level. We use our own first and last position
// sets, so get them up front.
//
final CMStateSet first = nodeCur.firstPos();
final CMStateSet last = nodeCur.lastPos();
//
// For every position which is in our last position set, add all
// of our first position states to the follow set for that
// position.
//
for (int index = 0; index < fLeafCount; index++)
{
if (last.getBit(index))
fFollowList[index].union(first);
}
}
else if (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE) {
// Recurse only
calcFollowList(((CMUniOp)nodeCur).getChild());
}
/***/
}
/**
* Dumps the tree of the current node to standard output.
*
* @param nodeCur The current node.
* @param level The maximum levels to output.
*
* @exception CMException Thrown on error.
*/
private void dumpTree(CMNode nodeCur, int level)
{
for (int index = 0; index < level; index++)
System.out.print(" ");
int type = nodeCur.type();
if ((type == XMLContentSpec.CONTENTSPECNODE_CHOICE)
|| (type == XMLContentSpec.CONTENTSPECNODE_SEQ))
{
if (type == XMLContentSpec.CONTENTSPECNODE_CHOICE)
System.out.print("Choice Node ");
else
System.out.print("Seq Node ");
if (nodeCur.isNullable())
System.out.print("Nullable ");
System.out.print("firstPos=");
System.out.print(nodeCur.firstPos().toString());
System.out.print(" lastPos=");
System.out.println(nodeCur.lastPos().toString());
dumpTree(((CMBinOp)nodeCur).getLeft(), level+1);
dumpTree(((CMBinOp)nodeCur).getRight(), level+1);
}
else if (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE)
{
System.out.print("Rep Node ");
if (nodeCur.isNullable())
System.out.print("Nullable ");
System.out.print("firstPos=");
System.out.print(nodeCur.firstPos().toString());
System.out.print(" lastPos=");
System.out.println(nodeCur.lastPos().toString());
dumpTree(((CMUniOp)nodeCur).getChild(), level+1);
}
else if (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_LEAF)
{
System.out.print
(
"Leaf: (pos="
+ ((CMLeaf)nodeCur).getPosition()
+ "), "
+ ((CMLeaf)nodeCur).getElement()
+ "(elemIndex="
+ ((CMLeaf)nodeCur).getElement()
+ ") "
);
if (nodeCur.isNullable())
System.out.print(" Nullable ");
System.out.print("firstPos=");
System.out.print(nodeCur.firstPos().toString());
System.out.print(" lastPos=");
System.out.println(nodeCur.lastPos().toString());
}
else
{
throw new RuntimeException("ImplementationMessages.VAL_NIICM");
}
}
/**
* -1 is used to represent bad transitions in the transition table
* entry for each state. So each entry is initialized to an all -1
* array. This method creates a new entry and initializes it.
*/
private int[] makeDefStateList()
{
int[] retArray = new int[fElemMapSize];
for (int index = 0; index < fElemMapSize; index++)
retArray[index] = -1;
return retArray;
}
/** Post tree build initialization. */
private int postTreeBuildInit(CMNode nodeCur, int curIndex)
{
// Set the maximum states on this node
nodeCur.setMaxStates(fLeafCount);
// Recurse as required
if ((nodeCur.type() & 0x0f) == XMLContentSpec.CONTENTSPECNODE_ANY ||
(nodeCur.type() & 0x0f) == XMLContentSpec.CONTENTSPECNODE_ANY_LOCAL ||
(nodeCur.type() & 0x0f) == XMLContentSpec.CONTENTSPECNODE_ANY_OTHER) {
// REVISIT: Don't waste these structures.
QName qname = new QName(null, null, null, ((CMAny)nodeCur).getURI());
fLeafList[curIndex] = new CMLeaf(qname, ((CMAny)nodeCur).getPosition());
fLeafListType[curIndex] = nodeCur.type();
curIndex++;
}
else if ((nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_CHOICE)
|| (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_SEQ))
{
curIndex = postTreeBuildInit(((CMBinOp)nodeCur).getLeft(), curIndex);
curIndex = postTreeBuildInit(((CMBinOp)nodeCur).getRight(), curIndex);
}
else if (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE
|| nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE
|| nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE)
{
curIndex = postTreeBuildInit(((CMUniOp)nodeCur).getChild(), curIndex);
}
else if (nodeCur.type() == XMLContentSpec.CONTENTSPECNODE_LEAF)
{
//
// Put this node in the leaf list at the current index if its
// a non-epsilon leaf.
//
final QName node = ((CMLeaf)nodeCur).getElement();
if (node.localpart != fEpsilonString) {
fLeafList[curIndex] = (CMLeaf)nodeCur;
fLeafListType[curIndex] = XMLContentSpec.CONTENTSPECNODE_LEAF;
curIndex++;
}
}
else
{
throw new RuntimeException("ImplementationMessages.VAL_NIICM: type="+nodeCur.type());
}
return curIndex;
}
} // class DFAContentModel