开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
SchemaValidator.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：88k
源码类别：

词法分析

开发平台：

Visual C++

SchemaValidator.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001-2002 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.  */
  57. /*
  58.  * $Log: SchemaValidator.cpp,v $
  59.  * Revision 1.32  2003/05/18 14:02:08  knoaman
  60.  * Memory manager implementation: pass per instance manager.
  61.  *
  62.  * Revision 1.31  2003/05/16 21:43:21  knoaman
  63.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  64.  *
  65.  * Revision 1.30  2003/05/16 03:15:51  knoaman
  66.  * Partial implementation of the configurable memory manager.
  67.  *
  68.  * Revision 1.29  2003/05/15 18:57:27  knoaman
  69.  * Partial implementation of the configurable memory manager.
  70.  *
  71.  * Revision 1.28  2003/02/06 13:51:55  gareth
  72.  * fixed bug with multiple attributes being validated by the same union type.
  73.  *
  74.  * Revision 1.27  2003/01/29 20:01:20  gareth
  75.  * We now detect when elements/attributes are validated and the result of the validation is stored.
  76.  *
  77.  * Revision 1.26  2003/01/20 19:04:48  knoaman
  78.  * Fix for particle derivation checking.
  79.  *
  80.  * Revision 1.25  2003/01/13 20:16:51  knoaman
  81.  * [Bug 16024] SchemaSymbols.hpp conflicts C++ Builder 6 dir.h
  82.  *
  83.  * Revision 1.24  2002/12/20 22:10:47  tng
  84.  * XML 1.1
  85.  *
  86.  * Revision 1.23  2002/12/12 20:53:28  knoaman
  87.  * Schema Errata E1-15.
  88.  *
  89.  * Revision 1.22  2002/12/04 02:47:26  knoaman
  90.  * scanner re-organization.
  91.  *
  92.  * Revision 1.21  2002/11/27 22:15:42  peiyongz
  93.  * Schema Errat E2-24 Duration 'T': allow to catch SchemaDateTimeException
  94.  *
  95.  * Revision 1.20  2002/11/27 21:27:14  peiyongz
  96.  * Schema Errat E2-24 Duration 'T': allow to catch SchemaDateTimeException
  97.  *
  98.  * Revision 1.19  2002/11/26 21:20:09  tng
  99.  * Schema Fix: List can have Union, and Union can have List.  So need to check its items for ID/IDREF/Entity.
  100.  *
  101.  * Revision 1.18  2002/11/07 21:57:37  tng
  102.  * Fix the following Schema Test Failures:
  103.  * 1. Typo when comparing miscFlags with FIXED
  104.  * 2. If xsi:type is specified, need to validate using that xsitype validator even if the type was any
  105.  * 3. Need to check ID/IDREFs for element value
  106.  * 4. Need to duplicate attribute id for wildcard scenario.
  107.  *
  108.  * Revision 1.17  2002/11/04 14:49:42  tng
  109.  * C++ Namespace Support.
  110.  *
  111.  * Revision 1.16  2002/09/24 20:12:48  tng
  112.  * Performance: use XMLString::equals instead of XMLString::compareString
  113.  *
  114.  * Revision 1.15  2002/09/16 20:37:08  tng
  115.  * Infinite loop for malformed xml (e.g. simple has "XXXX") w/ setexitonfirstfatal(false).
  116.  *
  117.  * Revision 1.14  2002/09/04 18:17:41  tng
  118.  * Do not set IDREF to used during prevalidation.
  119.  *
  120.  * Revision 1.13  2002/07/11 18:55:44  knoaman
  121.  * Add a flag to the preContentValidation method to indicate whether to validate
  122.  * default/fixed attributes or not.
  123.  *
  124.  * Revision 1.12  2002/06/17 18:53:58  tng
  125.  * DOM L3: support "datatype-normalization"
  126.  *
  127.  * Revision 1.11  2002/06/17 18:09:29  tng
  128.  * DOM L3: support "datatype-normalization"
  129.  *
  130.  * Revision 1.10  2002/05/23 21:27:21  knoaman
  131.  * Fix "Array Bound Read" problem reported by Purify.
  132.  *
  133.  * Revision 1.9  2002/04/19 13:33:23  knoaman
  134.  * Fix for bug 8236.
  135.  *
  136.  * Revision 1.8  2002/04/01 20:17:55  peiyongz
  137.  * Bug#7551: Exceptions are caught by value, rather than by reference
  138.  *
  139.  * Revision 1.7  2002/04/01 15:47:06  knoaman
  140.  * Move Element Consistency checking (ref to global declarations) to SchemaValidator.
  141.  *
  142.  * Revision 1.6  2002/03/25 20:25:32  knoaman
  143.  * Move particle derivation checking from TraverseSchema to SchemaValidator.
  144.  *
  145.  * Revision 1.5  2002/02/26 14:26:10  tng
  146.  * [Bug 6672] SAXValidator results in an access violation when validating against schema with empty element that has default value.
  147.  *
  148.  * Revision 1.4  2002/02/25 21:24:31  tng
  149.  * Schema Fix: Ensure no invalid uri index for UPA checking.
  150.  *
  151.  * Revision 1.3  2002/02/25 21:18:18  tng
  152.  * Schema Fix: Ensure no invalid uri index for UPA checking.
  153.  *
  154.  * Revision 1.2  2002/02/07 16:41:29  knoaman
  155.  * Fix for xsi:type.
  156.  *
  157.  * Revision 1.1.1.1  2002/02/01 22:22:47  peiyongz
  158.  * sane_include
  159.  *
  160.  * Revision 1.26  2001/11/21 18:05:09  tng
  161.  * Schema Fix: Check both XMLAttDef::Fixed and XMLAttDef::Required_And_Fixed for default values.
  162.  *
  163.  * Revision 1.25  2001/11/21 14:30:13  knoaman
  164.  * Fix for UPA checking.
  165.  *
  166.  * Revision 1.24  2001/11/20 20:32:52  knoaman
  167.  * Bypass validating element's simple content if it's empty and element is nillable.
  168.  *
  169.  * Revision 1.23  2001/11/13 13:25:08  tng
  170.  * Deprecate function XMLValidator::checkRootElement.
  171.  *
  172.  * Revision 1.22  2001/11/09 18:10:58  tng
  173.  * Schema Fix: should concatenate all characters for validation.
  174.  *
  175.  * Revision 1.21  2001/10/23 13:35:36  tng
  176.  * Schema fix: Resolve notation prefix to an URI.
  177.  *
  178.  * Revision 1.20  2001/10/12 20:44:01  tng
  179.  * Schema Fix: Notation Uri Binding.
  180.  *
  181.  * Revision 1.19  2001/10/04 15:08:56  knoaman
  182.  * Add support for circular import.
  183.  *
  184.  * Revision 1.18  2001/09/10 14:06:22  tng
  185.  * Schema: AnyAttribute support in Scanner and Validator.
  186.  *
  187.  * Revision 1.17  2001/09/05 20:49:11  knoaman
  188.  * Fix for complexTypes with mixed content model.
  189.  *
  190.  * Revision 1.16  2001/08/30 15:47:46  tng
  191.  * Schema: xsi:type fixes
  192.  *
  193.  * Revision 1.15  2001/08/29 20:52:35  tng
  194.  * Schema: xsi:type support
  195.  *
  196.  * Revision 1.14  2001/08/28 19:20:54  tng
  197.  * Schema: xsi:type support
  198.  *
  199.  * Revision 1.13  2001/08/21 16:06:11  tng
  200.  * Schema: Unique Particle Attribution Constraint Checking.
  201.  *
  202.  * Revision 1.12  2001/08/09 15:23:16  knoaman
  203.  * add support for <anyAttribute> declaration.
  204.  *
  205.  * Revision 1.11  2001/07/26 17:04:11  tng
  206.  * Schema: Process should stop after fatal error, and user throws need to be rethrown.
  207.  *
  208.  * Revision 1.10  2001/07/24 21:23:40  tng
  209.  * Schema: Use DatatypeValidator for ID/IDREF/ENTITY/ENTITIES/NOTATION.
  210.  *
  211.  * Revision 1.9  2001/07/11 21:39:58  peiyongz
  212.  * fix to normalizeWhiteSpace: synchronize fDatatypeBuffer with toFill.
  213.  *
  214.  * Revision 1.8  2001/05/17 18:14:32  tng
  215.  * Schema Fix: if nillable, it's an error to have default value
  216.  *
  217.  * Revision 1.7  2001/05/11 15:17:46  tng
  218.  * Schema: Nillable fixes.
  219.  *
  220.  * Revision 1.6  2001/05/11 13:27:37  tng
  221.  * Copyright update.
  222.  *
  223.  * Revision 1.5  2001/05/10 17:49:42  tng
  224.  * Schema: SchemaValidator fixes
  225.  *
  226.  * Revision 1.4  2001/05/03 20:34:44  tng
  227.  * Schema: SchemaValidator update
  228.  *
  229.  * Revision 1.3  2001/04/19 18:17:39  tng
  230.  * Schema: SchemaValidator update, and use QName in Content Model
  231.  *
  232.  * Revision 1.2  2001/03/30 16:35:19  tng
  233.  * Schema: Whitespace normalization.
  234.  *
  235.  * Revision 1.1  2001/03/21 21:56:33  tng
  236.  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
  237.  *
  238.  */
  240. // ---------------------------------------------------------------------------
  241. //  Includes
  242. // ---------------------------------------------------------------------------
  243. #include <xercesc/util/Janitor.hpp>
  244. #include <xercesc/util/KVStringPair.hpp>
  245. #include <xercesc/framework/XMLDocumentHandler.hpp>
  246. #include <xercesc/internal/XMLReader.hpp>
  247. #include <xercesc/internal/XMLScanner.hpp>
  248. #include <xercesc/internal/ElemStack.hpp>
  249. #include <xercesc/validators/datatype/DatatypeValidatorFactory.hpp>
  250. #include <xercesc/validators/datatype/ListDatatypeValidator.hpp>
  251. #include <xercesc/validators/datatype/UnionDatatypeValidator.hpp>
  252. #include <xercesc/validators/datatype/ENTITYDatatypeValidator.hpp>
  253. #include <xercesc/validators/datatype/IDDatatypeValidator.hpp>
  254. #include <xercesc/validators/datatype/IDREFDatatypeValidator.hpp>
  255. #include <xercesc/validators/schema/SchemaSymbols.hpp>
  256. #include <xercesc/validators/schema/SchemaValidator.hpp>
  257. #include <xercesc/validators/schema/SubstitutionGroupComparator.hpp>
  258. #include <xercesc/validators/schema/XercesGroupInfo.hpp>
  259. #include <xercesc/validators/schema/XSDLocator.hpp>
  261. XERCES_CPP_NAMESPACE_BEGIN
  263. // ---------------------------------------------------------------------------
  264. //  SchemaValidator: Constructors and Destructor
  265. // ---------------------------------------------------------------------------
  266. SchemaValidator::SchemaValidator( XMLErrorReporter* const errReporter
  267.                                 , MemoryManager* const    manager) :
  269.     XMLValidator(errReporter)
  270.     , fMemoryManager(manager)
  271.     , fGrammarResolver(0)
  272.     , fSchemaGrammar(0)
  273.     , fTrailing(false)
  274.     , fSeenId(false)
  275.     , fXsiType(0)
  276.     , fXsiTypeValidator(0)
  277.     , fDatatypeBuffer(1023, manager)
  278.     , fNil(false)
  279.     , fTypeStack(0)
  280. {
  281.     fTypeStack = new (fMemoryManager) ValueStackOf<ComplexTypeInfo*>(8, fMemoryManager);
  282. }
  284. SchemaValidator::~SchemaValidator()
  285. {
  286.     delete fXsiType;
  287.     delete fTypeStack;
  288. }
  290. // ---------------------------------------------------------------------------
  291. //  SchemaValidator: Implementation of the XMLValidator interface
  292. // ---------------------------------------------------------------------------
  293. int SchemaValidator::checkContent (XMLElementDecl* const elemDecl
  294.                                  , QName** const         children
  295.                                  , const unsigned int    childCount)
  296. {
  297.     bool valid = true;
  299.     //
  300.     //  Look up the element id in our element decl pool. This will get us
  301.     //  the element decl in our own way of looking at them.
  302.     //
  303.     if (!elemDecl)
  304.         ThrowXML(RuntimeException, XMLExcepts::Val_InvalidElemId);
  306.     ((SchemaElementDecl*) elemDecl)->setXsiComplexTypeInfo(fTypeStack->pop());
  308.     //
  309.     //  Get the content spec type of this element. This will tell us what
  310.     //  to do to validate it.
  311.     //
  312.     const SchemaElementDecl::ModelTypes modelType = ((SchemaElementDecl*) elemDecl)->getModelType();
  314.     if (modelType == SchemaElementDecl::Empty)
  315.     {
  316.         //
  317.         //  We can do this one here. It cannot have any children. If it does
  318.         //  we return 0 as the index of the first bad child.
  319.         //
  320.         if (childCount) {
  321.             return 0;
  322.         }
  323.     }
  324.     else if ((modelType == SchemaElementDecl::Mixed_Simple)
  325.          ||  (modelType == SchemaElementDecl::Mixed_Complex)
  326.          ||  (modelType == SchemaElementDecl::Children))
  327.     {
  328.         // if nillable, it's an error to have value
  329.         // XML Schema REC: Validation Rule: Element Locally Valid (Element)
  330.         // 3.2.1 The element information item must have no
  331.         // character or element information item [children].
  332.         //
  333.         if (fNil) {
  334.             if (childCount > 0 || !XMLString::equals(fDatatypeBuffer.getRawBuffer(), XMLUni::fgZeroLenString)) {
  335.                 emitError(XMLValid::NilAttrNotEmpty, elemDecl->getFullName());
  336.                 ((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
  337.                 valid = false;
  338.             }
  340.         }
  341.         else {
  342.             // Get the element's content model or fault it in
  343.             XMLContentModel* elemCM = elemDecl->getContentModel();
  345.             // Ask it to validate and return its return
  346.             unsigned int emptyNS = getScanner()->getEmptyNamespaceId();
  347.             int result = elemCM->validateContent(children, childCount, emptyNS);
  348.             if (result != -1) {
  349.                 result = elemCM->validateContentSpecial(children
  350.                                                       , childCount
  351.                                                       , emptyNS
  352.                                                       , fGrammarResolver
  353.                                                       , getScanner()->getURIStringPool());
  354.             }
  356.             if(result != -1) {
  357.                 ((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
  358.             }
  360.             return result;
  361.         }
  362.     }
  363.     else if (modelType == SchemaElementDecl::Simple || modelType == SchemaElementDecl::Any)
  364.     {
  365.         // Normally for SchemaElementDecl::Any, We pass no judgement on it and anything goes
  366.         // but if there is a fXsiTypeValidator, we need to use it for validation
  369.         if (modelType == SchemaElementDecl::Simple && childCount > 0) {
  370.             emitError(XMLValid::SimpleTypeHasChild, elemDecl->getFullName());
  371.             valid = false;
  372.         } else {
  373.             try {
  374.                 DatatypeValidator* fCurrentDV = 0;
  375.                 bool hasXsiType = false;
  377.                 if (modelType == SchemaElementDecl::Simple)
  378.                     fCurrentDV = ((SchemaElementDecl*)elemDecl)->getDatatypeValidator();
  380.                 // If there is xsi:type validator, substitute it.
  381.                 if (fXsiTypeValidator) {
  382.                     hasXsiType = true;
  383.                     fCurrentDV = fXsiTypeValidator;
  384.                     fXsiTypeValidator = 0;
  385.                 }
  386.                 if (!fCurrentDV) {
  387.                     if (modelType == SchemaElementDecl::Simple) {
  388.                         emitError(XMLValid::NoDatatypeValidatorForSimpleType, elemDecl->getFullName());
  389.                         valid = false;
  390.                     }
  391.                 } else {
  392.                     XMLCh* value = fDatatypeBuffer.getRawBuffer();
  393.                     XMLCh* elemDefaultValue = ((SchemaElementDecl*) elemDecl)->getDefaultValue();
  395.                     DatatypeValidator::ValidatorType eleDefDVType = fCurrentDV->getType();
  397.                     // if notation, need to bind URI to notation first
  398.                     XMLBuffer notationBuf(1023, fMemoryManager);
  400.                     // set up the entitydeclpool in ENTITYDatatypeValidator
  401.                     // and the idreflist in ID/IDREFDatatypeValidator
  403.                     if (eleDefDVType == DatatypeValidator::List) {
  404.                         DatatypeValidator* itemDTV = ((ListDatatypeValidator*)fCurrentDV)->getItemTypeDTV();
  405.                         DatatypeValidator::ValidatorType itemDTVType = itemDTV->getType();
  406.                         if (itemDTVType == DatatypeValidator::ENTITY)
  407.                             ((ENTITYDatatypeValidator*)itemDTV)->setEntityDeclPool(getScanner()->getEntityDeclPool());
  408.                         else if (itemDTVType == DatatypeValidator::ID)
  409.                             ((IDDatatypeValidator*)itemDTV)->setIDRefList(getScanner()->getIDRefList());
  410.                         else if (itemDTVType == DatatypeValidator::IDREF) {
  411.                             ((IDREFDatatypeValidator*)itemDTV)->setIDRefList(getScanner()->getIDRefList());
  412.                         }
  413.                         else if (itemDTVType == DatatypeValidator::Union) {
  414.                             RefVectorOf<DatatypeValidator>* memberDTV = ((UnionDatatypeValidator*)itemDTV)->getMemberTypeValidators();
  415.                             unsigned int memberTypeNumber = memberDTV->size();
  416.                             for ( unsigned int memberIndex = 0; memberIndex < memberTypeNumber; ++memberIndex)
  417.                             {
  418.                                 DatatypeValidator::ValidatorType memberDTVType = memberDTV->elementAt(memberIndex)->getType();
  419.                                 if (memberDTVType == DatatypeValidator::ENTITY)
  420.                                     ((ENTITYDatatypeValidator*)memberDTV->elementAt(memberIndex))->setEntityDeclPool(getScanner()->getEntityDeclPool());
  421.                                 else if (memberDTVType == DatatypeValidator::ID)
  422.                                     ((IDDatatypeValidator*)memberDTV->elementAt(memberIndex))->setIDRefList(getScanner()->getIDRefList());
  423.                                 else if (memberDTVType == DatatypeValidator::IDREF) {
  424.                                     ((IDREFDatatypeValidator*)memberDTV->elementAt(memberIndex))->setIDRefList(getScanner()->getIDRefList());
  425.                                 }
  426.                             }
  427.                         }
  428.                     }
  429.                     else if (eleDefDVType == DatatypeValidator::Union) {
  430.                         RefVectorOf<DatatypeValidator>* memberDTV = ((UnionDatatypeValidator*)fCurrentDV)->getMemberTypeValidators();
  431.                         unsigned int memberTypeNumber = memberDTV->size();
  432.                         for ( unsigned int memberIndex = 0; memberIndex < memberTypeNumber; ++memberIndex)
  433.                         {
  434.                             DatatypeValidator::ValidatorType memberDTVType = memberDTV->elementAt(memberIndex)->getType();
  435.                             if (memberDTVType == DatatypeValidator::ENTITY)
  436.                                 ((ENTITYDatatypeValidator*)memberDTV->elementAt(memberIndex))->setEntityDeclPool(getScanner()->getEntityDeclPool());
  437.                             else if (memberDTVType == DatatypeValidator::ID)
  438.                                 ((IDDatatypeValidator*)memberDTV->elementAt(memberIndex))->setIDRefList(getScanner()->getIDRefList());
  439.                             else if (memberDTVType == DatatypeValidator::IDREF) {
  440.                                 ((IDREFDatatypeValidator*)memberDTV->elementAt(memberIndex))->setIDRefList(getScanner()->getIDRefList());
  441.                             }
  442.                             else if (memberDTVType == DatatypeValidator::List) {
  443.                                 DatatypeValidator* itemDTV = ((ListDatatypeValidator*)memberDTV->elementAt(memberIndex))->getItemTypeDTV();
  444.                                 DatatypeValidator::ValidatorType itemDTVType = itemDTV->getType();
  445.                                 if (itemDTVType == DatatypeValidator::ENTITY)
  446.                                     ((ENTITYDatatypeValidator*)itemDTV)->setEntityDeclPool(getScanner()->getEntityDeclPool());
  447.                                 else if (itemDTVType == DatatypeValidator::ID)
  448.                                     ((IDDatatypeValidator*)itemDTV)->setIDRefList(getScanner()->getIDRefList());
  449.                                 else if (itemDTVType == DatatypeValidator::IDREF) {
  450.                                     ((IDREFDatatypeValidator*)itemDTV)->setIDRefList(getScanner()->getIDRefList());
  451.                                 }
  452.                             }
  453.                         }
  454.                     }
  455.                     else if (eleDefDVType == DatatypeValidator::ENTITY)
  456.                         ((ENTITYDatatypeValidator*)fCurrentDV)->setEntityDeclPool(getScanner()->getEntityDeclPool());
  457.                     else if (eleDefDVType == DatatypeValidator::ID)
  458.                         ((IDDatatypeValidator*)fCurrentDV)->setIDRefList(getScanner()->getIDRefList());
  459.                     else if (eleDefDVType == DatatypeValidator::IDREF) {
  460.                         ((IDREFDatatypeValidator*)fCurrentDV)->setIDRefList(getScanner()->getIDRefList());
  461.                     }
  462.                     else if (eleDefDVType == DatatypeValidator::NOTATION)
  463.                     {
  464.                         //
  465.                         //  Make sure that this value maps to one of the
  466.                         //  notation values in the enumList parameter. We don't have to
  467.                         //  look it up in the notation pool (if a notation) because we
  468.                         //  will look up the enumerated values themselves. If they are in
  469.                         //  the notation pool (after the Grammar is parsed), then obviously
  470.                         //  this value will be legal since it matches one of them.
  471.                         //
  472.                         int colonPos = -1;
  473.                         unsigned int uriId = getScanner()->resolveQName(value, notationBuf, ElemStack::Mode_Element, colonPos);
  474.                         notationBuf.set(getScanner()->getURIText(uriId));
  475.                         notationBuf.append(chColon);
  476.                         notationBuf.append(&value[colonPos + 1]);
  477.                         value = notationBuf.getRawBuffer();
  478.                     }
  480.                     if (elemDefaultValue) {
  481.                         // a default value was specified
  483.                         // if nillable, it's an error to have default value
  484.                         if (fNil) {
  485.                             emitError(XMLValid::NilAttrNotEmpty, elemDecl->getFullName());
  486.                             valid = false;
  487.                         }
  488.                         if (XMLString::equals(value, XMLUni::fgZeroLenString)) {
  489.                             // if this element didn't specified any value
  490.                             // use default value
  491.                             if (getScanner()->getDocHandler())
  492.                                 getScanner()->getDocHandler()->docCharacters(elemDefaultValue, XMLString::stringLen(elemDefaultValue), false);
  494.                             // Normally for default value, it has been validated already during TraverseSchema
  495.                             // But if there was a xsi:type and this validator is fXsiTypeValidator,
  496.                             // need to validate again
  497.                             if (hasXsiType)
  498.                                 fCurrentDV->validate(elemDefaultValue);
  500.                         }
  501.                         else {
  502.                             // this element has specified some value
  503.                             // if the flag is FIXED, then this value must be same as default value
  504.                             if ((((SchemaElementDecl*)elemDecl)->getMiscFlags() & SchemaSymbols::XSD_FIXED) != 0) {
  505.                                 if (fCurrentDV->compare(value, elemDefaultValue) != 0 ) {
  506.                                     emitError(XMLValid::FixedDifferentFromActual, elemDecl->getFullName());
  507.                                     valid = false;
  508.                                 }
  509.                             }
  511.                             // if nillable, it's an error to have value
  512.                             if (fNil) {
  513.                                 emitError(XMLValid::NilAttrNotEmpty, elemDecl->getFullName());
  514.                                 valid = false;
  515.                             }
  516.                             else
  517.                                 fCurrentDV->validate(value);
  518.                         }
  519.                     }
  520.                     else {
  521.                         // no default value, then check nillable
  522.                         if (XMLString::equals(value, XMLUni::fgZeroLenString)) {
  523.                             if ((((SchemaElementDecl*)elemDecl)->getMiscFlags() & SchemaSymbols::XSD_NILLABLE) == 0)
  524.                                 fCurrentDV->validate(value);
  525.                         }
  526.                         else if (fNil) {
  527.                             emitError(XMLValid::NilAttrNotEmpty, elemDecl->getFullName());
  528.                             valid = false;
  529.                         }
  530.                         else
  531.                             fCurrentDV->validate(value);
  532.                     }
  533.                 }
  534.             }
  535.             catch (XMLException& idve) {
  536.                 emitError (XMLValid::DatatypeError, idve.getType(), idve.getMessage());
  537.                 valid = false;
  538.             }
  539.             catch (...) {
  540.                 ((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
  541.                 emitError(XMLValid::GenericError);
  542.                 throw;
  543.             }
  544.         }
  545.     }
  546.      else
  547.     {
  548.         ThrowXML(RuntimeException, XMLExcepts::CM_UnknownCMType);
  549.     }
  551.     fDatatypeBuffer.reset();
  552.     fNil = false;
  553.     fTrailing=false;
  555.     if(!valid) {
  556.         ((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
  557.     }
  558.        
  559.     // Went ok, so return success
  560.     return -1;
  561. }
  563. void SchemaValidator::faultInAttr (XMLAttr&    toFill, const XMLAttDef&  attDef)   const
  564. {
  565.     //
  566.     //  At this level, we cannot set the URI id. So we just set it to zero
  567.     //  and leave it at that. The scanner, who called us, will look at the
  568.     //  prefix we stored (if any), resolve it, and store the URL id if any.
  569.     //
  570.     SchemaAttDef* schemaAttDef = (SchemaAttDef*) &attDef;
  571.     QName* attName = schemaAttDef->getAttName();
  573.     toFill.set
  574.     (
  575.           attName->getURI()
  576.         , attName->getLocalPart()
  577.         , attName->getPrefix()
  578.         , schemaAttDef->getValue()
  579.         , schemaAttDef->getType()
  580.     );
  581. }
  583. void SchemaValidator::reset()
  584. {
  585.     fTrailing = false;
  586.     fSeenId = false;
  587.     delete fXsiType;
  588.     fXsiType = 0;
  589.     fXsiTypeValidator = 0;
  590.     fNil = false;
  591.     fDatatypeBuffer.reset();
  592. }
  594. bool SchemaValidator::requiresNamespaces() const
  595. {
  596.     return true;
  597. }
  599. void SchemaValidator::validateAttrValue (const XMLAttDef*      attDef
  600.                                        , const XMLCh* const    attrValue
  601.                                        , bool                  preValidation
  602.                                        , const XMLElementDecl* elemDecl)
  603. {
  605.     //
  606.     //  Get quick refs to lot of the stuff in the passed objects in
  607.     //  order to simplify the code below, which will reference them very
  608.     //  often.
  609.     //
  610.     XMLAttDef::AttTypes            type      = attDef->getType();
  611.     const XMLAttDef::DefAttTypes   defType   = attDef->getDefaultType();
  612.     const XMLCh* const             fullName  = attDef->getFullName();
  613.     bool valid = true;
  615.     //
  616.     //  If the default type is fixed, then make sure the passed value maps
  617.     //  to the fixed value.
  618.     //
  619.     //  If during preContentValidation, the value we are validating is the fixed value itself
  620.     //  so no need to compare.
  621.     //  Only need to do this for regular attribute value validation
  622.     //
  623.     if ((defType == XMLAttDef::Fixed || defType == XMLAttDef::Required_And_Fixed) && !preValidation)
  624.     {
  625.         const XMLCh* const valueText = attDef->getValue();
  626.         if (!XMLString::equals(attrValue, valueText)) {
  627.             emitError(XMLValid::NotSameAsFixedValue, fullName, attrValue, valueText);
  628.             valid = false;
  629.         }
  630.     }
  632.     // An empty string cannot be valid for non_CDATA any of the other types
  633.     if (!attrValue[0] && type != XMLAttDef::Simple)
  634.     {
  635.         emitError(XMLValid::InvalidEmptyAttValue, fullName);
  636.         ((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
  637.         ((SchemaAttDef *)(attDef))->setValidity(PSVIDefs::INVALID);
  638.         return;
  639.     }
  641.     DatatypeValidator* attDefDV = ((SchemaAttDef*) attDef)->getDatatypeValidator();
  642.     if (!attDefDV) {
  643.         emitError(XMLValid::NoDatatypeValidatorForAttribute, fullName);
  644.         valid = false;
  645.     }
  646.     else {
  647.         try {
  648.             DatatypeValidator::ValidatorType attDefDVType = attDefDV->getType();
  650.             // set up the entitydeclpool in ENTITYDatatypeValidator
  651.             // and the idreflist in ID/IDREFDatatypeValidator
  653.             // indicate if this attribute is of type ID
  654.             bool thisIsAnId = false;
  656.             if (attDefDVType == DatatypeValidator::List) {
  657.                 DatatypeValidator* itemDTV = ((ListDatatypeValidator*)attDefDV)->getItemTypeDTV();
  658.                 DatatypeValidator::ValidatorType itemDTVType = itemDTV->getType();
  659.                 if (itemDTVType == DatatypeValidator::ENTITY)
  660.                     ((ENTITYDatatypeValidator*)itemDTV)->setEntityDeclPool(getScanner()->getEntityDeclPool());
  661.                 else if (itemDTVType == DatatypeValidator::ID) {
  662.                     ((IDDatatypeValidator*)itemDTV)->setIDRefList(getScanner()->getIDRefList());
  663.                     thisIsAnId = true;
  664.                 }
  665.                 else if (itemDTVType == DatatypeValidator::IDREF) {
  666.                     // if in prevalidatoin, do not add attDef to IDREFList
  667.                     if (preValidation)
  668.                         ((IDREFDatatypeValidator*)itemDTV)->setIDRefList(0);
  669.                     else
  670.                         ((IDREFDatatypeValidator*)itemDTV)->setIDRefList(getScanner()->getIDRefList());
  671.                 }
  672.             }
  673.             else if (attDefDVType == DatatypeValidator::Union) {
  674.                 RefVectorOf<DatatypeValidator>* memberDTV = ((UnionDatatypeValidator*)attDefDV)->getMemberTypeValidators();
  675.                 unsigned int memberTypeNumber = memberDTV->size();
  676.                 for ( unsigned int memberIndex = 0; memberIndex < memberTypeNumber; ++memberIndex)
  677.                 {
  678.                     DatatypeValidator::ValidatorType memberDTVType = memberDTV->elementAt(memberIndex)->getType();
  679.                     if (memberDTVType == DatatypeValidator::ENTITY)
  680.                         ((ENTITYDatatypeValidator*)memberDTV->elementAt(memberIndex))->setEntityDeclPool(getScanner()->getEntityDeclPool());
  681.                     else if (memberDTVType == DatatypeValidator::ID) {
  682.                         ((IDDatatypeValidator*)memberDTV->elementAt(memberIndex))->setIDRefList(getScanner()->getIDRefList());
  683.                         thisIsAnId = true;
  684.                     }
  685.                     else if (memberDTVType == DatatypeValidator::IDREF) {
  686.                         // if in prevalidatoin, do not add attDef to IDREFList
  687.                         if (preValidation)
  688.                             ((IDREFDatatypeValidator*)memberDTV->elementAt(memberIndex))->setIDRefList(0);
  689.                         else
  690.                             ((IDREFDatatypeValidator*)memberDTV->elementAt(memberIndex))->setIDRefList(getScanner()->getIDRefList());
  691.                     }
  692.                 }
  693.             }
  694.             else if (attDefDVType == DatatypeValidator::ENTITY)
  695.                 ((ENTITYDatatypeValidator*)attDefDV)->setEntityDeclPool(getScanner()->getEntityDeclPool());
  696.             else if (attDefDVType == DatatypeValidator::ID) {
  697.                 ((IDDatatypeValidator*)attDefDV)->setIDRefList(getScanner()->getIDRefList());
  698.                 thisIsAnId = true;
  699.             }
  700.             else if (attDefDVType == DatatypeValidator::IDREF) {
  701.                 // if in prevalidatoin, do not add attDef to IDREFList
  702.                 if (preValidation)
  703.                     ((IDREFDatatypeValidator*)attDefDV)->setIDRefList(0);
  704.                 else
  705.                     ((IDREFDatatypeValidator*)attDefDV)->setIDRefList(getScanner()->getIDRefList());
  706.             }
  708.             // now validate the attribute value
  709.             // if notation, need to bind URI to notation first
  710.             if (attDefDVType == DatatypeValidator::NOTATION)
  711.             {
  712.                 //
  713.                 //  Make sure that this value maps to one of the
  714.                 //  notation values in the enumList parameter. We don't have to
  715.                 //  look it up in the notation pool (if a notation) because we
  716.                 //  will look up the enumerated values themselves. If they are in
  717.                 //  the notation pool (after the Grammar is parsed), then obviously
  718.                 //  this value will be legal since it matches one of them.
  719.                 //
  720.                 XMLBuffer notationBuf(1023, fMemoryManager);
  721.                 int colonPos = -1;
  722.                 unsigned int uriId = getScanner()->resolveQName(attrValue, notationBuf, ElemStack::Mode_Element, colonPos);
  723.                 notationBuf.set(getScanner()->getURIText(uriId));
  724.                 notationBuf.append(chColon);
  725.                 notationBuf.append(&attrValue[colonPos + 1]);
  727.                 attDefDV->validate(notationBuf.getRawBuffer());
  728.             }
  729.             else {
  730.                 if (thisIsAnId) {
  731.                     if (fSeenId) {
  732.                         emitError
  733.                         (
  734.                             XMLValid::MultipleIdAttrs
  735.                             , elemDecl->getFullName()
  736.                         );
  737.                         valid = false;
  738.                     }
  739.                     else
  740.                         fSeenId = true;
  741.                 }
  742.                 attDefDV->validate(attrValue);
  743.             }
  744.         }
  745.         catch (XMLException& idve) {
  746.             valid = false;
  747.             emitError (XMLValid::DatatypeError, idve.getType(), idve.getMessage());       
  748.         }
  749.         catch (...) {
  750.             emitError(XMLValid::GenericError);
  751.             ((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
  752.             ((SchemaAttDef *)attDef)->setValidity(PSVIDefs::INVALID);
  753.             throw;
  754.         }
  755.     }
  757.     if(!valid) {
  758.         ((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
  759.         ((SchemaAttDef *)attDef)->setValidity(PSVIDefs::INVALID);
  760.     }
  761.     else if(attDefDV && attDefDV->getType() == DatatypeValidator::Union) 
  762.         ((SchemaAttDef *)attDef)->setMembertypeValidator(((UnionDatatypeValidator *)attDefDV)->getMemberTypeValidator());
  763.     fTrailing = false;
  766. }
  768. void SchemaValidator::validateElement(const   XMLElementDecl*  elemDef)
  769. {
  770.     ComplexTypeInfo* elemTypeInfo = ((SchemaElementDecl*)elemDef)->getComplexTypeInfo();
  771.     fTypeStack->push(elemTypeInfo);
  773.     bool valid = true;
  775.     if (fXsiType) {
  776.         // handle "xsi:type" right here
  777.         unsigned int uri = fXsiType->getURI();
  778.         const XMLCh* localPart = fXsiType->getLocalPart();
  780.         if (uri != XMLElementDecl::fgInvalidElemId &&
  781.             uri != XMLElementDecl::fgPCDataElemId &&
  782.             uri != XMLContentModel::gEpsilonFakeId &&
  783.             uri != XMLContentModel::gEOCFakeId) {
  785.             // retrieve Grammar for the uri
  786.             const XMLCh* uriStr = getScanner()->getURIText(uri);
  787.             SchemaGrammar* sGrammar = (SchemaGrammar*) fGrammarResolver->getGrammar(uriStr);
  789.             if (!sGrammar) {
  791.                 // Check built-in simple types
  792.                 if (XMLString::equals(uriStr, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) {
  794.                     fXsiTypeValidator = fGrammarResolver->getDatatypeValidator(uriStr, localPart);
  796.                     if (!fXsiTypeValidator) {
  797.                         emitError(XMLValid::BadXsiType, fXsiType->getRawName());
  798.                         valid = false;
  799.                     }
  800.                     else {
  801.                         ((SchemaElementDecl*)elemDef)->setXsiSimpleTypeInfo(fXsiTypeValidator);
  803.                         DatatypeValidator* ancestorValidator = ((SchemaElementDecl*)elemDef)->getDatatypeValidator();
  804.                         if (ancestorValidator && !ancestorValidator->isSubstitutableBy(fXsiTypeValidator)) {
  805.                             // the type is not derived from ancestor
  806.                             emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
  807.                             valid = false;
  808.                         }
  809.                         else {
  810.                             // the type is derived from ancestor
  811.                             if (((SchemaElementDecl*)elemDef)->getBlockSet() == SchemaSymbols::XSD_RESTRICTION) {
  812.                                 emitError(XMLValid::NoSubforBlock, fXsiType->getRawName(), elemDef->getFullName());
  813.                                 valid = false;
  814.                             }
  815.                             if (elemDef->hasAttDefs()) {
  816.                                 // if we have an attribute but xsi:type's type is simple, we have a problem...
  817.                                 emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
  818.                                 valid = false;
  819.                             }
  820.                         }
  821.                     }
  822.                 }
  823.                 else {
  824.                     // Grammar not found
  825.                     emitError(XMLValid::GrammarNotFound, uriStr);
  826.                     valid = false;
  827.                 }
  828.             }
  829.             else if (sGrammar->getGrammarType() != Grammar::SchemaGrammarType) {
  830.                 emitError(XMLValid::GrammarNotFound, uriStr);
  831.                 valid = false;
  832.             }
  833.             else {
  834.                 // retrieve complexType registry and DatatypeValidator registry
  835.                 RefHashTableOf<ComplexTypeInfo>* complexTypeRegistry = sGrammar->getComplexTypeRegistry();
  837.                 if (!complexTypeRegistry) {
  838.                     emitError(XMLValid::BadXsiType, fXsiType->getRawName());
  839.                     valid = false;
  840.                 }
  841.                 else {
  843.                     // retrieve the typeInfo specified in xsi:type
  844.                     XMLBuffer aBuffer(1023, fMemoryManager);
  845.                     aBuffer.set(uriStr);
  846.                     aBuffer.append(chComma);
  847.                     aBuffer.append(localPart);
  848.                     ComplexTypeInfo* typeInfo = complexTypeRegistry->get(aBuffer.getRawBuffer());
  850.                     if (typeInfo) {
  851.                         // typeInfo is found
  852.                         bool error = false;
  854.                         if (typeInfo->getAbstract()) {
  855.                             emitError(XMLValid::NoAbstractInXsiType, aBuffer.getRawBuffer());
  856.                             error = true;
  857.                         }
  859.                         ComplexTypeInfo* destType = ((SchemaElementDecl*)elemDef)->getComplexTypeInfo();
  860.                         ComplexTypeInfo* tempType = typeInfo;
  861.                         if (destType) {
  862.                             while (tempType) {
  863.                                 if (XMLString::equals(tempType->getTypeName(), destType->getTypeName()))
  864.                                     break;
  865.                                 tempType = tempType->getBaseComplexTypeInfo();
  866.                             }
  867.                             if (!tempType) {
  868.                                 emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
  869.                                 error = true;
  870.                             }
  871.                             else {
  872.                                 int derivationMethod = typeInfo->getDerivedBy();
  873.                                 if ((((SchemaElementDecl*)elemDef)->getBlockSet() & derivationMethod) != 0) {
  874.                                     emitError(XMLValid::NoSubforBlock, fXsiType->getRawName(), elemDef->getFullName());
  875.                                     error = true;
  876.                                 }
  877.                             }
  878.                         }
  879.                         else {
  880.                             // if the original type is a simple type, check derivation ok.
  881.                             DatatypeValidator* ancestorValidator = ((SchemaElementDecl*)elemDef)->getDatatypeValidator();
  882.                             if (ancestorValidator && !ancestorValidator->isSubstitutableBy(fXsiTypeValidator)) {
  883.                                 // the type is not derived from ancestor
  884.                                 emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
  885.                                 error = true;
  886.                             }
  887.                         }
  889.                         if (!error) {
  890.                             ((SchemaElementDecl*)elemDef)->setXsiComplexTypeInfo(typeInfo);
  891.                             fTypeStack->pop();
  892.                             fTypeStack->push(typeInfo);
  893.                         }
  894.                         valid = !error;
  895.                     }
  896.                     else {
  897.                         // typeInfo not found
  898.                         fXsiTypeValidator = fGrammarResolver->getDatatypeValidator(uriStr, localPart);
  900.                         if (!fXsiTypeValidator) {
  901.                             emitError(XMLValid::BadXsiType, fXsiType->getRawName());
  902.                             valid = false;
  903.                         }
  904.                         else {
  906.                             ((SchemaElementDecl*)elemDef)->setXsiSimpleTypeInfo(fXsiTypeValidator);
  907.                             DatatypeValidator* ancestorValidator = ((SchemaElementDecl*)elemDef)->getDatatypeValidator();
  908.                             if (ancestorValidator && !ancestorValidator->isSubstitutableBy(fXsiTypeValidator)) {
  909.                                 // the type is not derived from ancestor
  910.                                 emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
  911.                                 valid = false;
  912.                             }
  913.                             else {
  914.                                 // the type is derived from ancestor
  915.                                 if (((SchemaElementDecl*)elemDef)->getBlockSet() == SchemaSymbols::XSD_RESTRICTION) {
  916.                                     emitError(XMLValid::NoSubforBlock, fXsiType->getRawName(), elemDef->getFullName());
  917.                                     valid = false;
  918.                                     
  919.                                 }
  920.                                 if (elemDef->hasAttDefs()) {
  921.                                     // if we have an attribute but xsi:type's type is simple, we have a problem...
  922.                                     emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
  923.                                     valid = false;
  924.                                 }
  925.                             }
  927.                         }
  928.                     }
  929.                 }
  930.             }
  931.         }
  932.         delete fXsiType;
  933.         fXsiType = 0;
  934.     }
  935.     else {
  936.         //
  937.         // xsi:type was not specified...
  938.         // If the corresponding type is abstract, detect an error
  939.         //
  940.         if (elemTypeInfo && elemTypeInfo->getAbstract()) {
  941.             emitError(XMLValid::NoUseAbstractType, elemDef->getFullName());
  942.             valid = false;
  943.         }
  944.     }
  946.     //
  947.     // Check whether this element is abstract.  If so, an error
  948.     //
  949.     int miscFlags = ((SchemaElementDecl*)elemDef)->getMiscFlags();
  950.     if ((miscFlags & SchemaSymbols::XSD_ABSTRACT) != 0) {
  951.         emitError(XMLValid::NoDirectUseAbstractElement, elemDef->getFullName());
  952.         valid = false;
  953.     }
  955.     //
  956.     // Check whether this element allows Nillable
  957.     //
  958.     if (fNil && (miscFlags & SchemaSymbols::XSD_NILLABLE) == 0 ) {
  959.         fNil = false;
  960.         emitError(XMLValid::NillNotAllowed, elemDef->getFullName());
  961.         valid = false;
  962.     }
  964.     fDatatypeBuffer.reset();
  965.     fTrailing = false;
  966.     fSeenId = false;
  968.     if(!valid) {
  969.         ((SchemaElementDecl *)(elemDef))->setValidity(PSVIDefs::INVALID);    
  970.     }
  971. }
  973. void SchemaValidator::preContentValidation(bool reuseGrammar,
  974.                                            bool validateDefAttr)
  975. {
  976.     //  Lets go through all the grammar in the GrammarResolver
  977.     //    and validate those that has not been validated yet
  978.     //
  979.     //  Lets enumerate all of the elements in the element decl pool
  980.     //    and put out an error for any that did not get declared.
  981.     //    We also check all of the attributes as well.
  982.     //
  983.     //  And enumerate all the complextype info in the grammar
  984.     //    and do Unique Particle Attribution Checking
  986.     RefHashTableOfEnumerator<Grammar> grammarEnum = fGrammarResolver->getGrammarEnumerator();
  987.     while (grammarEnum.hasMoreElements())
  988.     {
  989.         SchemaGrammar& sGrammar = (SchemaGrammar&) grammarEnum.nextElement();
  990.         if (sGrammar.getGrammarType() != Grammar::SchemaGrammarType || sGrammar.getValidated())
  991.              continue;
  993.         sGrammar.setValidated(true);
  995.         RefHash3KeysIdPoolEnumerator<SchemaElementDecl> elemEnum = sGrammar.getElemEnumerator();
  997.         while (elemEnum.hasMoreElements())
  998.         {
  999.             SchemaElementDecl& curElem = elemEnum.nextElement();
  1001.             //  First check if declared or not
  1002.             //
  1003.             //  See if this element decl was ever marked as declared. If
  1004.             //  not, then put out an error. In some cases its just
  1005.             //  a warning, such as being referenced in a content model.
  1006.             //
  1007.             const SchemaElementDecl::CreateReasons reason = curElem.getCreateReason();
  1009.             if (reason != XMLElementDecl::Declared)
  1010.             {
  1011.                 if (reason == XMLElementDecl::AttList)
  1012.                 {
  1013.                     getScanner()->emitError
  1014.                     (
  1015.                         XMLErrs::UndeclaredElemInAttList
  1016.                         , curElem.getFullName()
  1017.                     );
  1018.                 }
  1019.                  else if (reason == XMLElementDecl::AsRootElem)
  1020.                 {
  1021.                     emitError
  1022.                     (
  1023.                         XMLValid::UndeclaredElemInDocType
  1024.                         , curElem.getFullName()
  1025.                     );
  1026.                 }
  1027.                  else if (reason == XMLElementDecl::InContentModel)
  1028.                 {
  1029.                     getScanner()->emitError
  1030.                     (
  1031.                         XMLErrs::UndeclaredElemInCM
  1032.                         , curElem.getFullName()
  1033.                     );
  1034.                 }
  1035.                 else
  1036.                 {
  1037.                 }
  1038.             }
  1040.             //
  1041.             //  Then check all of the attributes of the current element.
  1042.             //  We check for:
  1043.             //
  1044.             //  1) Multiple ID attributes
  1045.             //  2) That all of the default values of attributes are
  1046.             //      valid for their type.
  1047.             //  3) That for any notation types, that their lists
  1048.             //      of possible values refer to declared notations.
  1049.             //
  1050.             if (curElem.hasAttDefs()) {
  1051.                 XMLAttDefList& attDefList = curElem.getAttDefList();
  1052.                 bool seenId = false;
  1053.                 while (attDefList.hasMoreElements())
  1054.                 {
  1055.                     const XMLAttDef& curAttDef = attDefList.nextElement();
  1057.                     if (curAttDef.getType() == XMLAttDef::ID)
  1058.                     {
  1059.                         if (seenId)
  1060.                         {
  1061.                             emitError
  1062.                             (
  1063.                                 XMLValid::MultipleIdAttrs
  1064.                                 , curElem.getFullName()
  1065.                             );
  1066.                             break;
  1067.                         }
  1069.                         seenId = true;
  1070.                     }
  1071.                      else if (curAttDef.getType() == XMLAttDef::Notation && curAttDef.getEnumeration())
  1072.                     {
  1073.                         //
  1074.                         //  We need to verify that all of its possible values
  1075.                         //  (in the enum list) refer to valid notations.
  1076.                         //
  1077.                         XMLCh* list = XMLString::replicate(curAttDef.getEnumeration());
  1078.                         ArrayJanitor<XMLCh> janList(list);
  1080.                         //
  1081.                         //  Search forward for a space or a null. If a null,
  1082.                         //  we are done. If a space, cap it and look it up.
  1083.                         //
  1084.                         bool    breakFlag = false;
  1085.                         XMLCh*  listPtr = list;
  1086.                         XMLCh*  lastPtr = listPtr;
  1087.                         while (true)
  1088.                         {
  1089.                             while (*listPtr && (*listPtr != chSpace))
  1090.                                 listPtr++;
  1092.                             //
  1093.                             //  If at the end, indicate we need to break after
  1094.                             //  this one. Else, cap it off here.
  1095.                             //
  1096.                             if (!*listPtr)
  1097.                                 breakFlag = true;
  1098.                             else
  1099.                                 *listPtr = chNull;
  1101.                             if (!sGrammar.getNotationDecl(lastPtr))
  1102.                             {
  1103.                                 emitError
  1104.                                 (
  1105.                                     XMLValid::UnknownNotRefAttr
  1106.                                     , curAttDef.getFullName()
  1107.                                     , lastPtr
  1108.                                 );
  1109.                             }
  1111.                             // Break out if we hit the end last time
  1112.                             if (breakFlag)
  1113.                                 break;
  1115.                             // Else move upwards and try again
  1116.                             listPtr++;
  1117.                             lastPtr = listPtr;
  1118.                         }
  1119.                     }
  1121.                     // If it has a default/fixed value, then validate it
  1122.                     if (validateDefAttr && curAttDef.getValue())
  1123.                     {
  1124.                         validateAttrValue
  1125.                         (
  1126.                             &curAttDef
  1127.                             , curAttDef.getValue()
  1128.                             , true
  1129.                             , &curElem
  1130.                         );
  1131.                     }
  1132.                 }
  1133.             }
  1134.         }
  1136.         //  For each complex type info, check the Unique Particle Attribution
  1137.         if (getScanner()->getValidationSchemaFullChecking()) {
  1138.             RefHashTableOf<ComplexTypeInfo>* complexTypeRegistry = sGrammar.getComplexTypeRegistry();
  1140.             RefHashTableOfEnumerator<ComplexTypeInfo> complexTypeEnum(complexTypeRegistry);
  1141.             while (complexTypeEnum.hasMoreElements())
  1142.             {
  1143.                 ComplexTypeInfo& curTypeInfo = complexTypeEnum.nextElement();
  1144.                 curTypeInfo.checkUniqueParticleAttribution(&sGrammar, fGrammarResolver, getScanner()->getURIStringPool(), this);
  1145.                 checkParticleDerivation(&sGrammar, &curTypeInfo);
  1146.                 checkRefElementConsistency(&sGrammar, &curTypeInfo);
  1147.             }
  1149.             RefHashTableOf<XercesGroupInfo>* groupInfoRegistry = sGrammar.getGroupInfoRegistry();
  1150.             RefHashTableOfEnumerator<XercesGroupInfo> groupEnum(groupInfoRegistry);
  1152.             while (groupEnum.hasMoreElements()) {
  1154.                 XercesGroupInfo& curGroup = groupEnum.nextElement();
  1155.                 XercesGroupInfo* baseGroup = curGroup.getBaseGroup();
  1157.                 if (baseGroup) {
  1158.                     try {
  1159.                         checkParticleDerivationOk(&sGrammar, curGroup.getContentSpec(), curGroup.getScope(),
  1160.                                                   baseGroup->getContentSpec(), baseGroup->getScope());
  1161.                     }
  1162.                     catch (const XMLException& excep) {
  1163.                         fSchemaErrorReporter.emitError(XMLErrs::DisplayErrorMessage, XMLUni::fgXMLErrDomain, curGroup.getLocator(), excep.getMessage());
  1164. }
  1165.                 }
  1167.                 if (curGroup.getCheckElementConsistency())
  1168.                     checkRefElementConsistency(&sGrammar, 0, &curGroup);
  1169.             }
  1170.         }
  1171.     }
  1172. }
  1174. void SchemaValidator::postParseValidation()
  1175. {
  1176.     //
  1177.     //  At this time, there is nothing to do here. The scanner itself handles
  1178.     //  ID/IDREF validation, since that is the same no matter what kind of
  1179.     //  validator.
  1180.     //
  1181. }
  1183. // ---------------------------------------------------------------------------
  1184. //  SchemaValidator: Validator method
  1185. // ---------------------------------------------------------------------------
  1186. // Do Schema Normalization depends on the WhiteSpace Facet
  1187. // preserve : No normalization is done
  1188. // replace  : All occurrences of #x9 (tab), #xA (linefeed) and #xD (carriage return)
  1189. //            are replaced with #x20 (space).
  1190. // collapse : Subsequent to the replacements specified above under replace,
  1191. //            contiguous sequences of #x20s are collapsed to a single #x20,
  1192. //            and initial and/or final #x20s are deleted.
  1193. //
  1194. void SchemaValidator::normalizeWhiteSpace(DatatypeValidator* dV, const XMLCh* const value, XMLBuffer& toFill)
  1195. {
  1196.     toFill.reset();
  1198.     //empty string
  1199.     if (!*value)
  1200.         return;
  1202.     short fWhiteSpace = DatatypeValidator::PRESERVE;
  1203.     if (dV)
  1204.         fWhiteSpace = dV->getWSFacet();
  1206.     enum States
  1207.     {
  1208.         InWhitespace
  1209.         , InContent
  1210.     };
  1212.     States curState = InContent;
  1214.     //
  1215.     //  Loop through the chars of the source value and normalize it according
  1216.     //  to the whitespace facet
  1217.     //
  1218.     bool firstNonWS = false;
  1219.     XMLCh nextCh;
  1220.     const XMLCh* srcPtr = value;
  1222.     if ((fWhiteSpace==DatatypeValidator::COLLAPSE) && fTrailing)
  1223.         toFill.append(chSpace);
  1225.     while (*srcPtr)
  1226.     {
  1227.         nextCh = *srcPtr;
  1229.         if (fWhiteSpace == DatatypeValidator::PRESERVE)
  1230.         {
  1231.             // do nothing
  1232.         }
  1233.         else if (fWhiteSpace == DatatypeValidator::REPLACE)
  1234.         {
  1235.             if (getReaderMgr()->getCurrentReader()->isWhitespace(nextCh))
  1236.                 nextCh = chSpace;
  1237.         }
  1238.         else // COLLAPSE case
  1239.         {
  1240.             if (curState == InWhitespace)
  1241.             {
  1242.                 if (!getReaderMgr()->getCurrentReader()->isWhitespace(nextCh))
  1243.                 {
  1244.                     if (firstNonWS)
  1245.                         toFill.append(chSpace);
  1246.                     curState = InContent;
  1247.                     firstNonWS = true;
  1248.                 }
  1249.                  else
  1250.                 {
  1251.                     srcPtr++;
  1252.                     continue;
  1253.                 }
  1254.             }
  1255.              else if (curState == InContent)
  1256.             {
  1257.                 if (getReaderMgr()->getCurrentReader()->isWhitespace(nextCh))
  1258.                 {
  1259.                     curState = InWhitespace;
  1260.                     srcPtr++;
  1261.                     continue;
  1262.                 }
  1263.                 firstNonWS = true;
  1264.             }
  1265.         }
  1266.         // Add this char to the target buffer
  1267.         toFill.append(nextCh);
  1269.         // And move up to the next character in the source
  1270.         srcPtr++;
  1271.     }
  1272.     srcPtr--;
  1273.     nextCh = *srcPtr;
  1274.     if (getReaderMgr()->getCurrentReader()->isWhitespace(nextCh))
  1275.         fTrailing = true;
  1277. }
  1280. // ---------------------------------------------------------------------------
  1281. //  SchemaValidator: Particle Derivation Checking
  1282. // ---------------------------------------------------------------------------
  1283. void SchemaValidator::checkRefElementConsistency(SchemaGrammar* const currentGrammar,
  1284.                                                  const ComplexTypeInfo* const curTypeInfo,
  1285.                                                  const XercesGroupInfo* const curGroup) {
  1287.     unsigned int elemCount = (curTypeInfo) ? curTypeInfo->elementCount() : curGroup->elementCount();
  1288.     int elemScope = (curTypeInfo) ? curTypeInfo->getScopeDefined() : curGroup->getScope();
  1289.     XSDLocator* typeInfoLocator = (curTypeInfo) ? curTypeInfo->getLocator() : curGroup->getLocator();
  1291.     for (unsigned int i=0; i < elemCount; i++) {
  1293.         const SchemaElementDecl* elemDecl = (curTypeInfo) ? curTypeInfo->elementAt(i) : curGroup->elementAt(i);
  1295.         if (elemDecl->isGlobalDecl()) {
  1297.             unsigned int elemURI = elemDecl->getURI();
  1298.             const XMLCh* elemName = elemDecl->getBaseName();
  1299.             const SchemaElementDecl* other = (SchemaElementDecl*)
  1300.                 currentGrammar->getElemDecl(elemURI, elemName, 0, elemScope);
  1302.             if (other
  1303.                 && (elemDecl->getComplexTypeInfo() != other->getComplexTypeInfo() ||
  1304.                     elemDecl->getDatatypeValidator() != other->getDatatypeValidator())) {
  1305.                 fSchemaErrorReporter.emitError(XMLErrs::DuplicateElementDeclaration,
  1306.                                                XMLUni::fgXMLErrDomain, typeInfoLocator, elemName);
  1307.                 continue;
  1308.             }
  1310.             RefHash2KeysTableOf<ElemVector>* validSubsGroups = currentGrammar->getValidSubstitutionGroups();
  1311.             ValueVectorOf<SchemaElementDecl*>* subsElements = validSubsGroups->get(elemName, elemURI);
  1313.             if (subsElements) {
  1315.                 unsigned subsElemSize = subsElements->size();
  1317.                 for (unsigned int j=0; j < subsElemSize; j++) {
  1319.                     SchemaElementDecl* subsElem = subsElements->elementAt(j);
  1320.                     const XMLCh* subsElemName = subsElem->getBaseName();
  1321.                     other = (SchemaElementDecl*)
  1322.                         currentGrammar->getElemDecl(subsElem->getURI(), subsElemName, 0, elemScope);
  1324.                     if (other
  1325.                         && (subsElem->getComplexTypeInfo() != other->getComplexTypeInfo()
  1326.                             || subsElem->getDatatypeValidator() != other->getDatatypeValidator())) {
  1327.                         fSchemaErrorReporter.emitError(XMLErrs::DuplicateElementDeclaration,
  1328.                                                        XMLUni::fgXMLErrDomain, typeInfoLocator, elemName);
  1329.                     }
  1330.                 }
  1331.             }
  1332.         }
  1333.     }
  1334. }
  1336. // ---------------------------------------------------------------------------
  1337. //  SchemaValidator: Particle Derivation Checking
  1338. // ---------------------------------------------------------------------------
  1339. void SchemaValidator::checkParticleDerivation(SchemaGrammar* const currentGrammar,
  1340.                                               const ComplexTypeInfo* const curTypeInfo) {
  1342.     ComplexTypeInfo* baseTypeInfo = 0;
  1343.     ContentSpecNode* curSpecNode = 0;
  1345.     if (curTypeInfo->getDerivedBy() == SchemaSymbols::XSD_RESTRICTION
  1346.         && ((baseTypeInfo = curTypeInfo->getBaseComplexTypeInfo()) != 0)
  1347.         && ((curSpecNode = curTypeInfo->getContentSpec()) != 0)) {
  1349.         try {
  1350.             checkParticleDerivationOk(currentGrammar, curSpecNode,
  1351.                                       curTypeInfo->getScopeDefined(),
  1352.                                       baseTypeInfo->getContentSpec(),
  1353.                                       baseTypeInfo->getScopeDefined(), baseTypeInfo);
  1354.         }
  1355.         catch (const XMLException& excep) {
  1356.             fSchemaErrorReporter.emitError(XMLErrs::DisplayErrorMessage, XMLUni::fgXMLErrDomain, curTypeInfo->getLocator(), excep.getMessage());
  1357.         }
  1358.     }
  1359. }
  1361. void SchemaValidator::checkParticleDerivationOk(SchemaGrammar* const aGrammar,
  1362.                                                 ContentSpecNode* const curNode,
  1363.                                                 const int derivedScope,
  1364.                                                 ContentSpecNode* const baseNode,
  1365.                                                 const int baseScope,
  1366.                                                 const ComplexTypeInfo* const baseInfo,
  1367.                                                 const bool toCheckOccurence) {
  1369.     // Check for pointless occurrences of all, choice, sequence.  The result is
  1370.     // the contentspec which is not pointless. If the result is a non-pointless
  1371.     // group, Vector is filled  in with the children of interest
  1372.     if (curNode && !baseNode)
  1373.         ThrowXML(RuntimeException, XMLExcepts::PD_EmptyBase);
  1375.     if (!curNode)
  1376.         return;
  1378.     ContentSpecNode* curSpecNode = curNode;
  1379.     ContentSpecNode* baseSpecNode = baseNode;
  1380.     ValueVectorOf<ContentSpecNode*> curVector(8, fMemoryManager);
  1381.     ValueVectorOf<ContentSpecNode*> baseVector(8, fMemoryManager);
  1382.     ContentSpecNode::NodeTypes curNodeType = curSpecNode->getType();
  1383.     ContentSpecNode::NodeTypes baseNodeType = baseSpecNode->getType();
  1385.     if (curNodeType == ContentSpecNode::Sequence ||
  1386.         curNodeType == ContentSpecNode::Choice ||
  1387.         curNodeType == ContentSpecNode::All) {
  1388.         curSpecNode = checkForPointlessOccurrences(curSpecNode, curNodeType, &curVector);
  1389.     }
  1391.     if (baseNodeType == ContentSpecNode::Sequence ||
  1392.         baseNodeType == ContentSpecNode::Choice ||
  1393.         baseNodeType == ContentSpecNode::All) {
  1394.         baseSpecNode = checkForPointlessOccurrences(baseSpecNode, baseNodeType, &baseVector);
  1395.     }
  1397.     curNodeType = curSpecNode->getType();
  1398.     baseNodeType = baseSpecNode->getType();
  1400.     switch (curNodeType & 0x0f) {
  1401.     case ContentSpecNode::Leaf:
  1402.         {
  1403.             switch (baseNodeType & 0x0f) {
  1404.             case ContentSpecNode::Leaf:
  1405.                 {
  1406.                     checkNameAndTypeOK(aGrammar, curSpecNode, derivedScope, baseSpecNode, baseScope, baseInfo);
  1407.                     return;
  1408.                 }
  1409.             case ContentSpecNode::Any:
  1410.             case ContentSpecNode::Any_Other:
  1411.             case ContentSpecNode::Any_NS:
  1412.                 {
  1413.                     checkNSCompat(curSpecNode, baseSpecNode, toCheckOccurence);
  1414.                     return;
  1415.                 }
  1416.             case ContentSpecNode::Choice:
  1417.             case ContentSpecNode::Sequence:
  1418.             case ContentSpecNode::All:
  1419.                 {
  1420.                     checkRecurseAsIfGroup(aGrammar, curSpecNode, derivedScope,
  1421.                                           baseSpecNode, baseScope, &baseVector, baseInfo);
  1422.                     return;
  1423.                 }
  1424.             default:
  1425.                 {
  1426.                     ThrowXML(RuntimeException, XMLExcepts::PD_InvalidContentType);
  1427.                 }
  1428.             }
  1429.         }
  1430.     case ContentSpecNode::Any:
  1431.     case ContentSpecNode::Any_Other:
  1432.     case ContentSpecNode::Any_NS:
  1433.         {
  1434.             switch (baseNodeType & 0x0f) {
  1435.             case ContentSpecNode::Any:
  1436.             case ContentSpecNode::Any_Other:
  1437.             case ContentSpecNode::Any_NS:
  1438.                 {
  1439.                      checkNSSubset(curSpecNode, baseSpecNode);
  1440.                      return;
  1441.                 }
  1442.             case ContentSpecNode::Choice:
  1443.             case ContentSpecNode::Sequence:
  1444.             case ContentSpecNode::All:
  1445.             case ContentSpecNode::Leaf:
  1446.                 {
  1447.                     ThrowXML(RuntimeException, XMLExcepts::PD_ForbiddenRes1);
  1448.                 }
  1449.             default:
  1450.                 {
  1451.                     ThrowXML(RuntimeException, XMLExcepts::PD_InvalidContentType);
  1452.                 }
  1453.             }
  1454.         }
  1455.     case ContentSpecNode::All:
  1456.         {
  1457.             switch (baseNodeType & 0x0f) {
  1458.             case ContentSpecNode::Any:
  1459.             case ContentSpecNode::Any_Other:
  1460.             case ContentSpecNode::Any_NS:
  1461.                 {
  1462.                     checkNSRecurseCheckCardinality(aGrammar, curSpecNode, &curVector, derivedScope, baseSpecNode, toCheckOccurence);
  1463.                     return;
  1464.                 }
  1465.             case ContentSpecNode::All:
  1466.                 {
  1467.                     checkRecurse(aGrammar, curSpecNode, derivedScope, &curVector,
  1468.                                  baseSpecNode, baseScope, &baseVector, baseInfo);
  1469.                     return;
  1470.                 }
  1471.             case ContentSpecNode::Choice:
  1472.             case ContentSpecNode::Sequence:
  1473.             case ContentSpecNode::Leaf:
  1474.                 {
  1475.                     ThrowXML(RuntimeException, XMLExcepts::PD_ForbiddenRes2);
  1476.                 }
  1477.             default:
  1478.                 {
  1479.                     ThrowXML(RuntimeException, XMLExcepts::PD_InvalidContentType);
  1480.                 }
  1481.             }
  1482.         }
  1483.     case ContentSpecNode::Choice:
  1484.         {
  1485.             switch (baseNodeType & 0x0f) {
  1486.             case ContentSpecNode::Any:
  1487.             case ContentSpecNode::Any_Other:
  1488.             case ContentSpecNode::Any_NS:
  1489.                 {
  1490.                     checkNSRecurseCheckCardinality(aGrammar, curSpecNode, &curVector, derivedScope, baseSpecNode, toCheckOccurence);
  1491.                     return;
  1492.                 }
  1493.             case ContentSpecNode::Choice:
  1494.                 {
  1495.                     checkRecurse(aGrammar, curSpecNode, derivedScope, &curVector,
  1496.                                  baseSpecNode, baseScope, &baseVector, baseInfo, true);
  1497.                     return;
  1498.                 }
  1499.             case ContentSpecNode::All:
  1500.             case ContentSpecNode::Sequence:
  1501.             case ContentSpecNode::Leaf:
  1502.                 {
  1503.                     ThrowXML(RuntimeException, XMLExcepts::PD_ForbiddenRes3);
  1504.                 }
  1505.             default:
  1506.                 {
  1507.                     ThrowXML(RuntimeException, XMLExcepts::PD_InvalidContentType);
  1508.                 }
  1509.             }
  1510.         }
  1511.     case ContentSpecNode::Sequence:
  1512.         {
  1513.             switch (baseNodeType & 0x0f) {
  1514.             case ContentSpecNode::Any:
  1515.             case ContentSpecNode::Any_Other:
  1516.             case ContentSpecNode::Any_NS:
  1517.                 {
  1518.                     checkNSRecurseCheckCardinality(aGrammar, curSpecNode, &curVector, derivedScope, baseSpecNode, toCheckOccurence);
  1519.                     return;
  1520.                 }
  1521.             case ContentSpecNode::All:
  1522.                 {
  1523.                     checkRecurseUnordered(aGrammar, curSpecNode, &curVector, derivedScope,
  1524.                                           baseSpecNode, &baseVector, baseScope, baseInfo);
  1525.                     return;
  1526.                 }
  1527.             case ContentSpecNode::Sequence:
  1528.                 {
  1529.                     checkRecurse(aGrammar, curSpecNode, derivedScope, &curVector,
  1530.                                  baseSpecNode, baseScope, &baseVector, baseInfo);
  1531.                     return;
  1532.                 }
  1533.             case ContentSpecNode::Choice:
  1534.                 {
  1535.                     checkMapAndSum(aGrammar, curSpecNode, &curVector, derivedScope,
  1536.                                    baseSpecNode, &baseVector, baseScope, baseInfo);
  1537.                     return;
  1538.                 }
  1539.             case ContentSpecNode::Leaf:
  1540.                 {
  1541.                     ThrowXML(RuntimeException, XMLExcepts::PD_ForbiddenRes4);
  1542.                 }
  1543.             default:
  1544.                 {
  1545.                     ThrowXML(RuntimeException, XMLExcepts::PD_InvalidContentType);
  1546.                 }
  1547.             }
  1548.         }
  1549.     }
  1550. }
  1552. ContentSpecNode*
  1553. SchemaValidator::checkForPointlessOccurrences(ContentSpecNode* const specNode,
  1554.                                               const ContentSpecNode::NodeTypes nodeType,
  1555.                                               ValueVectorOf<ContentSpecNode*>* const nodes) {
  1557.     ContentSpecNode* rightNode = specNode->getSecond();
  1558.     int min = specNode->getMinOccurs();
  1559.     int max = specNode->getMaxOccurs();
  1561.     if (!rightNode) {
  1563.          gatherChildren(nodeType, specNode->getFirst(), nodes);
  1565.          if (nodes->size() == 1 && min == 1 && max == 1) {
  1566.             return nodes->elementAt(0);
  1567.         }
  1569.         return specNode;
  1570.     }
  1572.     gatherChildren(nodeType, specNode->getFirst(), nodes);
  1573.     gatherChildren(nodeType, rightNode, nodes);
  1575.     return specNode;
  1576. }
  1578. void SchemaValidator::gatherChildren(const ContentSpecNode::NodeTypes parentNodeType,
  1579.                                     ContentSpecNode* const specNode,
  1580.                                     ValueVectorOf<ContentSpecNode*>* const nodes) {
  1582.     if (!specNode) {
  1583.         return;
  1584.     }
  1586.     int min = specNode->getMinOccurs();
  1587.     int max = specNode->getMaxOccurs();
  1588.     ContentSpecNode::NodeTypes nodeType = specNode->getType();
  1589.     ContentSpecNode* rightNode = specNode->getSecond();
  1591.     if (nodeType == ContentSpecNode::Leaf ||
  1592.         (nodeType & 0x0f) == ContentSpecNode::Any ||
  1593.         (nodeType & 0x0f) == ContentSpecNode::Any_NS ||
  1594.         (nodeType & 0x0f) == ContentSpecNode::Any_Other) {
  1595.         nodes->addElement(specNode);
  1596.     }
  1597.     else if (min !=1 || max != 1) {
  1598.         nodes->addElement(specNode);
  1599.     }
  1600.     else if (!rightNode) {
  1601.         gatherChildren(nodeType, specNode->getFirst(), nodes);
  1602.     }
  1603.     else if (parentNodeType == nodeType) {
  1605.         gatherChildren(nodeType, specNode->getFirst(), nodes);
  1606.         gatherChildren(nodeType, rightNode, nodes);
  1607.     }
  1608.     else {
  1609.         nodes->addElement(specNode);
  1610.     }
  1611. }
  1613. void
  1614. SchemaValidator::checkNSCompat(const ContentSpecNode* const derivedSpecNode,
  1615.                                const ContentSpecNode* const baseSpecNode,
  1616.                                const bool toCheckOccurence) {
  1618.     // check Occurrence ranges
  1619.     if (toCheckOccurence &&
  1620.         !isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
  1621.                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
  1622.         ThrowXML1(RuntimeException, XMLExcepts::PD_OccurRangeE,
  1623.                   derivedSpecNode->getElement()->getLocalPart());
  1624.     }
  1626.     // check wildcard subset
  1627.     if (!wildcardEltAllowsNamespace(baseSpecNode, derivedSpecNode->getElement()->getURI())) {
  1628.         ThrowXML1(RuntimeException, XMLExcepts::PD_NSCompat1,
  1629.                   derivedSpecNode->getElement()->getLocalPart());
  1630.     }
  1631. }
  1633. bool
  1634. SchemaValidator::wildcardEltAllowsNamespace(const ContentSpecNode* const baseSpecNode,
  1635.                                             const unsigned int derivedURI) {
  1637.     ContentSpecNode::NodeTypes nodeType = baseSpecNode->getType();
  1639.     if ((nodeType & 0x0f) == ContentSpecNode::Any) {
  1640.         return true;
  1641.     }
  1643.     unsigned int baseURI = baseSpecNode->getElement()->getURI();
  1645.     if ((nodeType & 0x0f) == ContentSpecNode::Any_NS) {
  1646.         if (derivedURI == baseURI) {
  1647.            return true;
  1648.         }
  1649.     }
  1650.     else { // must be ANY_OTHER
  1651.         if (derivedURI != baseURI && derivedURI != getScanner()->getEmptyNamespaceId()) {
  1652.             return true;
  1653.         }
  1654.     }
  1656.     return false;
  1657. }
  1659. void
  1660. SchemaValidator::checkNameAndTypeOK(SchemaGrammar* const currentGrammar,
  1661.                                     const ContentSpecNode* const derivedSpecNode,
  1662.                                     const int derivedScope,
  1663.                                     const ContentSpecNode* const baseSpecNode,
  1664.                                     const int baseScope,
  1665.                                     const ComplexTypeInfo* const baseInfo) {
  1667.     unsigned int derivedURI = derivedSpecNode->getElement()->getURI();
  1668.     unsigned int baseURI = baseSpecNode->getElement()->getURI();
  1669.     const XMLCh* derivedName = derivedSpecNode->getElement()->getLocalPart();
  1670.     const XMLCh* baseName = baseSpecNode->getElement()->getLocalPart();
  1672.     if (!XMLString::equals(derivedName, baseName) || derivedURI != baseURI) {
  1673.         ThrowXML(RuntimeException, XMLExcepts::PD_NameTypeOK1);
  1674.     }
  1676. // case of mixed complex types with attributes only
  1677.     if (derivedURI == XMLElementDecl::fgPCDataElemId) {
  1678.         return;
  1679.     }
  1681.     if (!isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
  1682.                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
  1683.         ThrowXML1(RuntimeException, XMLExcepts::PD_OccurRangeE, derivedName);
  1684.     }
  1686.     SchemaGrammar* aGrammar = currentGrammar;
  1687.     const XMLCh* schemaURI = getScanner()->getURIStringPool()->getValueForId(derivedURI);
  1689.     if (derivedURI != getScanner()->getEmptyNamespaceId()) {
  1690.         aGrammar= (SchemaGrammar*) fGrammarResolver->getGrammar(schemaURI);
  1691.     }
  1693.     if (!aGrammar) { //something is wrong
  1694.         return;
  1695.     }
  1697.     SchemaElementDecl* derivedElemDecl = findElement(derivedScope, derivedURI, derivedName, aGrammar);
  1699.     if (!derivedElemDecl) {
  1700.         return;
  1701.     }
  1703.     SchemaElementDecl* baseElemDecl =
  1704.         findElement(baseScope, baseURI, baseName, aGrammar, baseInfo);
  1706.     if (!baseElemDecl) {
  1707.         return;
  1708.     }
  1710.     int derivedFlags = derivedElemDecl->getMiscFlags();
  1711.     int baseFlags = baseElemDecl->getMiscFlags();
  1713.     if (((baseFlags & SchemaSymbols::XSD_NILLABLE) == 0) &&
  1714. ((derivedFlags & SchemaSymbols::XSD_NILLABLE) != 0)) {
  1715.         ThrowXML1(RuntimeException, XMLExcepts::PD_NameTypeOK2, derivedName);
  1716.     }
  1718.     const XMLCh* derivedDefVal = derivedElemDecl->getDefaultValue();
  1719.     const XMLCh* baseDefVal = baseElemDecl->getDefaultValue();
  1721.     if (baseDefVal && (baseFlags & SchemaSymbols::XSD_FIXED) != 0 &&
  1722.         ((derivedFlags & SchemaSymbols::XSD_FIXED) == 0 ||
  1723.          !XMLString::equals(derivedDefVal, baseDefVal))) {
  1724.         ThrowXML1(RuntimeException, XMLExcepts::PD_NameTypeOK3, derivedName);
  1725.     }
  1727.     int derivedBlockSet = derivedElemDecl->getBlockSet();
  1728.     int baseBlockSet = baseElemDecl->getBlockSet();
  1730.     if ((derivedBlockSet & baseBlockSet) != baseBlockSet) {
  1731.         ThrowXML1(RuntimeException, XMLExcepts::PD_NameTypeOK4, derivedName);
  1732.     }
  1734.     // check identity constraints
  1735.     checkICRestriction(derivedElemDecl, baseElemDecl, derivedName, baseName);
  1737.     // check that the derived element's type is derived from the base's.
  1738.     checkTypesOK(derivedElemDecl, baseElemDecl, derivedName);
  1739. }
  1741. SchemaElementDecl*
  1742. SchemaValidator::findElement(const int scope, const unsigned int uriIndex,
  1743.                              const XMLCh* const name,
  1744.                              SchemaGrammar* const grammar,
  1745.                              const ComplexTypeInfo* const typeInfo) {
  1747.     // check for element at given scope first
  1748.     SchemaElementDecl* elemDecl = (SchemaElementDecl*) grammar->getElemDecl(uriIndex, name, 0, scope);
  1750.     // if not found, check at global scope
  1751.     if (!elemDecl) {
  1753.         elemDecl = (SchemaElementDecl*)
  1754.             grammar->getElemDecl(uriIndex, name, 0, Grammar::TOP_LEVEL_SCOPE);
  1756.         // if still not found, and base is specified, look it up there
  1757.         if (!elemDecl && typeInfo) {
  1759.             const ComplexTypeInfo* baseInfo = typeInfo;
  1761.             while (baseInfo) {
  1763.                 elemDecl = (SchemaElementDecl*)
  1764.                     grammar->getElemDecl(uriIndex, name, 0, baseInfo->getScopeDefined());
  1766.                 if (elemDecl) {
  1767.                    break;
  1768.                 }
  1770.                 baseInfo = baseInfo->getBaseComplexTypeInfo();
  1771.             }
  1772.         }
  1773.     }
  1775.     return elemDecl;
  1776. }
  1778. void
  1779. SchemaValidator::checkICRestriction(const SchemaElementDecl* const derivedElemDecl,
  1780.                                    const SchemaElementDecl* const baseElemDecl,
  1781.                                    const XMLCh* const derivedElemName,
  1782.                                    const XMLCh* const baseElemName) {
  1784.     // REVIST - need to get more clarification
  1785.     unsigned int derivedICCount = derivedElemDecl->getIdentityConstraintCount();
  1786.     unsigned int baseICCount = baseElemDecl->getIdentityConstraintCount();
  1788.     if (derivedICCount > baseICCount) {
  1789.         ThrowXML2(RuntimeException, XMLExcepts::PD_NameTypeOK6, derivedElemName, baseElemName);
  1790.     }
  1792.     for (unsigned int i=0; i < derivedICCount; i++) {
  1794.         bool found = false;
  1795.         IdentityConstraint* ic= derivedElemDecl->getIdentityConstraintAt(i);
  1797.         for (unsigned int j=0; j < baseICCount; j++) {
  1798.             if (*ic == *(baseElemDecl->getIdentityConstraintAt(j))) {
  1800.                 found = true;
  1801.                 break;
  1802.             }
  1803.         }
  1805.         if (!found) {
  1806.             ThrowXML2(RuntimeException, XMLExcepts::PD_NameTypeOK7, derivedElemName, baseElemName);
  1807.         }
  1808.     }
  1809. }
  1811. void
  1812. SchemaValidator::checkTypesOK(const SchemaElementDecl* const derivedElemDecl,
  1813.                               const SchemaElementDecl* const baseElemDecl,
  1814.                               const XMLCh* const derivedElemName) {
  1816.     SchemaElementDecl::ModelTypes baseType = baseElemDecl->getModelType();
  1818.     if (baseType == SchemaElementDecl::Any) {
  1819.         return;
  1820.     }
  1822.     ComplexTypeInfo* rInfo = derivedElemDecl->getComplexTypeInfo();
  1823.     ComplexTypeInfo* bInfo = baseElemDecl->getComplexTypeInfo();
  1825.     if (derivedElemDecl->getModelType() == SchemaElementDecl::Simple) {
  1827.         if (baseType != SchemaElementDecl::Simple) {
  1828.             ThrowXML1(RuntimeException, XMLExcepts::PD_NameTypeOK5, derivedElemName);
  1829.         }
  1831.         if (!rInfo) {
  1833.             DatatypeValidator* bDV = baseElemDecl->getDatatypeValidator();
  1835.             if (bInfo || bDV == 0 ||
  1836. !bDV->isSubstitutableBy(derivedElemDecl->getDatatypeValidator())) {
  1837.                 ThrowXML1(RuntimeException, XMLExcepts::PD_NameTypeOK5, derivedElemName);
  1838.             }
  1840.             return;
  1841.         }
  1842.     }
  1844.     if (rInfo == bInfo)
  1845.         return;
  1847.     for (; rInfo && rInfo != bInfo; rInfo = rInfo->getBaseComplexTypeInfo()) {
  1848.         if (rInfo->getDerivedBy() != SchemaSymbols::XSD_RESTRICTION) {
  1850.             rInfo = 0;
  1851.             break;
  1852.         }
  1853.     }
  1855.     if (!rInfo) {
  1856.         ThrowXML1(RuntimeException, XMLExcepts::PD_NameTypeOK5, derivedElemName);
  1857.     }
  1858. }
  1860. void
  1861. SchemaValidator::checkRecurseAsIfGroup(SchemaGrammar* const currentGrammar,
  1862.                                        ContentSpecNode* const derivedSpecNode,
  1863.                                        const int derivedScope,
  1864.                                        const ContentSpecNode* const baseSpecNode,
  1865.                                        const int baseScope,
  1866.                                        ValueVectorOf<ContentSpecNode*>* const baseNodes,
  1867.                                        const ComplexTypeInfo* const baseInfo) {
  1869.     ContentSpecNode::NodeTypes baseType = baseSpecNode->getType();
  1870.     ValueVectorOf<ContentSpecNode*> derivedNodes(1, fMemoryManager);
  1871.     bool toLax = false;
  1873.     //Treat the element as if it were in a group of the same variety as base
  1874.     ContentSpecNode derivedGroupNode(baseType, derivedSpecNode, 0, false, true, fMemoryManager);
  1876.     derivedNodes.addElement(derivedSpecNode);
  1878.     if (baseSpecNode->getType() == ContentSpecNode::Choice) {
  1879.         toLax = true;
  1880.     }
  1882.     checkRecurse(currentGrammar, &derivedGroupNode, derivedScope, &derivedNodes,
  1883.                  baseSpecNode, baseScope, baseNodes, baseInfo, toLax);
  1884. }
  1886. void
  1887. SchemaValidator::checkRecurse(SchemaGrammar* const currentGrammar,
  1888.                               const ContentSpecNode* const derivedSpecNode,
  1889.                               const int derivedScope,
  1890.                               ValueVectorOf<ContentSpecNode*>* const derivedNodes,
  1891.                               const ContentSpecNode* const baseSpecNode,
  1892.                               const int baseScope,
  1893.                               ValueVectorOf<ContentSpecNode*>* const baseNodes,
  1894.                               const ComplexTypeInfo* const baseInfo,
  1895.                               const bool toLax) {
  1897.     if (!isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
  1898.                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
  1899.         ThrowXML(RuntimeException, XMLExcepts::PD_Recurse1);
  1900.     }
  1902.     // check for mapping of children
  1903.     XMLExcepts::Codes codeToThrow = XMLExcepts::NoError;
  1904.     unsigned int count1= derivedNodes->size();
  1905.     unsigned int count2= baseNodes->size();
  1906.     unsigned int current = 0;
  1908.     for (unsigned int i=0; i<count1; i++) {
  1910.         bool matched = false;
  1912.         for (unsigned int j = current; j < count2; j++) {
  1914.             ContentSpecNode* baseNode = baseNodes->elementAt(j);
  1915.             current++;
  1917.             try {
  1919.                 checkParticleDerivationOk(currentGrammar, derivedNodes->elementAt(i),
  1920.                                           derivedScope, baseNode, baseScope, baseInfo);
  1921.                 matched = true;
  1922.                 break;
  1923.             }
  1924.             catch(const XMLException&) {
  1925.                 if (!toLax && baseNode->getMinTotalRange()) {
  1926.                     break;
  1927.                 }
  1928.             }
  1929.         }
  1931.         // did not find a match
  1932.         if (!matched) {
  1934.             codeToThrow = XMLExcepts::PD_Recurse2;
  1935.             break;
  1936.         }
  1937.     }
  1939.     // Now, see if there are some elements in the base we didn't match up
  1940.     // in case of Sequence or All
  1941.     if (!toLax && codeToThrow == XMLExcepts::NoError) {
  1942.         for (unsigned int j = current; j < count2; j++) {
  1943.             if (baseNodes->elementAt(j)->getMinTotalRange()) { //!emptiable
  1945.                 codeToThrow =  XMLExcepts::PD_Recurse2;
  1946.                 break;
  1947.             }
  1948.         }
  1949.     }
  1951.     if (codeToThrow != XMLExcepts::NoError) {
  1952.         ThrowXML(RuntimeException, codeToThrow);
  1953.     }
  1954. }
  1956. void SchemaValidator::checkNSSubset(const ContentSpecNode* const derivedSpecNode,
  1957.                                     const ContentSpecNode* const baseSpecNode) {
  1959.     // check Occurrence ranges
  1960.     if (!isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
  1961.                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
  1962.         ThrowXML(RuntimeException, XMLExcepts::PD_NSSubset1);
  1963.     }
  1965.     if (!isWildCardEltSubset(derivedSpecNode, baseSpecNode)) {
  1966.         ThrowXML(RuntimeException, XMLExcepts::PD_NSSubset2);
  1967.     }
  1968. }
  1970. bool
  1971. SchemaValidator::isWildCardEltSubset(const ContentSpecNode* const derivedSpecNode,
  1972.                                      const ContentSpecNode* const baseSpecNode) {
  1974.     ContentSpecNode::NodeTypes baseType = baseSpecNode->getType();
  1976.     if ((baseType & 0x0f) == ContentSpecNode::Any) {
  1977.         return true;
  1978.     }
  1980.     ContentSpecNode::NodeTypes derivedType = derivedSpecNode->getType();
  1981.     unsigned int baseURI = baseSpecNode->getElement()->getURI();
  1982.     unsigned int derivedURI = derivedSpecNode->getElement()->getURI();
  1984.     if (((derivedType & 0x0f) == ContentSpecNode::Any_Other) &&
  1985.         ((baseType & 0x0f) == ContentSpecNode::Any_Other) &&
  1986.         baseURI == derivedURI) {
  1987.         return true;
  1988.     }
  1990.     if ((derivedType & 0x0f) == ContentSpecNode::Any_NS) {
  1992.         if (((baseType & 0x0f) == ContentSpecNode::Any_NS) &&
  1993.             baseURI == derivedURI) {
  1994.             return true;
  1995.         }
  1997.         if (((baseType & 0x0f) == ContentSpecNode::Any_Other) &&
  1998.             baseURI != derivedURI) {
  1999.             return true;
  2000.         }
  2001.     }
  2003.     return false;
  2004. }
  2006. void
  2007. SchemaValidator::checkNSRecurseCheckCardinality(SchemaGrammar* const currentGrammar,
  2008.                                                 const ContentSpecNode* const derivedSpecNode,
  2009.                                                 ValueVectorOf<ContentSpecNode*>* const derivedNodes,
  2010.                                                 const int derivedScope,
  2011.                                                 ContentSpecNode* const baseSpecNode,
  2012.                                                 const bool toCheckOccurence) {
  2014.     // Implement total range check
  2015.     int derivedMin = derivedSpecNode->getMinTotalRange();
  2016.     int derivedMax = derivedSpecNode->getMaxTotalRange();
  2018.     // check Occurrence ranges
  2019.     if (toCheckOccurence &&
  2020.         !isOccurrenceRangeOK(derivedMin, derivedMax, baseSpecNode->getMinOccurs(),
  2021.                               baseSpecNode->getMaxOccurs())) {
  2022.         ThrowXML(RuntimeException, XMLExcepts::PD_NSRecurseCheckCardinality1);
  2023.     }
  2025.     // Check that each member of the group is a valid restriction of the wildcard
  2026.     unsigned int nodesCount = derivedNodes->size();
  2028.     for (unsigned int i = 0; i < nodesCount; i++) {
  2029.         checkParticleDerivationOk(currentGrammar, derivedNodes->elementAt(i), derivedScope, baseSpecNode, -1, 0, false);
  2030.     }
  2031. }
  2033. void
  2034. SchemaValidator::checkRecurseUnordered(SchemaGrammar* const currentGrammar,
  2035.                                        const ContentSpecNode* const derivedSpecNode,
  2036.                                        ValueVectorOf<ContentSpecNode*>* const derivedNodes,
  2037.                                        const int derivedScope,
  2038.                                        ContentSpecNode* const baseSpecNode,
  2039.                                        ValueVectorOf<ContentSpecNode*>* const baseNodes,
  2040.                                        const int baseScope,
  2041.                                        const ComplexTypeInfo* const baseInfo) {
  2043.     // check Occurrence ranges
  2044.     if (!isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
  2045.                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
  2046.         ThrowXML(RuntimeException, XMLExcepts::PD_Recurse1);
  2047.     }
  2049.     XMLExcepts::Codes  codeToThrow = XMLExcepts::NoError;
  2050.     unsigned int       derivedCount= derivedNodes->size();
  2051.     unsigned int       baseCount = baseNodes->size();
  2052.     bool*              foundIt = (bool*) fMemoryManager->allocate
  2053.     (
  2054.         baseCount * sizeof(bool)
  2055.     );//new bool[baseCount];
  2056.     ArrayJanitor<bool> janFoundIt(foundIt, fMemoryManager);
  2058.     for (unsigned k=0; k < baseCount; k++) {
  2059.         foundIt[k] = false;
  2060.     }
  2062.     // check for mapping of children
  2063.     for (unsigned int i = 0; i < derivedCount; i++) {
  2065.         ContentSpecNode* derivedNode = derivedNodes->elementAt(i);
  2066.         bool matched = false;
  2068.         for (unsigned int j = 0; j < baseCount; j++) {
  2070.             try {
  2072.                 checkParticleDerivationOk(currentGrammar, derivedNode, derivedScope,
  2073.                                           baseNodes->elementAt(j), baseScope, baseInfo);
  2075.                 if (foundIt[j]) {
  2076.                     break;
  2077.                 }
  2079.                 foundIt[j] = true;
  2080.                 matched = true;
  2081.                 break;
  2082.             }
  2083.             catch (const XMLException&) {
  2084.             }
  2085.         }
  2087.         // didn't find a match.
  2088.         if (!matched) {
  2090.         codeToThrow = XMLExcepts::PD_RecurseUnordered;
  2091.             break;
  2092.         }
  2093.     }
  2095.     // For all unmapped particles in base, check to see it it's emptiable or not
  2096.     if (codeToThrow == XMLExcepts::NoError) {
  2097.         for (unsigned int j=0; j < baseCount; j++) {
  2098.             if (!foundIt[j] && baseNodes->elementAt(j)->getMinTotalRange()) {
  2100.             codeToThrow = XMLExcepts::PD_RecurseUnordered;
  2101.                 break;
  2102.             }
  2103.         }
  2104.     }
  2106.     if (codeToThrow != XMLExcepts::NoError) {
  2107.         ThrowXML(RuntimeException, codeToThrow);
  2108.     }
  2109. }
  2111. void
  2112. SchemaValidator::checkMapAndSum(SchemaGrammar* const currentGrammar,
  2113.                                 const ContentSpecNode* const derivedSpecNode,
  2114.                                 ValueVectorOf<ContentSpecNode*>* const derivedNodes,
  2115.                                 const int derivedScope,
  2116.                                 ContentSpecNode* const baseSpecNode,
  2117.                                 ValueVectorOf<ContentSpecNode*>* const baseNodes,
  2118.                                 const int baseScope,
  2119.                                 const ComplexTypeInfo* const baseInfo) {
  2121.     // check Occurrence ranges
  2122.     int derivedCount = derivedNodes->size();
  2123.     int baseCount = baseNodes->size();
  2124.     int derivedMin = derivedSpecNode->getMinOccurs() * derivedCount;
  2125.     int derivedMax = derivedSpecNode->getMaxOccurs();
  2127.     if (derivedMax != SchemaSymbols::XSD_UNBOUNDED) {
  2128.         derivedMax *= derivedCount;
  2129.     }
  2131.     if (!isOccurrenceRangeOK(derivedMin, derivedMax, baseSpecNode->getMinOccurs(),
  2132.                              baseSpecNode->getMaxOccurs())) {
  2133.         ThrowXML(RuntimeException, XMLExcepts::PD_Recurse1);
  2134.     }
  2136.     // check for mapping of children
  2137.     for (int i = 0; i < derivedCount; i++) {
  2139.         ContentSpecNode* derivedNode = derivedNodes->elementAt(i);
  2140.         bool matched = false;
  2142.         for (int j = 0; j < baseCount && !matched; j++) {
  2144.             try {
  2146.                 checkParticleDerivationOk(currentGrammar, derivedNode, derivedScope,
  2147.                                           baseNodes->elementAt(j), baseScope, baseInfo);
  2148.                 matched = true;
  2149.             }
  2150.             catch (const XMLException&) {
  2151.             }
  2152.         }
  2154.         // didn't find a match.
  2155.         if (!matched) {
  2156.         ThrowXML(RuntimeException, XMLExcepts::PD_MapAndSum);
  2157.         }
  2158.     }
  2160. }
  2162. XERCES_CPP_NAMESPACE_END