AllContentModel.cpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:15k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 2001, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Log: AllContentModel.cpp,v $
  58.  * Revision 1.5  2003/05/18 14:02:06  knoaman
  59.  * Memory manager implementation: pass per instance manager.
  60.  *
  61.  * Revision 1.4  2003/05/15 18:48:27  knoaman
  62.  * Partial implementation of the configurable memory manager.
  63.  *
  64.  * Revision 1.3  2002/11/04 14:54:58  tng
  65.  * C++ Namespace Support.
  66.  *
  67.  * Revision 1.2  2002/09/24 19:48:39  tng
  68.  * Performance: use XMLString::equals instead of XMLString::compareString
  69.  *
  70.  * Revision 1.1.1.1  2002/02/01 22:22:37  peiyongz
  71.  * sane_include
  72.  *
  73.  * Revision 1.3  2001/11/21 14:30:13  knoaman
  74.  * Fix for UPA checking.
  75.  *
  76.  * Revision 1.2  2001/08/27 12:19:00  tng
  77.  * Schema: AllContentModel UPA Check typo fix
  78.  *
  79.  * Revision 1.1  2001/08/24 12:48:48  tng
  80.  * Schema: AllContentModel
  81.  *
  82.  */
  83. // ---------------------------------------------------------------------------
  84. //  Includes
  85. // ---------------------------------------------------------------------------
  86. #include <xercesc/util/RuntimeException.hpp>
  87. #include <xercesc/framework/XMLElementDecl.hpp>
  88. #include <xercesc/framework/XMLValidator.hpp>
  89. #include <xercesc/validators/common/ContentSpecNode.hpp>
  90. #include <xercesc/validators/common/AllContentModel.hpp>
  91. #include <xercesc/validators/schema/SubstitutionGroupComparator.hpp>
  92. #include <xercesc/validators/schema/XercesElementWildcard.hpp>
  93. XERCES_CPP_NAMESPACE_BEGIN
  94. // ---------------------------------------------------------------------------
  95. //  AllContentModel: Constructors and Destructor
  96. // ---------------------------------------------------------------------------
  97. AllContentModel::AllContentModel( ContentSpecNode* const parentContentSpec
  98.                                 , const bool             isMixed
  99.                                 , MemoryManager* const   manager) :
  100.    fMemoryManager(manager)
  101.  , fCount(0)
  102.  , fChildren(0)
  103.  , fChildOptional(0)
  104.  , fNumRequired(0)
  105.  , fIsMixed(isMixed)
  106. {
  107.     //
  108.     //  Create a vector of unsigned ints that will be filled in with the
  109.     //  ids of the child nodes. It will be expanded as needed but we give
  110.     //  it an initial capacity of 64 which should be more than enough for
  111.     //  99% of the scenarios.
  112.     //
  113.     ValueVectorOf<QName*> children(64, fMemoryManager);
  114.     ValueVectorOf<bool> childOptional(64, fMemoryManager);
  115.     //
  116.     //  Get the parent element's content spec. This is the head of the tree
  117.     //  of nodes that describes the content model. We will iterate this
  118.     //  tree.
  119.     //
  120.     ContentSpecNode* curNode = parentContentSpec;
  121.     if (!curNode)
  122.         ThrowXML(RuntimeException, XMLExcepts::CM_NoParentCSN);
  123.     // And now call the private recursive method that iterates the tree
  124.     buildChildList(curNode, children, childOptional);
  125.     //
  126.     //  And now we know how many elements we need in our member list. So
  127.     //  fill them in.
  128.     //
  129.     fCount = children.size();
  130.     fChildren = (QName**) fMemoryManager->allocate(fCount * sizeof(QName*)); //new QName*[fCount];
  131.     fChildOptional = (bool*) fMemoryManager->allocate(fCount * sizeof(bool)); //new bool[fCount];
  132.     for (unsigned int index = 0; index < fCount; index++) {
  133.         fChildren[index] = children.elementAt(index);
  134.         fChildOptional[index] = childOptional.elementAt(index);
  135.     }
  136. }
  137. AllContentModel::~AllContentModel()
  138. {
  139.     fMemoryManager->deallocate(fChildren); //delete [] fChildren;
  140.     fMemoryManager->deallocate(fChildOptional); //delete [] fChildOptional;
  141. }
  142. // ---------------------------------------------------------------------------
  143. //  AllContentModel: Implementation of the ContentModel virtual interface
  144. // ---------------------------------------------------------------------------
  145. //
  146. //Under the XML Schema mixed model,
  147. //the order and number of child elements appearing in an instance
  148. //must agree with
  149. //the order and number of child elements specified in the model.
  150. //
  151. int
  152. AllContentModel::validateContent( QName** const         children
  153.                                 , const unsigned int    childCount
  154.                                 , const unsigned int    emptyNamespaceId) const
  155. {
  156.     // If <all> had minOccurs of zero and there are
  157.     // no children to validate, trivially validate
  158.     if (!fNumRequired && !childCount)
  159.         return -1;
  160.     // Check for duplicate element
  161.     bool* elementSeen = (bool*) fMemoryManager->allocate(fCount*sizeof(bool)); //new bool[fCount];
  162.     // initialize the array
  163.     for (unsigned int i = 0; i < fCount; i++)
  164.         elementSeen[i] = false;
  165.     // keep track of the required element seen
  166.     unsigned int numRequiredSeen = 0;
  167.     for (unsigned int outIndex = 0; outIndex < childCount; outIndex++) {
  168.         // Get the current child out of the source index
  169.         const QName* curChild = children[outIndex];
  170.         // If its PCDATA, then we just accept that
  171.         if (fIsMixed && curChild->getURI() == XMLElementDecl::fgPCDataElemId)
  172.             continue;
  173.         // And try to find it in our list
  174.         unsigned int inIndex = 0;
  175.         for (; inIndex < fCount; inIndex++)
  176.         {
  177.             const QName* inChild = fChildren[inIndex];
  178.             if ((inChild->getURI() == curChild->getURI()) &&
  179.                 (XMLString::equals(inChild->getLocalPart(), curChild->getLocalPart()))) {
  180.                 // found it
  181.                 // If this element was seen already, indicate an error was
  182.                 // found at the duplicate index.
  183.                 if (elementSeen[inIndex]) {
  184.                     fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
  185.                     return outIndex;
  186.                 }
  187.                 else
  188.                     elementSeen[inIndex] = true;
  189.                 if (!fChildOptional[inIndex])
  190.                     numRequiredSeen++;
  191.                 break;
  192.             }
  193.         }
  194.         // We did not find this one, so the validation failed
  195.         if (inIndex == fCount) {
  196.             fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
  197.             return outIndex;
  198.         }
  199.     }
  200.     fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
  201.     // Were all the required elements of the <all> encountered?
  202.     if (numRequiredSeen != fNumRequired) {
  203.         return childCount;
  204.     }
  205.     // Everything seems to be ok, so return success
  206.     // success
  207.     return -1;
  208. }
  209. int AllContentModel::validateContentSpecial(QName** const           children
  210.                                           , const unsigned int      childCount
  211.                                           , const unsigned int      emptyNamespaceId
  212.                                           , GrammarResolver*  const pGrammarResolver
  213.                                           , XMLStringPool*    const pStringPool) const
  214. {
  215.     SubstitutionGroupComparator comparator(pGrammarResolver, pStringPool);
  216.     // If <all> had minOccurs of zero and there are
  217.     // no children to validate, trivially validate
  218.     if (!fNumRequired && !childCount)
  219.         return -1;
  220.     // Check for duplicate element
  221.     bool* elementSeen = (bool*) fMemoryManager->allocate(fCount*sizeof(bool)); //new bool[fCount];
  222.     // initialize the array
  223.     for (unsigned int i = 0; i < fCount; i++)
  224.         elementSeen[i] = false;
  225.     // keep track of the required element seen
  226.     unsigned int numRequiredSeen = 0;
  227.     for (unsigned int outIndex = 0; outIndex < childCount; outIndex++) {
  228.         // Get the current child out of the source index
  229.         QName* const curChild = children[outIndex];
  230.         // If its PCDATA, then we just accept that
  231.         if (fIsMixed && curChild->getURI() == XMLElementDecl::fgPCDataElemId)
  232.             continue;
  233.         // And try to find it in our list
  234.         unsigned int inIndex = 0;
  235.         for (; inIndex < fCount; inIndex++)
  236.         {
  237.             QName* const inChild = fChildren[inIndex];
  238.             if ( comparator.isEquivalentTo(curChild, inChild)) {
  239.                 // match
  240.                 // If this element was seen already, indicate an error was
  241.                 // found at the duplicate index.
  242.                 if (elementSeen[inIndex]) {
  243.                     fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
  244.                     return outIndex;
  245.                 }
  246.                 else
  247.                     elementSeen[inIndex] = true;
  248.                 if (!fChildOptional[inIndex])
  249.                     numRequiredSeen++;
  250.                 break;
  251.             }
  252.         }
  253.         // We did not find this one, so the validation failed
  254.         if (inIndex == fCount) {
  255.             fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
  256.             return outIndex;
  257.         }
  258.     }
  259.     fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
  260.     // Were all the required elements of the <all> encountered?
  261.     if (numRequiredSeen != fNumRequired) {
  262.         return childCount;
  263.     }
  264.     // Everything seems to be ok, so return success
  265.     // success
  266.     return -1;
  267. }
  268. void AllContentModel::checkUniqueParticleAttribution
  269.     (
  270.         SchemaGrammar*    const pGrammar
  271.       , GrammarResolver*  const pGrammarResolver
  272.       , XMLStringPool*    const pStringPool
  273.       , XMLValidator*     const pValidator
  274.       , unsigned int*     const pContentSpecOrgURI
  275.     )
  276. {
  277.     SubstitutionGroupComparator comparator(pGrammarResolver, pStringPool);
  278.     unsigned int i, j;
  279.     // rename back
  280.     for (i = 0; i < fCount; i++) {
  281.         unsigned int orgURIIndex = fChildren[i]->getURI();
  282.         fChildren[i]->setURI(pContentSpecOrgURI[orgURIIndex]);
  283.     }
  284.     // check whether there is conflict between any two leaves
  285.     for (i = 0; i < fCount; i++) {
  286.         for (j = i+1; j < fCount; j++) {
  287.             // If this is text in a Schema mixed content model, skip it.
  288.             if ( fIsMixed &&
  289.                  (( fChildren[i]->getURI() == XMLElementDecl::fgPCDataElemId) ||
  290.                   ( fChildren[j]->getURI() == XMLElementDecl::fgPCDataElemId)))
  291.                 continue;
  292.             if (XercesElementWildcard::conflict(pGrammar,
  293.                                                 ContentSpecNode::Leaf,
  294.                                                 fChildren[i],
  295.                                                 ContentSpecNode::Leaf,
  296.                                                 fChildren[j],
  297.                                                 &comparator)) {
  298.                 pValidator->emitError(XMLValid::UniqueParticleAttributionFail,
  299.                                       fChildren[i]->getRawName(),
  300.                                       fChildren[j]->getRawName());
  301.              }
  302.          }
  303.     }
  304. }
  305. // ---------------------------------------------------------------------------
  306. //  AllContentModel: Private helper methods
  307. // ---------------------------------------------------------------------------
  308. void
  309. AllContentModel::buildChildList(ContentSpecNode* const       curNode
  310.                               , ValueVectorOf<QName*>&       toFill
  311.                               , ValueVectorOf<bool>&         toOptional)
  312. {
  313.     // Get the type of spec node our current node is
  314.     const ContentSpecNode::NodeTypes curType = curNode->getType();
  315.     if (curType == ContentSpecNode::All)
  316.     {
  317.         // Get both the child node pointers
  318.         ContentSpecNode* leftNode = curNode->getFirst();
  319.         ContentSpecNode* rightNode = curNode->getSecond();
  320.         // Recurse on the left and right nodes
  321.         buildChildList(leftNode, toFill, toOptional);
  322.         buildChildList(rightNode, toFill, toOptional);
  323.     }
  324.     else if (curType == ContentSpecNode::Leaf)
  325.     {
  326.         // At leaf, add the element to list of elements permitted in the all
  327.         toFill.addElement(curNode->getElement());
  328.         toOptional.addElement(false);
  329.         fNumRequired++;
  330.     }
  331.     else if (curType == ContentSpecNode::ZeroOrOne)
  332.     {
  333.         // At ZERO_OR_ONE node, subtree must be an element
  334.         // that was specified with minOccurs=0, maxOccurs=1
  335.         ContentSpecNode* leftNode = curNode->getFirst();
  336.         if (leftNode->getType() != ContentSpecNode::Leaf)
  337.             ThrowXML(RuntimeException, XMLExcepts::CM_UnknownCMSpecType);
  338.         toFill.addElement(leftNode->getElement());
  339.         toOptional.addElement(true);
  340.     }
  341.     else
  342.         ThrowXML(RuntimeException, XMLExcepts::CM_UnknownCMSpecType);
  343. }
  344. XERCES_CPP_NAMESPACE_END