1. /*

  2.  * The Apache Software License, Version 1.1

  3.  *

  4.  *

  5.  * Copyright (c) 1999-2004 The Apache Software Foundation.  All rights 

  6.  * reserved.

  7.  *

  8.  * Redistribution and use in source and binary forms, with or without

  9.  * modification, are permitted provided that the following conditions

  10.  * are met:

  11.  *

  12.  * 1. Redistributions of source code must retain the above copyright

  13.  *    notice, this list of conditions and the following disclaimer. 

  14.  *

  15.  * 2. Redistributions in binary form must reproduce the above copyright

  16.  *    notice, this list of conditions and the following disclaimer in

  17.  *    the documentation and/or other materials provided with the

  18.  *    distribution.

  19.  *

  20.  * 3. The end-user documentation included with the redistribution,

  21.  *    if any, must include the following acknowledgment:  

  22.  *       "This product includes software developed by the

  23.  *        Apache Software Foundation (http://www.apache.org/)."

  24.  *    Alternately, this acknowledgment may appear in the software itself,

  25.  *    if and wherever such third-party acknowledgments normally appear.

  26.  *

  27.  * 4. The names "Xerces" and "Apache Software Foundation" must

  28.  *    not be used to endorse or promote products derived from this

  29.  *    software without prior written permission. For written 

  30.  *    permission, please contact apache@apache.org.

  31.  *

  32.  * 5. Products derived from this software may not be called "Apache",

  33.  *    nor may "Apache" appear in their name, without prior written

  34.  *    permission of the Apache Software Foundation.

  35.  *

  36.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED

  37.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

  38.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

  39.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR

  40.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

  41.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

  42.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

  43.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

  44.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  45.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

  46.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

  47.  * SUCH DAMAGE.

  48.  * ====================================================================

  49.  *

  50.  * This software consists of voluntary contributions made by many

  51.  * individuals on behalf of the Apache Software Foundation and was

  52.  * originally based on software copyright (c) 1999, International

  53.  * Business Machines, Inc., http://www.apache.org.  For more

  54.  * information on the Apache Software Foundation, please see

  55.  * <http://www.apache.org/>.

  56.  */

  57. 

  58. package com.sun.org.apache.xerces.internal.util;

  59. 

  60. import java.util.Arrays;

  61. 

  62. /**

  63.  * This class defines the basic properties of characters in XML 1.1. The data

  64.  * in this class can be used to verify that a character is a valid

  65.  * XML 1.1 character or if the character is a space, name start, or name

  66.  * character.

  67.  * <p>

  68.  * A series of convenience methods are supplied to ease the burden

  69.  * of the developer.  Using the character as an index into the <code>XML11CHARS</code>

  70.  * array and applying the appropriate mask flag (e.g.

  71.  * <code>MASK_VALID</code>), yields the same results as calling the

  72.  * convenience methods. There is one exception: check the comments

  73.  * for the <code>isValid</code> method for details.

  74.  *

  75.  * @author Glenn Marcy, IBM

  76.  * @author Andy Clark, IBM

  77.  * @author Arnaud  Le Hors, IBM

  78.  * @author Neil Graham, IBM

  79.  * @author Michael Glavassevich, IBM

  80.  *

  81.  * @version $Id: XML11Char.java,v 1.6 2004/02/03 20:34:27 mrglavas Exp $

  82.  */

  83. public class XML11Char {

  84. 

  85.     //

  86.     // Constants

  87.     //

  88. 

  89.     /** Character flags for XML 1.1. */

  90.     private static final byte XML11CHARS [] = new byte [1 << 16];

  91. 

  92.     /** XML 1.1 Valid character mask. */

  93.     public static final int MASK_XML11_VALID = 0x01;

  94. 

  95.     /** XML 1.1 Space character mask. */

  96.     public static final int MASK_XML11_SPACE = 0x02;

  97. 

  98.     /** XML 1.1 Name start character mask. */

  99.     public static final int MASK_XML11_NAME_START = 0x04;

  100. 

  101.     /** XML 1.1 Name character mask. */

  102.     public static final int MASK_XML11_NAME = 0x08;

  103. 

  104.     /** XML 1.1 control character mask */

  105.     public static final int MASK_XML11_CONTROL = 0x10;

  106. 

  107.     /** XML 1.1 content for external entities (valid - "special" chars - control chars) */

  108.     public static final int MASK_XML11_CONTENT = 0x20;

  109. 

  110.     /** XML namespaces 1.1 NCNameStart */

  111.     public static final int MASK_XML11_NCNAME_START = 0x40;

  112. 

  113.     /** XML namespaces 1.1 NCName */

  114.     public static final int MASK_XML11_NCNAME = 0x80;

  115.     

  116.     /** XML 1.1 content for internal entities (valid - "special" chars) */

  117.     public static final int MASK_XML11_CONTENT_INTERNAL = MASK_XML11_CONTROL | MASK_XML11_CONTENT; 

  118. 

  119.     //

  120.     // Static initialization

  121.     //

  122. 

  123.     static {

  124.     	

  125.         // Initializing the Character Flag Array

  126.         // Code generated by: XML11CharGenerator.

  127.         

  128.         Arrays.fill(XML11CHARS, 1, 9, (byte) 17 ); // Fill 8 of value (byte) 17

  129.         XML11CHARS[9] = 35;

  130.         XML11CHARS[10] = 3;

  131.         Arrays.fill(XML11CHARS, 11, 13, (byte) 17 ); // Fill 2 of value (byte) 17

  132.         XML11CHARS[13] = 3;

  133.         Arrays.fill(XML11CHARS, 14, 32, (byte) 17 ); // Fill 18 of value (byte) 17

  134.         XML11CHARS[32] = 35;

  135.         Arrays.fill(XML11CHARS, 33, 38, (byte) 33 ); // Fill 5 of value (byte) 33

  136.         XML11CHARS[38] = 1;

  137.         Arrays.fill(XML11CHARS, 39, 45, (byte) 33 ); // Fill 6 of value (byte) 33

  138.         Arrays.fill(XML11CHARS, 45, 47, (byte) -87 ); // Fill 2 of value (byte) -87

  139.         XML11CHARS[47] = 33;

  140.         Arrays.fill(XML11CHARS, 48, 58, (byte) -87 ); // Fill 10 of value (byte) -87

  141.         XML11CHARS[58] = 45;

  142.         XML11CHARS[59] = 33;

  143.         XML11CHARS[60] = 1;

  144.         Arrays.fill(XML11CHARS, 61, 65, (byte) 33 ); // Fill 4 of value (byte) 33

  145.         Arrays.fill(XML11CHARS, 65, 91, (byte) -19 ); // Fill 26 of value (byte) -19

  146.         Arrays.fill(XML11CHARS, 91, 93, (byte) 33 ); // Fill 2 of value (byte) 33

  147.         XML11CHARS[93] = 1;

  148.         XML11CHARS[94] = 33;

  149.         XML11CHARS[95] = -19;

  150.         XML11CHARS[96] = 33;

  151.         Arrays.fill(XML11CHARS, 97, 123, (byte) -19 ); // Fill 26 of value (byte) -19

  152.         Arrays.fill(XML11CHARS, 123, 127, (byte) 33 ); // Fill 4 of value (byte) 33

  153.         Arrays.fill(XML11CHARS, 127, 133, (byte) 17 ); // Fill 6 of value (byte) 17

  154.         XML11CHARS[133] = 35;

  155.         Arrays.fill(XML11CHARS, 134, 160, (byte) 17 ); // Fill 26 of value (byte) 17

  156.         Arrays.fill(XML11CHARS, 160, 183, (byte) 33 ); // Fill 23 of value (byte) 33

  157.         XML11CHARS[183] = -87;

  158.         Arrays.fill(XML11CHARS, 184, 192, (byte) 33 ); // Fill 8 of value (byte) 33

  159.         Arrays.fill(XML11CHARS, 192, 215, (byte) -19 ); // Fill 23 of value (byte) -19

  160.         XML11CHARS[215] = 33;

  161.         Arrays.fill(XML11CHARS, 216, 247, (byte) -19 ); // Fill 31 of value (byte) -19

  162.         XML11CHARS[247] = 33;

  163.         Arrays.fill(XML11CHARS, 248, 768, (byte) -19 ); // Fill 520 of value (byte) -19

  164.         Arrays.fill(XML11CHARS, 768, 880, (byte) -87 ); // Fill 112 of value (byte) -87

  165.         Arrays.fill(XML11CHARS, 880, 894, (byte) -19 ); // Fill 14 of value (byte) -19

  166.         XML11CHARS[894] = 33;

  167.         Arrays.fill(XML11CHARS, 895, 8192, (byte) -19 ); // Fill 7297 of value (byte) -19

  168.         Arrays.fill(XML11CHARS, 8192, 8204, (byte) 33 ); // Fill 12 of value (byte) 33

  169.         Arrays.fill(XML11CHARS, 8204, 8206, (byte) -19 ); // Fill 2 of value (byte) -19

  170.         Arrays.fill(XML11CHARS, 8206, 8232, (byte) 33 ); // Fill 26 of value (byte) 33

  171.         XML11CHARS[8232] = 35;

  172.         Arrays.fill(XML11CHARS, 8233, 8255, (byte) 33 ); // Fill 22 of value (byte) 33

  173.         Arrays.fill(XML11CHARS, 8255, 8257, (byte) -87 ); // Fill 2 of value (byte) -87

  174.         Arrays.fill(XML11CHARS, 8257, 8304, (byte) 33 ); // Fill 47 of value (byte) 33

  175.         Arrays.fill(XML11CHARS, 8304, 8592, (byte) -19 ); // Fill 288 of value (byte) -19

  176.         Arrays.fill(XML11CHARS, 8592, 11264, (byte) 33 ); // Fill 2672 of value (byte) 33

  177.         Arrays.fill(XML11CHARS, 11264, 12272, (byte) -19 ); // Fill 1008 of value (byte) -19

  178.         Arrays.fill(XML11CHARS, 12272, 12289, (byte) 33 ); // Fill 17 of value (byte) 33

  179.         Arrays.fill(XML11CHARS, 12289, 55296, (byte) -19 ); // Fill 43007 of value (byte) -19

  180.         Arrays.fill(XML11CHARS, 57344, 63744, (byte) 33 ); // Fill 6400 of value (byte) 33

  181.         Arrays.fill(XML11CHARS, 63744, 64976, (byte) -19 ); // Fill 1232 of value (byte) -19

  182.         Arrays.fill(XML11CHARS, 64976, 65008, (byte) 33 ); // Fill 32 of value (byte) 33

  183.         Arrays.fill(XML11CHARS, 65008, 65534, (byte) -19 ); // Fill 526 of value (byte) -19

  184. 

  185.     } // <clinit>()

  186. 

  187.     //

  188.     // Public static methods

  189.     //

  190. 

  191.     /**

  192.      * Returns true if the specified character is a space character

  193.      * as amdended in the XML 1.1 specification.

  194.      *

  195.      * @param c The character to check.

  196.      */

  197.     public static boolean isXML11Space(int c) {

  198.         return (c < 0x10000 && (XML11CHARS[c] & MASK_XML11_SPACE) != 0);

  199.     } // isXML11Space(int):boolean

  200. 

  201.     /**

  202.      * Returns true if the specified character is valid. This method

  203.      * also checks the surrogate character range from 0x10000 to 0x10FFFF.

  204.      * <p>

  205.      * If the program chooses to apply the mask directly to the

  206.      * <code>XML11CHARS</code> array, then they are responsible for checking

  207.      * the surrogate character range.

  208.      *

  209.      * @param c The character to check.

  210.      */

  211.     public static boolean isXML11Valid(int c) {

  212.         return (c < 0x10000 && (XML11CHARS[c] & MASK_XML11_VALID) != 0) 

  213.                 || (0x10000 <= c && c <= 0x10FFFF);

  214.     } // isXML11Valid(int):boolean

  215. 

  216.     /**

  217.      * Returns true if the specified character is invalid.

  218.      *

  219.      * @param c The character to check.

  220.      */

  221.     public static boolean isXML11Invalid(int c) {

  222.         return !isXML11Valid(c);

  223.     } // isXML11Invalid(int):boolean

  224. 

  225.     /**

  226.      * Returns true if the specified character is valid and permitted outside

  227.      * of a character reference.  

  228.      * That is, this method will return false for the same set as

  229.      * isXML11Valid, except it also reports false for "control characters".

  230.      *

  231.      * @param c The character to check.

  232.      */

  233.     public static boolean isXML11ValidLiteral(int c) {

  234.         return ((c < 0x10000 && ((XML11CHARS[c] & MASK_XML11_VALID) != 0 && (XML11CHARS[c] & MASK_XML11_CONTROL) == 0))

  235.             || (0x10000 <= c && c <= 0x10FFFF)); 

  236.     } // isXML11ValidLiteral(int):boolean

  237. 

  238.     /**

  239.      * Returns true if the specified character can be considered 

  240.      * content in an external parsed entity.

  241.      *

  242.      * @param c The character to check.

  243.      */

  244.     public static boolean isXML11Content(int c) {

  245.         return (c < 0x10000 && (XML11CHARS[c] & MASK_XML11_CONTENT) != 0) ||

  246.                (0x10000 <= c && c <= 0x10FFFF);

  247.     } // isXML11Content(int):boolean

  248.     

  249.     /**

  250.      * Returns true if the specified character can be considered 

  251.      * content in an internal parsed entity.

  252.      *

  253.      * @param c The character to check.

  254.      */

  255.     public static boolean isXML11InternalEntityContent(int c) {

  256.         return (c < 0x10000 && (XML11CHARS[c] & MASK_XML11_CONTENT_INTERNAL) != 0) ||

  257.                (0x10000 <= c && c <= 0x10FFFF);

  258.     } // isXML11InternalEntityContent(int):boolean

  259. 

  260.     /**

  261.      * Returns true if the specified character is a valid name start

  262.      * character as defined by production [4] in the XML 1.1

  263.      * specification.

  264.      *

  265.      * @param c The character to check.

  266.      */

  267.     public static boolean isXML11NameStart(int c) {

  268.         return (c < 0x10000 && (XML11CHARS[c] & MASK_XML11_NAME_START) != 0)

  269.             || (0x10000 <= c && c < 0xF0000);

  270.     } // isXML11NameStart(int):boolean

  271. 

  272.     /**

  273.      * Returns true if the specified character is a valid name

  274.      * character as defined by production [4a] in the XML 1.1

  275.      * specification.

  276.      *

  277.      * @param c The character to check.

  278.      */

  279.     public static boolean isXML11Name(int c) {

  280.         return (c < 0x10000 && (XML11CHARS[c] & MASK_XML11_NAME) != 0) 

  281.             || (c >= 0x10000 && c < 0xF0000);

  282.     } // isXML11Name(int):boolean

  283. 

  284.     /**

  285.      * Returns true if the specified character is a valid NCName start

  286.      * character as defined by production [4] in Namespaces in XML

  287.      * 1.1 recommendation.

  288.      *

  289.      * @param c The character to check.

  290.      */

  291.     public static boolean isXML11NCNameStart(int c) {

  292.         return (c < 0x10000 && (XML11CHARS[c] & MASK_XML11_NCNAME_START) != 0)

  293.             || (0x10000 <= c && c < 0xF0000);

  294.     } // isXML11NCNameStart(int):boolean

  295. 

  296.     /**

  297.      * Returns true if the specified character is a valid NCName

  298.      * character as defined by production [5] in Namespaces in XML

  299.      * 1.1 recommendation.

  300.      *

  301.      * @param c The character to check.

  302.      */

  303.     public static boolean isXML11NCName(int c) {

  304.         return (c < 0x10000 && (XML11CHARS[c] & MASK_XML11_NCNAME) != 0)

  305.             || (0x10000 <= c && c < 0xF0000);

  306.     } // isXML11NCName(int):boolean

  307.     

  308.     /**

  309.      * Returns whether the given character is a valid 

  310.      * high surrogate for a name character. This includes

  311.      * all high surrogates for characters [0x10000-0xEFFFF].

  312.      * In other words everything excluding planes 15 and 16.

  313.      *

  314.      * @param c The character to check.

  315.      */

  316.     public static boolean isXML11NameHighSurrogate(int c) {

  317.         return (0xD800 <= c && c <= 0xDB7F);

  318.     }

  319. 

  320.     /*

  321.      * [5] Name ::= NameStartChar NameChar*

  322.      */

  323.     /**

  324.      * Check to see if a string is a valid Name according to [5]

  325.      * in the XML 1.1 Recommendation

  326.      *

  327.      * @param name string to check

  328.      * @return true if name is a valid Name

  329.      */

  330.     public static boolean isXML11ValidName(String name) {

  331.         int length = name.length();

  332.         if (length == 0)

  333.             return false;

  334.         int i = 1;

  335.         char ch = name.charAt(0);

  336.         if( !isXML11NameStart(ch) ) {

  337.             if ( length > 1 && isXML11NameHighSurrogate(ch) ) {

  338.                 char ch2 = name.charAt(1);

  339.                 if ( !XMLChar.isLowSurrogate(ch2) || 

  340.                      !isXML11NameStart(XMLChar.supplemental(ch, ch2)) ) {

  341.                     return false;

  342.                 }

  343.                 i = 2;

  344.             }

  345.             else {

  346.                 return false;

  347.             }

  348.         }

  349.         while (i < length) {

  350.             ch = name.charAt(i);

  351.             if ( !isXML11Name(ch) ) {

  352.                 if ( ++i < length && isXML11NameHighSurrogate(ch) ) {

  353.                     char ch2 = name.charAt(i);

  354.                     if ( !XMLChar.isLowSurrogate(ch2) || 

  355.                          !isXML11Name(XMLChar.supplemental(ch, ch2)) ) {

  356.                         return false;

  357.                     }

  358.                 }

  359.                 else {

  360.                     return false;

  361.                 }

  362.             }

  363.             ++i;

  364.         }

  365.         return true;

  366.     } // isXML11ValidName(String):boolean

  367.     

  368. 

  369.     /*

  370.      * from the namespace 1.1 rec

  371.      * [4] NCName ::= NCNameStartChar NCNameChar*

  372.      */

  373.     /**

  374.      * Check to see if a string is a valid NCName according to [4]

  375.      * from the XML Namespaces 1.1 Recommendation

  376.      *

  377.      * @param name string to check

  378.      * @return true if name is a valid NCName

  379.      */

  380.     public static boolean isXML11ValidNCName(String ncName) {

  381.         int length = ncName.length();

  382.         if (length == 0)

  383.             return false;

  384.         int i = 1;

  385.         char ch = ncName.charAt(0);

  386.         if( !isXML11NCNameStart(ch) ) {

  387.             if ( length > 1 && isXML11NameHighSurrogate(ch) ) {

  388.                 char ch2 = ncName.charAt(1);

  389.                 if ( !XMLChar.isLowSurrogate(ch2) || 

  390.                      !isXML11NCNameStart(XMLChar.supplemental(ch, ch2)) ) {

  391.                     return false;

  392.                 }

  393.                 i = 2;

  394.             }

  395.             else {

  396.                 return false;

  397.             }

  398.         }

  399.         while (i < length) {

  400.             ch = ncName.charAt(i);

  401.             if ( !isXML11NCName(ch) ) {

  402.                 if ( ++i < length && isXML11NameHighSurrogate(ch) ) {

  403.                     char ch2 = ncName.charAt(i);

  404.                     if ( !XMLChar.isLowSurrogate(ch2) || 

  405.                          !isXML11NCName(XMLChar.supplemental(ch, ch2)) ) {

  406.                         return false;

  407.                     }

  408.                 }

  409.                 else {

  410.                     return false;

  411.                 }

  412.             }

  413.             ++i;

  414.         }

  415.         return true;

  416.     } // isXML11ValidNCName(String):boolean

  417. 

  418.     /*

  419.      * [7] Nmtoken ::= (NameChar)+

  420.      */

  421.     /**

  422.      * Check to see if a string is a valid Nmtoken according to [7]

  423.      * in the XML 1.1 Recommendation

  424.      *

  425.      * @param nmtoken string to check

  426.      * @return true if nmtoken is a valid Nmtoken 

  427.      */

  428.     public static boolean isXML11ValidNmtoken(String nmtoken) {

  429.         int length = nmtoken.length();

  430.         if (length == 0)

  431.             return false;

  432.         for (int i = 0; i < length; ++i ) {

  433.             char ch = nmtoken.charAt(i);

  434.             if( !isXML11Name(ch) ) {

  435.                 if ( ++i < length && isXML11NameHighSurrogate(ch) ) {

  436.                     char ch2 = nmtoken.charAt(i);

  437.                     if ( !XMLChar.isLowSurrogate(ch2) || 

  438.                          !isXML11Name(XMLChar.supplemental(ch, ch2)) ) {

  439.                         return false;

  440.                     }

  441.                 }

  442.                 else {

  443.                     return false;

  444.                 }

  445.             }

  446.         }

  447.         return true;

  448.     } // isXML11ValidName(String):boolean

  449. 

  450. } // class XML11Char

  451.