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

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 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) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Log: XMLChar.hpp,v $
  58.  * Revision 1.1  2002/12/20 22:10:21  tng
  59.  * XML 1.1
  60.  *
  61.  */
  62. #if !defined(XMLCHAR_HPP)
  63. #define XMLCHAR_HPP
  64. #include <xercesc/util/XMLUniDefs.hpp>
  65. XERCES_CPP_NAMESPACE_BEGIN
  66. // ---------------------------------------------------------------------------
  67. //  This file defines Char and utility that conforms to XML 1.0 and XML 1.1
  68. // ---------------------------------------------------------------------------
  69. // Masks for the fgCharCharsTable1_0 array
  70. const XMLByte   gLetterCharMask             = 0x1;
  71. const XMLByte   gFirstNameCharMask          = 0x2;
  72. const XMLByte   gNameCharMask               = 0x4;
  73. const XMLByte   gPlainContentCharMask       = 0x8;
  74. const XMLByte   gSpecialStartTagCharMask    = 0x10;
  75. const XMLByte   gControlCharMask            = 0x20;
  76. const XMLByte   gXMLCharMask                = 0x40;
  77. const XMLByte   gWhitespaceCharMask         = 0x80;
  78. // ---------------------------------------------------------------------------
  79. //  This class is for XML 1.0
  80. // ---------------------------------------------------------------------------
  81. class XMLUTIL_EXPORT XMLChar1_0
  82. {
  83. public:
  84.     // -----------------------------------------------------------------------
  85.     //  Public, static methods, check the string
  86.     // -----------------------------------------------------------------------
  87.     static bool isAllSpaces
  88.     (
  89.         const   XMLCh* const    toCheck
  90.         , const unsigned int    count
  91.     );
  92.     static bool containsWhiteSpace
  93.     (
  94.         const   XMLCh* const    toCheck
  95.         , const unsigned int    count
  96.     );
  97.     static bool isValidName
  98.     (
  99.         const   XMLCh* const    toCheck
  100.         , const unsigned int    count
  101.     );
  102.     static bool isValidNCName
  103.     (
  104.         const   XMLCh* const    toCheck
  105.         , const unsigned int    count
  106.     );
  107.     static bool isValidQName
  108.     (
  109.         const   XMLCh* const    toCheck
  110.         , const unsigned int    count
  111.     );
  112.     // -----------------------------------------------------------------------
  113.     //  Public, static methods, check the XMLCh
  114.     //  surrogate pair is assumed if second parameter is not null
  115.     // -----------------------------------------------------------------------
  116.     static bool isXMLLetter(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  117.     static bool isFirstNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  118.     static bool isNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  119.     static bool isPlainContentChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  120.     static bool isSpecialStartTagChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  121.     static bool isXMLChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  122.     static bool isWhitespace(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  123.     static bool isControlChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  124.     static bool isPublicIdChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  125.     // -----------------------------------------------------------------------
  126.     //  Special Non-conformant Public, static methods
  127.     // -----------------------------------------------------------------------
  128.     /**
  129.       * Return true if NEL (0x85) and LSEP (0x2028) to be treated as white space char.
  130.       */
  131.     static bool isNELRecognized();
  132.     /**
  133.       * Method to enable NEL (0x85) and LSEP (0x2028) to be treated as white space char.
  134.       */
  135.     static void enableNELWS();
  136. private:
  137.     // -----------------------------------------------------------------------
  138.     //  Static data members
  139.     //
  140.     //  fgCharCharsTable1_0
  141.     //      The character characteristics table. Bits in each byte, represent
  142.     //      the characteristics of each character. It is generated via some
  143.     //      code and then hard coded into the cpp file for speed.
  144.     //
  145.     //  fNEL
  146.     //      Flag to respresents whether NEL and LSEP newline recognition is enabled
  147.     //      or disabled
  148.     // -----------------------------------------------------------------------
  149.     static XMLByte  fgCharCharsTable1_0[0x10000];
  150.     static bool     enableNEL;
  151.     friend class XMLReader;
  152. };
  153. // ---------------------------------------------------------------------------
  154. //  XMLReader: Public, static methods
  155. // ---------------------------------------------------------------------------
  156. inline bool XMLChar1_0::isXMLLetter(const XMLCh toCheck, const XMLCh toCheck2)
  157. {
  158.     if (!toCheck2)
  159.         return ((fgCharCharsTable1_0[toCheck] & gLetterCharMask) != 0);
  160.     return false;
  161. }
  162. inline bool XMLChar1_0::isFirstNameChar(const XMLCh toCheck, const XMLCh toCheck2)
  163. {
  164.     if (!toCheck2)
  165.         return ((fgCharCharsTable1_0[toCheck] & gFirstNameCharMask) != 0);
  166.     return false;
  167. }
  168. inline bool XMLChar1_0::isNameChar(const XMLCh toCheck, const XMLCh toCheck2)
  169. {
  170.     if (!toCheck2)
  171.         return ((fgCharCharsTable1_0[toCheck] & gNameCharMask) != 0);
  172.     return false;
  173. }
  174. inline bool XMLChar1_0::isPlainContentChar(const XMLCh toCheck, const XMLCh toCheck2)
  175. {
  176.     if (!toCheck2)
  177.         return ((fgCharCharsTable1_0[toCheck] & gPlainContentCharMask) != 0);
  178.     else {
  179.         if ((toCheck >= 0xD800) && (toCheck <= 0xDBFF))
  180.            if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
  181.                return true;
  182.     }
  183.     return false;
  184. }
  185. inline bool XMLChar1_0::isSpecialStartTagChar(const XMLCh toCheck, const XMLCh toCheck2)
  186. {
  187.     if (!toCheck2)
  188.         return ((fgCharCharsTable1_0[toCheck] & gSpecialStartTagCharMask) != 0);
  189.     return false;
  190. }
  191. inline bool XMLChar1_0::isXMLChar(const XMLCh toCheck, const XMLCh toCheck2)
  192. {
  193.     if (!toCheck2)
  194.         return ((fgCharCharsTable1_0[toCheck] & gXMLCharMask) != 0);
  195.     else {
  196.         if ((toCheck >= 0xD800) && (toCheck <= 0xDBFF))
  197.            if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
  198.                return true;
  199.     }
  200.     return false;
  201. }
  202. inline bool XMLChar1_0::isWhitespace(const XMLCh toCheck, const XMLCh toCheck2)
  203. {
  204.     if (!toCheck2)
  205.         return ((fgCharCharsTable1_0[toCheck] & gWhitespaceCharMask) != 0);
  206.     return false;
  207. }
  208. inline bool XMLChar1_0::isControlChar(const XMLCh toCheck, const XMLCh toCheck2)
  209. {
  210.     if (!toCheck2)
  211.         return ((fgCharCharsTable1_0[toCheck] & gControlCharMask) != 0);
  212.     return false;
  213. }
  214. inline bool XMLChar1_0::isNELRecognized() {
  215.     return enableNEL;
  216. }
  217. // ---------------------------------------------------------------------------
  218. //  This class is for XML 1.1
  219. // ---------------------------------------------------------------------------
  220. class XMLUTIL_EXPORT XMLChar1_1
  221. {
  222. public:
  223.     // -----------------------------------------------------------------------
  224.     //  Public, static methods, check the string
  225.     // -----------------------------------------------------------------------
  226.     static bool isAllSpaces
  227.     (
  228.         const   XMLCh* const    toCheck
  229.         , const unsigned int    count
  230.     );
  231.     static bool containsWhiteSpace
  232.     (
  233.         const   XMLCh* const    toCheck
  234.         , const unsigned int    count
  235.     );
  236.     static bool isValidName
  237.     (
  238.         const   XMLCh* const    toCheck
  239.         , const unsigned int    count
  240.     );
  241.     static bool isValidNCName
  242.     (
  243.         const   XMLCh* const    toCheck
  244.         , const unsigned int    count
  245.     );
  246.     static bool isValidQName
  247.     (
  248.         const   XMLCh* const    toCheck
  249.         , const unsigned int    count
  250.     );
  251.     // -----------------------------------------------------------------------
  252.     //  Public, static methods, check the XMLCh
  253.     // -----------------------------------------------------------------------
  254.     static bool isXMLLetter(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  255.     static bool isFirstNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  256.     static bool isNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  257.     static bool isPlainContentChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  258.     static bool isSpecialStartTagChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  259.     static bool isXMLChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  260.     static bool isWhitespace(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  261.     static bool isControlChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  262.     static bool isPublicIdChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
  263. private:
  264.     // -----------------------------------------------------------------------
  265.     //  Static data members
  266.     //
  267.     //  fgCharCharsTable1_1
  268.     //      The character characteristics table. Bits in each byte, represent
  269.     //      the characteristics of each character. It is generated via some
  270.     //      code and then hard coded into the cpp file for speed.
  271.     //
  272.     // -----------------------------------------------------------------------
  273.     static XMLByte  fgCharCharsTable1_1[0x10000];
  274.     friend class XMLReader;
  275. };
  276. // ---------------------------------------------------------------------------
  277. //  XMLReader: Public, static methods
  278. // ---------------------------------------------------------------------------
  279. inline bool XMLChar1_1::isXMLLetter(const XMLCh toCheck, const XMLCh toCheck2)
  280. {
  281.     if (!toCheck2)
  282.         return ((fgCharCharsTable1_1[toCheck] & gLetterCharMask) != 0);
  283.     return false;
  284. }
  285. inline bool XMLChar1_1::isFirstNameChar(const XMLCh toCheck, const XMLCh toCheck2)
  286. {
  287.     if (!toCheck2)
  288.         return ((fgCharCharsTable1_1[toCheck] & gFirstNameCharMask) != 0);
  289.     else {
  290.         if ((toCheck >= 0xD800) && (toCheck <= 0xDB7F))
  291.            if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
  292.                return true;
  293.     }
  294.     return false;
  295. }
  296. inline bool XMLChar1_1::isNameChar(const XMLCh toCheck, const XMLCh toCheck2)
  297. {
  298.     if (!toCheck2)
  299.         return ((fgCharCharsTable1_1[toCheck] & gNameCharMask) != 0);
  300.     else {
  301.         if ((toCheck >= 0xD800) && (toCheck <= 0xDB7F))
  302.            if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
  303.                return true;
  304.     }
  305.     return false;
  306. }
  307. inline bool XMLChar1_1::isPlainContentChar(const XMLCh toCheck, const XMLCh toCheck2)
  308. {
  309.     if (!toCheck2)
  310.         return ((fgCharCharsTable1_1[toCheck] & gPlainContentCharMask) != 0);
  311.     else {
  312.         if ((toCheck >= 0xD800) && (toCheck <= 0xDBFF))
  313.            if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
  314.                return true;
  315.     }
  316.     return false;
  317. }
  318. inline bool XMLChar1_1::isSpecialStartTagChar(const XMLCh toCheck, const XMLCh toCheck2)
  319. {
  320.     if (!toCheck2)
  321.         return ((fgCharCharsTable1_1[toCheck] & gSpecialStartTagCharMask) != 0);
  322.     return false;
  323. }
  324. inline bool XMLChar1_1::isXMLChar(const XMLCh toCheck, const XMLCh toCheck2)
  325. {
  326.     if (!toCheck2)
  327.         return ((fgCharCharsTable1_1[toCheck] & gXMLCharMask) != 0);
  328.     else {
  329.         if ((toCheck >= 0xD800) && (toCheck <= 0xDBFF))
  330.            if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
  331.                return true;
  332.     }
  333.     return false;
  334. }
  335. inline bool XMLChar1_1::isWhitespace(const XMLCh toCheck, const XMLCh toCheck2)
  336. {
  337.     if (!toCheck2)
  338.         return ((fgCharCharsTable1_1[toCheck] & gWhitespaceCharMask) != 0);
  339.     return false;
  340. }
  341. inline bool XMLChar1_1::isControlChar(const XMLCh toCheck, const XMLCh toCheck2)
  342. {
  343.     if (!toCheck2)
  344.         return ((fgCharCharsTable1_1[toCheck] & gControlCharMask) != 0);
  345.     return false;
  346. }
  347. XERCES_CPP_NAMESPACE_END
  348. #endif