1. /*

  2.  * The Apache Software License, Version 1.1

  3.  *

  4.  *

  5.  * Copyright (c) 1999-2003 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.impl.xpath.regex;

  59. 

  60. import java.util.Hashtable;

  61. import java.util.Locale;

  62. 

  63. /**

  64.  * A regular expression parser for the XML Shema.

  65.  *

  66.  * @author TAMURA Kent <kent@trl.ibm.co.jp>

  67.  * @version $Id: ParserForXMLSchema.java,v 1.5 2003/03/24 23:37:55 sandygao Exp $

  68.  */

  69. class ParserForXMLSchema extends RegexParser {

  70. 

  71.     public ParserForXMLSchema() {

  72.         //this.setLocale(Locale.getDefault());

  73.     }

  74.     public ParserForXMLSchema(Locale locale) {

  75.         //this.setLocale(locale);

  76.     }

  77. 

  78.     Token processCaret() throws ParseException {

  79.         this.next();

  80.         return Token.createChar('^');

  81.     }

  82.     Token processDollar() throws ParseException {

  83.         this.next();

  84.         return Token.createChar('$');

  85.      }

  86.     Token processLookahead() throws ParseException {

  87.         throw ex("parser.process.1", this.offset);

  88.     }

  89.     Token processNegativelookahead() throws ParseException {

  90.         throw ex("parser.process.1", this.offset);

  91.     }

  92.     Token processLookbehind() throws ParseException {

  93.         throw ex("parser.process.1", this.offset);

  94.     }

  95.     Token processNegativelookbehind() throws ParseException {

  96.         throw ex("parser.process.1", this.offset);

  97.     }

  98.     Token processBacksolidus_A() throws ParseException {

  99.         throw ex("parser.process.1", this.offset);

  100.     }

  101.     Token processBacksolidus_Z() throws ParseException {

  102.         throw ex("parser.process.1", this.offset);

  103.     }

  104.     Token processBacksolidus_z() throws ParseException {

  105.         throw ex("parser.process.1", this.offset);

  106.     }

  107.     Token processBacksolidus_b() throws ParseException {

  108.         throw ex("parser.process.1", this.offset);

  109.     }

  110.     Token processBacksolidus_B() throws ParseException {

  111.         throw ex("parser.process.1", this.offset);

  112.     }

  113.     Token processBacksolidus_lt() throws ParseException {

  114.         throw ex("parser.process.1", this.offset);

  115.     }

  116.     Token processBacksolidus_gt() throws ParseException {

  117.         throw ex("parser.process.1", this.offset);

  118.     }

  119.     Token processStar(Token tok) throws ParseException {

  120.         this.next();

  121.         return Token.createClosure(tok);

  122.     }

  123.     Token processPlus(Token tok) throws ParseException {

  124.         // X+ -> XX*

  125.         this.next();

  126.         return Token.createConcat(tok, Token.createClosure(tok));

  127.     }

  128.     Token processQuestion(Token tok) throws ParseException {

  129.         // X? -> X|

  130.         this.next();

  131.         Token par = Token.createUnion();

  132.         par.addChild(tok);

  133.         par.addChild(Token.createEmpty());

  134.         return par;

  135.     }

  136.     boolean checkQuestion(int off) {

  137.         return false;

  138.     }

  139.     Token processParen() throws ParseException {

  140.         this.next();

  141.         Token tok = Token.createParen(this.parseRegex(), 0);

  142.         if (this.read() != super.T_RPAREN)  throw ex("parser.factor.1", this.offset-1);

  143.         this.next();                            // Skips ')'

  144.         return tok;

  145.     }

  146.     Token processParen2() throws ParseException {

  147.         throw ex("parser.process.1", this.offset);

  148.     }

  149.     Token processCondition() throws ParseException {

  150.         throw ex("parser.process.1", this.offset);

  151.     }

  152.     Token processModifiers() throws ParseException {

  153.         throw ex("parser.process.1", this.offset);

  154.     }

  155.     Token processIndependent() throws ParseException {

  156.         throw ex("parser.process.1", this.offset);

  157.     }

  158.     Token processBacksolidus_c() throws ParseException {

  159.         this.next();

  160.         return this.getTokenForShorthand('c');

  161.     }

  162.     Token processBacksolidus_C() throws ParseException {

  163.         this.next();

  164.         return this.getTokenForShorthand('C');

  165.     }

  166.     Token processBacksolidus_i() throws ParseException {

  167.         this.next();

  168.         return this.getTokenForShorthand('i');

  169.     }

  170.     Token processBacksolidus_I() throws ParseException {

  171.         this.next();

  172.         return this.getTokenForShorthand('I');

  173.     }

  174.     Token processBacksolidus_g() throws ParseException {

  175.         throw this.ex("parser.process.1", this.offset-2);

  176.     }

  177.     Token processBacksolidus_X() throws ParseException {

  178.         throw ex("parser.process.1", this.offset-2);

  179.     }

  180.     Token processBackreference() throws ParseException {

  181.         throw ex("parser.process.1", this.offset-4);

  182.     }

  183. 

  184.     int processCIinCharacterClass(RangeToken tok, int c) {

  185.         tok.mergeRanges(this.getTokenForShorthand(c));

  186.         return -1;

  187.     }

  188. 

  189. 

  190.     /**

  191.      * Parses a character-class-expression, not a character-class-escape.

  192.      *

  193.      * c-c-expression   ::= '[' c-group ']'

  194.      * c-group          ::= positive-c-group | negative-c-group | c-c-subtraction

  195.      * positive-c-group ::= (c-range | c-c-escape)+

  196.      * negative-c-group ::= '^' positive-c-group

  197.      * c-c-subtraction  ::= (positive-c-group | negative-c-group) subtraction

  198.      * subtraction      ::= '-' c-c-expression

  199.      * c-range          ::= single-range | from-to-range

  200.      * single-range     ::= multi-c-escape | category-c-escape | block-c-escape | <any XML char>

  201.      * cc-normal-c      ::= <any character except [, ], \>

  202.      * from-to-range    ::= cc-normal-c '-' cc-normal-c

  203.      *

  204.      * @param useNrage Ignored.

  205.      * @return This returns no NrageToken.

  206.      */

  207.     protected RangeToken parseCharacterClass(boolean useNrange) throws ParseException {

  208.         this.setContext(S_INBRACKETS);

  209.         this.next();                            // '['

  210.         boolean nrange = false;

  211.         RangeToken base = null;

  212.         RangeToken tok;

  213.         if (this.read() == T_CHAR && this.chardata == '^') {

  214.             nrange = true;

  215.             this.next();                        // '^'

  216.             base = Token.createRange();

  217.             base.addRange(0, Token.UTF16_MAX);

  218.             tok = Token.createRange();

  219.         } else {

  220.             tok = Token.createRange();

  221.         }

  222.         int type;

  223.         boolean firstloop = true;

  224.         while ((type = this.read()) != T_EOF) { // Don't use 'cotinue' for this loop.

  225.             // single-range | from-to-range | subtraction

  226.             if (type == T_CHAR && this.chardata == ']' && !firstloop) {

  227.                 if (nrange) {

  228.                     base.subtractRanges(tok);

  229.                     tok = base;

  230.                 }

  231.                 break;

  232.             }

  233.             int c = this.chardata;

  234.             boolean end = false;

  235.             if (type == T_BACKSOLIDUS) {

  236.                 switch (c) {

  237.                   case 'd':  case 'D':

  238.                   case 'w':  case 'W':

  239.                   case 's':  case 'S':

  240.                     tok.mergeRanges(this.getTokenForShorthand(c));

  241.                     end = true;

  242.                     break;

  243. 

  244.                   case 'i':  case 'I':

  245.                   case 'c':  case 'C':

  246.                     c = this.processCIinCharacterClass(tok, c);

  247.                     if (c < 0)  end = true;

  248.                     break;

  249.                     

  250.                   case 'p':

  251.                   case 'P':

  252.                     int pstart = this.offset;

  253.                     RangeToken tok2 = this.processBacksolidus_pP(c);

  254.                     if (tok2 == null)  throw this.ex("parser.atom.5", pstart);

  255.                     tok.mergeRanges(tok2);

  256.                     end = true;

  257.                     break;

  258. 

  259.                   default:

  260.                     c = this.decodeEscaped();

  261.                 } // \ + c

  262.             } // backsolidus

  263.             else if (type == T_XMLSCHEMA_CC_SUBTRACTION && !firstloop) {

  264.                                                 // Subraction

  265.                 if (nrange) {

  266.                     base.subtractRanges(tok);

  267.                     tok = base;

  268.                 }

  269.                 RangeToken range2 = this.parseCharacterClass(false);

  270.                 tok.subtractRanges(range2);

  271.                 if (this.read() != T_CHAR || this.chardata != ']')

  272.                     throw this.ex("parser.cc.5", this.offset);

  273.                 break;                          // Exit this loop

  274.             }

  275.             this.next();

  276.             if (!end) {                         // if not shorthands...

  277.                 if (type == T_CHAR) {

  278.                     if (c == '[')  throw this.ex("parser.cc.6", this.offset-2);

  279.                     if (c == ']')  throw this.ex("parser.cc.7", this.offset-2);

  280.                     if (c == '-')  throw this.ex("parser.cc.8", this.offset-2);

  281.                 }

  282.                 if (this.read() != T_CHAR || this.chardata != '-') { // Here is no '-'.

  283.                     tok.addRange(c, c);

  284.                 } else {                        // Found '-'

  285.                                                 // Is this '-' is a from-to token??

  286.                     this.next(); // Skips '-'

  287.                     if ((type = this.read()) == T_EOF)  throw this.ex("parser.cc.2", this.offset);

  288.                                                 // c '-' ']' -> '-' is a single-range.

  289.                     if ((type == T_CHAR && this.chardata == ']')

  290.                         || type == T_XMLSCHEMA_CC_SUBTRACTION) {

  291.                         throw this.ex("parser.cc.8", this.offset-1);

  292.                     } else {

  293.                         int rangeend = this.chardata;

  294.                         if (type == T_CHAR) {

  295.                             if (rangeend == '[')  throw this.ex("parser.cc.6", this.offset-1);

  296.                             if (rangeend == ']')  throw this.ex("parser.cc.7", this.offset-1);

  297.                             if (rangeend == '-')  throw this.ex("parser.cc.8", this.offset-2);

  298.                         }

  299.                         else if (type == T_BACKSOLIDUS)

  300.                             rangeend = this.decodeEscaped();

  301.                         this.next();

  302. 

  303.                         if (c > rangeend)  throw this.ex("parser.ope.3", this.offset-1);

  304.                         tok.addRange(c, rangeend);

  305.                     }

  306.                 }

  307.             }

  308.             firstloop = false;

  309.         }

  310.         if (this.read() == T_EOF)

  311.             throw this.ex("parser.cc.2", this.offset);

  312.         tok.sortRanges();

  313.         tok.compactRanges();

  314.         //tok.dumpRanges();

  315.         this.setContext(S_NORMAL);

  316.         this.next();                    // Skips ']'

  317. 

  318.         return tok;

  319.     }

  320. 

  321.     protected RangeToken parseSetOperations() throws ParseException {

  322.         throw this.ex("parser.process.1", this.offset);

  323.     }

  324.  

  325.     Token getTokenForShorthand(int ch) {

  326.         switch (ch) {

  327.           case 'd':

  328.             return ParserForXMLSchema.getRange("xml:isDigit", true);

  329.           case 'D':

  330.             return ParserForXMLSchema.getRange("xml:isDigit", false);

  331.           case 'w':

  332.             return ParserForXMLSchema.getRange("xml:isWord", true);

  333.           case 'W':

  334.             return ParserForXMLSchema.getRange("xml:isWord", false);

  335.           case 's':

  336.             return ParserForXMLSchema.getRange("xml:isSpace", true);

  337.           case 'S':

  338.             return ParserForXMLSchema.getRange("xml:isSpace", false);

  339.           case 'c':

  340.             return ParserForXMLSchema.getRange("xml:isNameChar", true);

  341.           case 'C':

  342.             return ParserForXMLSchema.getRange("xml:isNameChar", false);

  343.           case 'i':

  344.             return ParserForXMLSchema.getRange("xml:isInitialNameChar", true);

  345.           case 'I':

  346.             return ParserForXMLSchema.getRange("xml:isInitialNameChar", false);

  347.           default:

  348.             throw new RuntimeException("Internal Error: shorthands: \\u"+Integer.toString(ch, 16));

  349.         }

  350.     }

  351.     int decodeEscaped() throws ParseException {

  352.         if (this.read() != T_BACKSOLIDUS)  throw ex("parser.next.1", this.offset-1);

  353.         int c = this.chardata;

  354.         switch (c) {

  355.           case 'n':  c = '\n';  break; // LINE FEED U+000A

  356.           case 'r':  c = '\r';  break; // CRRIAGE RETURN U+000D

  357.           case 't':  c = '\t';  break; // HORIZONTAL TABULATION U+0009

  358.           case '\\':

  359.           case '|':

  360.           case '.':

  361.           case '^':

  362.           case '-':

  363.           case '?':

  364.           case '*':

  365.           case '+':

  366.           case '{':

  367.           case '}':

  368.           case '(':

  369.           case ')':

  370.           case '[':

  371.           case ']':

  372.             break; // return actucal char

  373.           default:

  374.             throw ex("parser.process.1", this.offset-2);

  375.         }

  376.         return c;

  377.     }

  378. 

  379.     static private Hashtable ranges = null;

  380.     static private Hashtable ranges2 = null;

  381.     static synchronized protected RangeToken getRange(String name, boolean positive) {

  382.         if (ranges == null) {

  383.             ranges = new Hashtable();

  384.             ranges2 = new Hashtable();

  385. 

  386.             Token tok = Token.createRange();

  387.             setupRange(tok, SPACES);

  388.             ranges.put("xml:isSpace", tok);

  389.             ranges2.put("xml:isSpace", Token.complementRanges(tok));

  390. 

  391.             tok = Token.createRange();

  392.             setupRange(tok, DIGITS);

  393.             ranges.put("xml:isDigit", tok);

  394.             ranges2.put("xml:isDigit", Token.complementRanges(tok));

  395. 

  396.             tok = Token.createRange();

  397.             setupRange(tok, DIGITS);

  398.             ranges.put("xml:isDigit", tok);

  399.             ranges2.put("xml:isDigit", Token.complementRanges(tok));

  400. 

  401.             tok = Token.createRange();

  402.             setupRange(tok, LETTERS);

  403.             tok.mergeRanges((Token)ranges.get("xml:isDigit"));

  404.             ranges.put("xml:isWord", tok);

  405.             ranges2.put("xml:isWord", Token.complementRanges(tok));

  406. 

  407.             tok = Token.createRange();

  408.             setupRange(tok, NAMECHARS);

  409.             ranges.put("xml:isNameChar", tok);

  410.             ranges2.put("xml:isNameChar", Token.complementRanges(tok));

  411. 

  412.             tok = Token.createRange();

  413.             setupRange(tok, LETTERS);

  414.             tok.addRange('_', '_');

  415.             tok.addRange(':', ':');

  416.             ranges.put("xml:isInitialNameChar", tok);

  417.             ranges2.put("xml:isInitialNameChar", Token.complementRanges(tok));

  418.         }

  419.         RangeToken tok = positive ? (RangeToken)ranges.get(name)

  420.             : (RangeToken)ranges2.get(name);

  421.         return tok;

  422.     }

  423. 

  424.     static void setupRange(Token range, String src) {

  425.         int len = src.length();

  426.         for (int i = 0;  i < len;  i += 2)

  427.             range.addRange(src.charAt(i), src.charAt(i+1));

  428.     }

  429. 

  430.     private static final String SPACES = "\t\n\r\r  ";

  431.     private static final String NAMECHARS =

  432.         "\u002d\u002e\u0030\u003a\u0041\u005a\u005f\u005f\u0061\u007a\u00b7\u00b7\u00c0\u00d6"

  433.         +"\u00d8\u00f6\u00f8\u0131\u0134\u013e\u0141\u0148\u014a\u017e\u0180\u01c3\u01cd\u01f0"

  434.         +"\u01f4\u01f5\u01fa\u0217\u0250\u02a8\u02bb\u02c1\u02d0\u02d1\u0300\u0345\u0360\u0361"

  435.         +"\u0386\u038a\u038c\u038c\u038e\u03a1\u03a3\u03ce\u03d0\u03d6\u03da\u03da\u03dc\u03dc"

  436.         +"\u03de\u03de\u03e0\u03e0\u03e2\u03f3\u0401\u040c\u040e\u044f\u0451\u045c\u045e\u0481"

  437.         +"\u0483\u0486\u0490\u04c4\u04c7\u04c8\u04cb\u04cc\u04d0\u04eb\u04ee\u04f5\u04f8\u04f9"

  438.         +"\u0531\u0556\u0559\u0559\u0561\u0586\u0591\u05a1\u05a3\u05b9\u05bb\u05bd\u05bf\u05bf"

  439.         +"\u05c1\u05c2\u05c4\u05c4\u05d0\u05ea\u05f0\u05f2\u0621\u063a\u0640\u0652\u0660\u0669"

  440.         +"\u0670\u06b7\u06ba\u06be\u06c0\u06ce\u06d0\u06d3\u06d5\u06e8\u06ea\u06ed\u06f0\u06f9"

  441.         +"\u0901\u0903\u0905\u0939\u093c\u094d\u0951\u0954\u0958\u0963\u0966\u096f\u0981\u0983"

  442.         +"\u0985\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b2\u09b2\u09b6\u09b9\u09bc\u09bc"

  443.         +"\u09be\u09c4\u09c7\u09c8\u09cb\u09cd\u09d7\u09d7\u09dc\u09dd\u09df\u09e3\u09e6\u09f1"

  444.         +"\u0a02\u0a02\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a\u0a30\u0a32\u0a33\u0a35\u0a36"

  445.         +"\u0a38\u0a39\u0a3c\u0a3c\u0a3e\u0a42\u0a47\u0a48\u0a4b\u0a4d\u0a59\u0a5c\u0a5e\u0a5e"

  446.         +"\u0a66\u0a74\u0a81\u0a83\u0a85\u0a8b\u0a8d\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0"

  447.         +"\u0ab2\u0ab3\u0ab5\u0ab9\u0abc\u0ac5\u0ac7\u0ac9\u0acb\u0acd\u0ae0\u0ae0\u0ae6\u0aef"

  448.         +"\u0b01\u0b03\u0b05\u0b0c\u0b0f\u0b10\u0b13\u0b28\u0b2a\u0b30\u0b32\u0b33\u0b36\u0b39"

  449.         +"\u0b3c\u0b43\u0b47\u0b48\u0b4b\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f\u0b61\u0b66\u0b6f"

  450.         +"\u0b82\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95\u0b99\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f"

  451.         +"\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb5\u0bb7\u0bb9\u0bbe\u0bc2\u0bc6\u0bc8\u0bca\u0bcd"

  452.         +"\u0bd7\u0bd7\u0be7\u0bef\u0c01\u0c03\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c33"

  453.         +"\u0c35\u0c39\u0c3e\u0c44\u0c46\u0c48\u0c4a\u0c4d\u0c55\u0c56\u0c60\u0c61\u0c66\u0c6f"

  454.         +"\u0c82\u0c83\u0c85\u0c8c\u0c8e\u0c90\u0c92\u0ca8\u0caa\u0cb3\u0cb5\u0cb9\u0cbe\u0cc4"

  455.         +"\u0cc6\u0cc8\u0cca\u0ccd\u0cd5\u0cd6\u0cde\u0cde\u0ce0\u0ce1\u0ce6\u0cef\u0d02\u0d03"

  456.         +"\u0d05\u0d0c\u0d0e\u0d10\u0d12\u0d28\u0d2a\u0d39\u0d3e\u0d43\u0d46\u0d48\u0d4a\u0d4d"

  457.         +"\u0d57\u0d57\u0d60\u0d61\u0d66\u0d6f\u0e01\u0e2e\u0e30\u0e3a\u0e40\u0e4e\u0e50\u0e59"

  458.         +"\u0e81\u0e82\u0e84\u0e84\u0e87\u0e88\u0e8a\u0e8a\u0e8d\u0e8d\u0e94\u0e97\u0e99\u0e9f"

  459.         +"\u0ea1\u0ea3\u0ea5\u0ea5\u0ea7\u0ea7\u0eaa\u0eab\u0ead\u0eae\u0eb0\u0eb9\u0ebb\u0ebd"

  460.         +"\u0ec0\u0ec4\u0ec6\u0ec6\u0ec8\u0ecd\u0ed0\u0ed9\u0f18\u0f19\u0f20\u0f29\u0f35\u0f35"

  461.         +"\u0f37\u0f37\u0f39\u0f39\u0f3e\u0f47\u0f49\u0f69\u0f71\u0f84\u0f86\u0f8b\u0f90\u0f95"

  462.         +"\u0f97\u0f97\u0f99\u0fad\u0fb1\u0fb7\u0fb9\u0fb9\u10a0\u10c5\u10d0\u10f6\u1100\u1100"

  463.         +"\u1102\u1103\u1105\u1107\u1109\u1109\u110b\u110c\u110e\u1112\u113c\u113c\u113e\u113e"

  464.         +"\u1140\u1140\u114c\u114c\u114e\u114e\u1150\u1150\u1154\u1155\u1159\u1159\u115f\u1161"

  465.         +"\u1163\u1163\u1165\u1165\u1167\u1167\u1169\u1169\u116d\u116e\u1172\u1173\u1175\u1175"

  466.         +"\u119e\u119e\u11a8\u11a8\u11ab\u11ab\u11ae\u11af\u11b7\u11b8\u11ba\u11ba\u11bc\u11c2"

  467.         +"\u11eb\u11eb\u11f0\u11f0\u11f9\u11f9\u1e00\u1e9b\u1ea0\u1ef9\u1f00\u1f15\u1f18\u1f1d"

  468.         +"\u1f20\u1f45\u1f48\u1f4d\u1f50\u1f57\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f\u1f7d"

  469.         +"\u1f80\u1fb4\u1fb6\u1fbc\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0\u1fd3\u1fd6\u1fdb"

  470.         +"\u1fe0\u1fec\u1ff2\u1ff4\u1ff6\u1ffc\u20d0\u20dc\u20e1\u20e1\u2126\u2126\u212a\u212b"

  471.         +"\u212e\u212e\u2180\u2182\u3005\u3005\u3007\u3007\u3021\u302f\u3031\u3035\u3041\u3094"

  472.         +"\u3099\u309a\u309d\u309e\u30a1\u30fa\u30fc\u30fe\u3105\u312c\u4e00\u9fa5\uac00\ud7a3"

  473.         +"";

  474.     private static final String LETTERS =

  475.         "\u0041\u005a\u0061\u007a\u00c0\u00d6\u00d8\u00f6\u00f8\u0131\u0134\u013e\u0141\u0148"

  476.         +"\u014a\u017e\u0180\u01c3\u01cd\u01f0\u01f4\u01f5\u01fa\u0217\u0250\u02a8\u02bb\u02c1"

  477.         +"\u0386\u0386\u0388\u038a\u038c\u038c\u038e\u03a1\u03a3\u03ce\u03d0\u03d6\u03da\u03da"

  478.         +"\u03dc\u03dc\u03de\u03de\u03e0\u03e0\u03e2\u03f3\u0401\u040c\u040e\u044f\u0451\u045c"

  479.         +"\u045e\u0481\u0490\u04c4\u04c7\u04c8\u04cb\u04cc\u04d0\u04eb\u04ee\u04f5\u04f8\u04f9"

  480.         +"\u0531\u0556\u0559\u0559\u0561\u0586\u05d0\u05ea\u05f0\u05f2\u0621\u063a\u0641\u064a"

  481.         +"\u0671\u06b7\u06ba\u06be\u06c0\u06ce\u06d0\u06d3\u06d5\u06d5\u06e5\u06e6\u0905\u0939"

  482.         +"\u093d\u093d\u0958\u0961\u0985\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b2\u09b2"

  483.         +"\u09b6\u09b9\u09dc\u09dd\u09df\u09e1\u09f0\u09f1\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28"

  484.         +"\u0a2a\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a5e\u0a5e\u0a72\u0a74"

  485.         +"\u0a85\u0a8b\u0a8d\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5\u0ab9"

  486.         +"\u0abd\u0abd\u0ae0\u0ae0\u0b05\u0b0c\u0b0f\u0b10\u0b13\u0b28\u0b2a\u0b30\u0b32\u0b33"

  487.         +"\u0b36\u0b39\u0b3d\u0b3d\u0b5c\u0b5d\u0b5f\u0b61\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95"

  488.         +"\u0b99\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb5\u0bb7\u0bb9"

  489.         +"\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c33\u0c35\u0c39\u0c60\u0c61\u0c85\u0c8c"

  490.         +"\u0c8e\u0c90\u0c92\u0ca8\u0caa\u0cb3\u0cb5\u0cb9\u0cde\u0cde\u0ce0\u0ce1\u0d05\u0d0c"

  491.         +"\u0d0e\u0d10\u0d12\u0d28\u0d2a\u0d39\u0d60\u0d61\u0e01\u0e2e\u0e30\u0e30\u0e32\u0e33"

  492.         +"\u0e40\u0e45\u0e81\u0e82\u0e84\u0e84\u0e87\u0e88\u0e8a\u0e8a\u0e8d\u0e8d\u0e94\u0e97"

  493.         +"\u0e99\u0e9f\u0ea1\u0ea3\u0ea5\u0ea5\u0ea7\u0ea7\u0eaa\u0eab\u0ead\u0eae\u0eb0\u0eb0"

  494.         +"\u0eb2\u0eb3\u0ebd\u0ebd\u0ec0\u0ec4\u0f40\u0f47\u0f49\u0f69\u10a0\u10c5\u10d0\u10f6"

  495.         +"\u1100\u1100\u1102\u1103\u1105\u1107\u1109\u1109\u110b\u110c\u110e\u1112\u113c\u113c"

  496.         +"\u113e\u113e\u1140\u1140\u114c\u114c\u114e\u114e\u1150\u1150\u1154\u1155\u1159\u1159"

  497.         +"\u115f\u1161\u1163\u1163\u1165\u1165\u1167\u1167\u1169\u1169\u116d\u116e\u1172\u1173"

  498.         +"\u1175\u1175\u119e\u119e\u11a8\u11a8\u11ab\u11ab\u11ae\u11af\u11b7\u11b8\u11ba\u11ba"

  499.         +"\u11bc\u11c2\u11eb\u11eb\u11f0\u11f0\u11f9\u11f9\u1e00\u1e9b\u1ea0\u1ef9\u1f00\u1f15"

  500.         +"\u1f18\u1f1d\u1f20\u1f45\u1f48\u1f4d\u1f50\u1f57\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d"

  501.         +"\u1f5f\u1f7d\u1f80\u1fb4\u1fb6\u1fbc\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0\u1fd3"

  502.         +"\u1fd6\u1fdb\u1fe0\u1fec\u1ff2\u1ff4\u1ff6\u1ffc\u2126\u2126\u212a\u212b\u212e\u212e"

  503.         +"\u2180\u2182\u3007\u3007\u3021\u3029\u3041\u3094\u30a1\u30fa\u3105\u312c\u4e00\u9fa5"

  504.         +"\uac00\ud7a3";

  505.     private static final String DIGITS =

  506.         "\u0030\u0039\u0660\u0669\u06F0\u06F9\u0966\u096F\u09E6\u09EF\u0A66\u0A6F\u0AE6\u0AEF"

  507.         +"\u0B66\u0B6F\u0BE7\u0BEF\u0C66\u0C6F\u0CE6\u0CEF\u0D66\u0D6F\u0E50\u0E59\u0ED0\u0ED9"

  508.         +"\u0F20\u0F29";

  509. }