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

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

词法分析

开发平台：

Visual C++

SchemaValidator.hpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001-2003 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.hpp,v $
  59.  * Revision 1.17  2003/05/18 14:02:08  knoaman
  60.  * Memory manager implementation: pass per instance manager.
  61.  *
  62.  * Revision 1.16  2003/05/16 21:43:21  knoaman
  63.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  64.  *
  65.  * Revision 1.15  2003/05/16 03:15:51  knoaman
  66.  * Partial implementation of the configurable memory manager.
  67.  *
  68.  * Revision 1.14  2003/05/15 18:57:27  knoaman
  69.  * Partial implementation of the configurable memory manager.
  70.  *
  71.  * Revision 1.13  2003/01/20 19:04:48  knoaman
  72.  * Fix for particle derivation checking.
  73.  *
  74.  * Revision 1.12  2003/01/13 20:16:51  knoaman
  75.  * [Bug 16024] SchemaSymbols.hpp conflicts C++ Builder 6 dir.h
  76.  *
  77.  * Revision 1.11  2003/01/09 22:34:54  tng
  78.  * [Bug 14955] error validating parser.
  79.  *
  80.  * Revision 1.10  2002/11/07 21:57:37  tng
  81.  * Fix the following Schema Test Failures:
  82.  * 1. Typo when comparing miscFlags with FIXED
  83.  * 2. If xsi:type is specified, need to validate using that xsitype validator even if the type was any
  84.  * 3. Need to check ID/IDREFs for element value
  85.  * 4. Need to duplicate attribute id for wildcard scenario.
  86.  *
  87.  * Revision 1.9  2002/11/04 14:49:42  tng
  88.  * C++ Namespace Support.
  89.  *
  90.  * Revision 1.8  2002/09/04 18:17:41  tng
  91.  * Do not set IDREF to used during prevalidation.
  92.  *
  93.  * Revision 1.7  2002/07/11 18:55:45  knoaman
  94.  * Add a flag to the preContentValidation method to indicate whether to validate
  95.  * default/fixed attributes or not.
  96.  *
  97.  * Revision 1.6  2002/06/17 18:09:29  tng
  98.  * DOM L3: support "datatype-normalization"
  99.  *
  100.  * Revision 1.5  2002/05/22 20:54:14  knoaman
  101.  * Prepare for DOM L3 :
  102.  * - Make use of the XMLEntityHandler/XMLErrorReporter interfaces, instead of using
  103.  * EntityHandler/ErrorHandler directly.
  104.  * - Add 'AbstractDOMParser' class to provide common functionality for XercesDOMParser
  105.  * and DOMBuilder.
  106.  *
  107.  * Revision 1.4  2002/04/19 13:33:23  knoaman
  108.  * Fix for bug 8236.
  109.  *
  110.  * Revision 1.3  2002/04/01 15:47:06  knoaman
  111.  * Move Element Consistency checking (ref to global declarations) to SchemaValidator.
  112.  *
  113.  * Revision 1.2  2002/03/25 20:25:32  knoaman
  114.  * Move particle derivation checking from TraverseSchema to SchemaValidator.
  115.  *
  116.  * Revision 1.1.1.1  2002/02/01 22:22:47  peiyongz
  117.  * sane_include
  118.  *
  119.  * Revision 1.8  2001/11/13 13:25:08  tng
  120.  * Deprecate function XMLValidator::checkRootElement.
  121.  *
  122.  * Revision 1.7  2001/06/05 16:51:21  knoaman
  123.  * Add 'const' to getGrammar - submitted by Peter A. Volchek.
  124.  *
  125.  * Revision 1.6  2001/05/11 15:17:48  tng
  126.  * Schema: Nillable fixes.
  127.  *
  128.  * Revision 1.5  2001/05/11 13:27:37  tng
  129.  * Copyright update.
  130.  *
  131.  * Revision 1.4  2001/05/03 20:34:45  tng
  132.  * Schema: SchemaValidator update
  133.  *
  134.  * Revision 1.3  2001/04/19 18:17:40  tng
  135.  * Schema: SchemaValidator update, and use QName in Content Model
  136.  *
  137.  * Revision 1.2  2001/03/30 16:35:20  tng
  138.  * Schema: Whitespace normalization.
  139.  *
  140.  * Revision 1.1  2001/03/21 21:56:33  tng
  141.  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
  142.  *
  143.  */
  147. #if !defined(SCHEMAVALIDATOR_HPP)
  148. #define SCHEMAVALIDATOR_HPP
  150. #include <xercesc/framework/XMLValidator.hpp>
  151. #include <xercesc/framework/XMLBuffer.hpp>
  152. #include <xercesc/util/ValueStackOf.hpp>
  153. #include <xercesc/validators/common/ContentSpecNode.hpp>
  154. #include <xercesc/validators/schema/SchemaGrammar.hpp>
  155. #include <xercesc/validators/schema/XSDErrorReporter.hpp>
  157. XERCES_CPP_NAMESPACE_BEGIN
  159. class GrammarResolver;
  160. class DatatypeValidator;
  161. class SchemaElementDecl;
  163. //
  164. //  This is a derivative of the abstract validator interface. This class
  165. //  implements a validator that supports standard XML Schema semantics.
  166. //  This class handles scanning the of the schema, and provides
  167. //  the standard validation services against the Schema info it found.
  168. //
  169. class VALIDATORS_EXPORT SchemaValidator : public XMLValidator
  170. {
  171. public:
  172.     // -----------------------------------------------------------------------
  173.     //  Constructors and Destructor
  174.     // -----------------------------------------------------------------------
  175.     SchemaValidator
  176.     (
  177.           XMLErrorReporter* const errReporter = 0
  178.           , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
  179.     );
  180.     virtual ~SchemaValidator();
  182.     // -----------------------------------------------------------------------
  183.     //  Implementation of the XMLValidator interface
  184.     // -----------------------------------------------------------------------
  185.     virtual int checkContent
  186.     (
  187.         XMLElementDecl* const   elemDecl
  188.         , QName** const         children
  189.         , const unsigned int    childCount
  190.     );
  192.     virtual void faultInAttr
  193.     (
  194.                 XMLAttr&    toFill
  195.         , const XMLAttDef&  attDef
  196.     )   const;
  198.     virtual void preContentValidation(bool reuseGrammar,
  199.                                       bool validateDefAttr = false);
  201.     virtual void postParseValidation();
  203.     virtual void reset();
  205.     virtual bool requiresNamespaces() const;
  207.     virtual void validateAttrValue
  208.     (
  209.         const   XMLAttDef*                  attDef
  210.         , const XMLCh* const                attrValue
  211.         , bool                              preValidation = false
  212.         , const XMLElementDecl*             elemDecl = 0
  213.     );
  215.     virtual void validateElement
  216.     (
  217.         const   XMLElementDecl*             elemDef
  218.     );
  220.     virtual Grammar* getGrammar() const;
  221.     virtual void setGrammar(Grammar* aGrammar);
  223.     // -----------------------------------------------------------------------
  224.     //  Virtual DTD handler interface.
  225.     // -----------------------------------------------------------------------
  226.     virtual bool handlesDTD() const;
  228.     // -----------------------------------------------------------------------
  229.     //  Virtual Schema handler interface. handlesSchema() always return false.
  230.     // -----------------------------------------------------------------------
  231.     virtual bool handlesSchema() const;
  233.     // -----------------------------------------------------------------------
  234.     //  Schema Validator methods
  235.     // -----------------------------------------------------------------------
  236.     void normalizeWhiteSpace(DatatypeValidator* dV, const XMLCh* const value, XMLBuffer& toFill);
  238.     // -----------------------------------------------------------------------
  239.     //  Setter methods
  240.     // -----------------------------------------------------------------------
  241.     void setGrammarResolver(GrammarResolver* grammarResolver);
  243.     void setXsiType(const XMLCh* const        prefix
  244.       , const XMLCh* const        localPart
  245.        , const unsigned int        uriId);
  247.     void setNillable(bool isNil);
  248.     void setErrorReporter(XMLErrorReporter* const errorReporter);
  249.     void setExitOnFirstFatal(const bool newValue);
  250.     void setDatatypeBuffer(const XMLCh* const value);
  252.     // -----------------------------------------------------------------------
  253.     //  Getter methods
  254.     // -----------------------------------------------------------------------
  255.     ComplexTypeInfo* getCurrentTypeInfo() const;
  257. private:
  258.     // -----------------------------------------------------------------------
  259.     //  Element Consitency Checking methods
  260.     // -----------------------------------------------------------------------
  261.     void checkRefElementConsistency(SchemaGrammar* const currentGrammar,
  262.                                     const ComplexTypeInfo* const curTypeInfo,
  263.                                     const XercesGroupInfo* const curGroup = 0);
  265.     // -----------------------------------------------------------------------
  266.     //  Particle Derivation Checking methods
  267.     // -----------------------------------------------------------------------
  268.     void checkParticleDerivation(SchemaGrammar* const currentGrammar,
  269.                                  const ComplexTypeInfo* const typeInfo);
  270.     void checkParticleDerivationOk(SchemaGrammar* const currentGrammar,
  271.                                    ContentSpecNode* const curNode,
  272.                                    const int derivedScope,
  273.                                    ContentSpecNode* const baseNode,
  274.                                    const int baseScope,
  275.                                    const ComplexTypeInfo* const baseInfo = 0,
  276.                                    const bool toCheckOccurrence = true);
  277.     ContentSpecNode* checkForPointlessOccurrences(ContentSpecNode* const specNode,
  278.                                                   const ContentSpecNode::NodeTypes nodeType,
  279.                                                   ValueVectorOf<ContentSpecNode*>* const nodes);
  280.     void gatherChildren(const ContentSpecNode::NodeTypes parentNodeType,
  281.                         ContentSpecNode* const specNode,
  282.                         ValueVectorOf<ContentSpecNode*>* const nodes);
  283.     bool isOccurrenceRangeOK(const int min1, const int max1, const int min2, const int max2);
  284.     void checkNSCompat(const ContentSpecNode* const derivedSpecNode,
  285.                        const ContentSpecNode* const baseSpecNode,
  286.                        const bool toCheckOccurence);
  287.     bool wildcardEltAllowsNamespace(const ContentSpecNode* const baseSpecNode,
  288.                                     const unsigned int derivedURI);
  289.     void checkNameAndTypeOK(SchemaGrammar* const currentGrammar,
  290.                             const ContentSpecNode* const derivedSpecNode,
  291.                             const int derivedScope,
  292.                             const ContentSpecNode* const baseSpecNode,
  293.                             const int baseScope,
  294.                             const ComplexTypeInfo* const baseInfo = 0);
  295.     SchemaElementDecl* findElement(const int scope,
  296.                                    const unsigned int uriIndex,
  297.                                    const XMLCh* const name,
  298.                                    SchemaGrammar* const grammar,
  299.                                    const ComplexTypeInfo* const typeInfo = 0);
  300.     void checkICRestriction(const SchemaElementDecl* const derivedElemDecl,
  301.                             const SchemaElementDecl* const baseElemDecl,
  302.                             const XMLCh* const derivedElemName,
  303.                             const XMLCh* const baseElemName);
  304.     void checkTypesOK(const SchemaElementDecl* const derivedElemDecl,
  305.                       const SchemaElementDecl* const baseElemDecl,
  306.                       const XMLCh* const derivedElemName);
  307.     void checkRecurseAsIfGroup(SchemaGrammar* const currentGrammar,
  308.                                ContentSpecNode* const derivedSpecNode,
  309.                                const int derivedScope,
  310.                                const ContentSpecNode* const baseSpecNode,
  311.                                const int baseScope,
  312.                                ValueVectorOf<ContentSpecNode*>* const nodes,
  313.                                const ComplexTypeInfo* const baseInfo);
  314.     void checkRecurse(SchemaGrammar* const currentGrammar,
  315.                       const ContentSpecNode* const derivedSpecNode,
  316.                       const int derivedScope,
  317.                       ValueVectorOf<ContentSpecNode*>* const derivedNodes,
  318.                       const ContentSpecNode* const baseSpecNode,
  319.                       const int baseScope,
  320.                       ValueVectorOf<ContentSpecNode*>* const baseNodes,
  321.                       const ComplexTypeInfo* const baseInfo,
  322.                       const bool toLax = false);
  323.     void checkNSSubset(const ContentSpecNode* const derivedSpecNode,
  324.                        const ContentSpecNode* const baseSpecNode);
  325.     bool isWildCardEltSubset(const ContentSpecNode* const derivedSpecNode,
  326.                              const ContentSpecNode* const baseSpecNode);
  327.     void checkNSRecurseCheckCardinality(SchemaGrammar* const currentGrammar,
  328.                                         const ContentSpecNode* const derivedSpecNode,
  329.                                         ValueVectorOf<ContentSpecNode*>* const derivedNodes,
  330.                                         const int derivedScope,
  331.                                         ContentSpecNode* const baseSpecNode,
  332.                                         const bool toCheckOccurence);
  333.     void checkRecurseUnordered(SchemaGrammar* const currentGrammar,
  334.                                const ContentSpecNode* const derivedSpecNode,
  335.                                ValueVectorOf<ContentSpecNode*>* const derivedNodes,
  336.                                const int derivedScope,
  337.                                ContentSpecNode* const baseSpecNode,
  338.                                ValueVectorOf<ContentSpecNode*>* const baseNodes,
  339.                                const int baseScope,
  340.                                const ComplexTypeInfo* const baseInfo);
  341.     void checkMapAndSum(SchemaGrammar* const currentGrammar,
  342.                         const ContentSpecNode* const derivedSpecNode,
  343.                         ValueVectorOf<ContentSpecNode*>* const derivedNodes,
  344.                         const int derivedScope,
  345.                         ContentSpecNode* const baseSpecNode,
  346.                         ValueVectorOf<ContentSpecNode*>* const baseNodes,
  347.                         const int baseScope,
  348.                         const ComplexTypeInfo* const baseInfo);
  350.     // -----------------------------------------------------------------------
  351.     //  Private data members
  352.     //
  353.     // -----------------------------------------------------------------------
  354.     //  The following comes from or set by the Scanner
  355.     //  fSchemaGrammar
  356.     //      The current schema grammar used by the validator
  357.     //
  358.     //  fGrammarResolver
  359.     //      All the schema grammar stored
  360.     //
  361.     //  fXsiType
  362.     //      Store the Schema Type Attribute Value if schema type is specified
  363.     //
  364.     //  fNil
  365.     //      Indicates if Nillable has been set
  366.     // -----------------------------------------------------------------------
  367.     //  The following used internally in the validator
  368.     //
  369.     //  fXsiTypeValidator
  370.     //      The validator used for xsi type validation
  371.     //
  372.     //  fDatatypeBuffer
  373.     //      Buffer for simple type element string content
  374.     //
  375.     //  fTrailing
  376.     //      Previous chunk had a trailing space
  377.     //
  378.     //  fSeenId
  379.     //      Indicate if an attribute of ID type has been seen already, reset per element.
  380.     //
  381.     //  fSchemaErrorReporter
  382.     //      Report schema process errors
  383.     //
  384.     //  fTypeStack
  385.     //      Stack of complex type declarations.
  386.     // -----------------------------------------------------------------------
  387.     MemoryManager*                  fMemoryManager;
  388.     SchemaGrammar*                  fSchemaGrammar;
  389.     GrammarResolver*                fGrammarResolver;
  390.     QName*                          fXsiType;
  391.     bool                            fNil;
  392.     DatatypeValidator*              fXsiTypeValidator;
  393.     XMLBuffer                       fDatatypeBuffer;
  394.     bool                            fTrailing;
  395.     bool                            fSeenId;
  396.     XSDErrorReporter                fSchemaErrorReporter;
  397.     ValueStackOf<ComplexTypeInfo*>* fTypeStack;
  398. };
  401. // ---------------------------------------------------------------------------
  402. //  SchemaValidator: Setter methods
  403. // ---------------------------------------------------------------------------
  404. inline void SchemaValidator::setGrammarResolver(GrammarResolver* grammarResolver) {
  405.     fGrammarResolver = grammarResolver;
  406. }
  408. inline void SchemaValidator::setXsiType(const XMLCh* const        prefix
  409.       , const XMLCh* const        localPart
  410.        , const unsigned int        uriId)
  411. {
  412.     delete fXsiType;
  413.     fXsiType = new (fMemoryManager) QName(prefix, localPart, uriId, fMemoryManager);
  414. }
  416. inline void SchemaValidator::setNillable(bool isNil) {
  417.     fNil = isNil;
  418. }
  420. inline void SchemaValidator::setExitOnFirstFatal(const bool newValue) {
  422.     fSchemaErrorReporter.setExitOnFirstFatal(newValue);
  423. }
  425. inline void SchemaValidator::setDatatypeBuffer(const XMLCh* const value)
  426. {
  427.     fDatatypeBuffer.append(value);
  428. }
  430. // ---------------------------------------------------------------------------
  431. //  SchemaValidator: Getter methods
  432. // ---------------------------------------------------------------------------
  433. inline ComplexTypeInfo* SchemaValidator::getCurrentTypeInfo() const {
  434.     if (fTypeStack->empty())
  435.         return 0;
  436.     return fTypeStack->peek();
  437. }
  439. // ---------------------------------------------------------------------------
  440. //  Virtual interface
  441. // ---------------------------------------------------------------------------
  442. inline Grammar* SchemaValidator::getGrammar() const {
  443.     return fSchemaGrammar;
  444. }
  446. inline void SchemaValidator::setGrammar(Grammar* aGrammar) {
  447.     fSchemaGrammar = (SchemaGrammar*) aGrammar;
  448. }
  450. inline void SchemaValidator::setErrorReporter(XMLErrorReporter* const errorReporter) {
  452.     XMLValidator::setErrorReporter(errorReporter);
  453.     fSchemaErrorReporter.setErrorReporter(errorReporter);
  454. }
  456. // ---------------------------------------------------------------------------
  457. //  SchemaValidator: DTD handler interface
  458. // ---------------------------------------------------------------------------
  459. inline bool SchemaValidator::handlesDTD() const
  460. {
  461.     // No DTD scanning
  462.     return false;
  463. }
  465. // ---------------------------------------------------------------------------
  466. //  SchemaValidator: Schema handler interface
  467. // ---------------------------------------------------------------------------
  468. inline bool SchemaValidator::handlesSchema() const
  469. {
  470.     return true;
  471. }
  473. // ---------------------------------------------------------------------------
  474. //  SchemaValidator: Particle derivation checking
  475. // ---------------------------------------------------------------------------
  476. inline bool
  477. SchemaValidator::isOccurrenceRangeOK(const int min1, const int max1,
  478.                                      const int min2, const int max2) {
  480.     if (min1 >= min2 &&
  481.         (max2 == SchemaSymbols::XSD_UNBOUNDED ||
  482.          (max1 != SchemaSymbols::XSD_UNBOUNDED && max1 <= max2))) {
  483.         return true;
  484.     }
  485.     return false;
  486. }
  488. XERCES_CPP_NAMESPACE_END
  490. #endif