KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > enhydra > apache > xerces > utils > regex > ParserForXMLSchema


1 /*
2  * The Apache Software License, Version 1.1
3  *
4  *
5  * Copyright (c) 1999,2000 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 org.enhydra.apache.xerces.utils.regex;
59
60
61
62 import java.util.Hashtable JavaDoc;
63 import java.util.Locale JavaDoc;
64
65 /**
66  * A regular expression parser for the XML Shema.
67  *
68  * @author TAMURA Kent &lt;kent@trl.ibm.co.jp&gt;
69  */

70 class ParserForXMLSchema extends RegexParser {
71
72     public ParserForXMLSchema() {
73         //this.setLocale(Locale.getDefault());
74
}
75     public ParserForXMLSchema(Locale JavaDoc locale) {
76         //this.setLocale(locale);
77
}
78
79     Token processCaret() throws ParseException {
80         this.next();
81         return Token.createChar('^');
82     }
83     Token processDollar() throws ParseException {
84         this.next();
85         return Token.createChar('$');
86      }
87     Token processLookahead() throws ParseException {
88         throw ex("parser.process.1", this.offset);
89     }
90     Token processNegativelookahead() throws ParseException {
91         throw ex("parser.process.1", this.offset);
92     }
93     Token processLookbehind() throws ParseException {
94         throw ex("parser.process.1", this.offset);
95     }
96     Token processNegativelookbehind() throws ParseException {
97         throw ex("parser.process.1", this.offset);
98     }
99     Token processBacksolidus_A() throws ParseException {
100         throw ex("parser.process.1", this.offset);
101     }
102     Token processBacksolidus_Z() throws ParseException {
103         throw ex("parser.process.1", this.offset);
104     }
105     Token processBacksolidus_z() throws ParseException {
106         throw ex("parser.process.1", this.offset);
107     }
108     Token processBacksolidus_b() throws ParseException {
109         throw ex("parser.process.1", this.offset);
110     }
111     Token processBacksolidus_B() throws ParseException {
112         throw ex("parser.process.1", this.offset);
113     }
114     Token processBacksolidus_lt() throws ParseException {
115         throw ex("parser.process.1", this.offset);
116     }
117     Token processBacksolidus_gt() throws ParseException {
118         throw ex("parser.process.1", this.offset);
119     }
120     Token processStar(Token tok) throws ParseException {
121         this.next();
122         return Token.createClosure(tok);
123     }
124     Token processPlus(Token tok) throws ParseException {
125         // X+ -> XX*
126
this.next();
127         return Token.createConcat(tok, Token.createClosure(tok));
128     }
129     Token processQuestion(Token tok) throws ParseException {
130         // X? -> X|
131
this.next();
132         Token par = Token.createUnion();
133         par.addChild(tok);
134         par.addChild(Token.createEmpty());
135         return par;
136     }
137     boolean checkQuestion(int off) {
138         return false;
139     }
140     Token processParen() throws ParseException {
141         this.next();
142         Token tok = Token.createParen(this.parseRegex(), 0);
143         if (this.read() != super.T_RPAREN) throw ex("parser.factor.1", this.offset-1);
144         this.next(); // Skips ')'
145
return tok;
146     }
147     Token processParen2() throws ParseException {
148         throw ex("parser.process.1", this.offset);
149     }
150     Token processCondition() throws ParseException {
151         throw ex("parser.process.1", this.offset);
152     }
153     Token processModifiers() throws ParseException {
154         throw ex("parser.process.1", this.offset);
155     }
156     Token processIndependent() throws ParseException {
157         throw ex("parser.process.1", this.offset);
158     }
159     Token processBacksolidus_c() throws ParseException {
160         this.next();
161         return this.getTokenForShorthand('c');
162     }
163     Token processBacksolidus_C() throws ParseException {
164         this.next();
165         return this.getTokenForShorthand('C');
166     }
167     Token processBacksolidus_i() throws ParseException {
168         this.next();
169         return this.getTokenForShorthand('i');
170     }
171     Token processBacksolidus_I() throws ParseException {
172         this.next();
173         return this.getTokenForShorthand('I');
174     }
175     Token processBacksolidus_g() throws ParseException {
176         throw this.ex("parser.process.1", this.offset-2);
177     }
178     Token processBacksolidus_X() throws ParseException {
179         throw ex("parser.process.1", this.offset-2);
180     }
181     Token processBackreference() throws ParseException {
182         throw ex("parser.process.1", this.offset-4);
183     }
184
185     int processCIinCharacterClass(RangeToken tok, int c) {
186         tok.mergeRanges(this.getTokenForShorthand(c));
187         return -1;
188     }
189
190
191     /**
192      * Parses a character-class-expression, not a character-class-escape.
193      *
194      * c-c-expression ::= '[' c-group ']'
195      * c-group ::= positive-c-group | negative-c-group | c-c-subtraction
196      * positive-c-group ::= (c-range | c-c-escape)+
197      * negative-c-group ::= '^' positive-c-group
198      * c-c-subtraction ::= (positive-c-group | negative-c-group) subtraction
199      * subtraction ::= '-' c-c-expression
200      * c-range ::= single-range | from-to-range
201      * single-range ::= multi-c-escape | category-c-escape | block-c-escape | <any XML char>
202      * cc-normal-c ::= <any character except [, ], \>
203      * from-to-range ::= cc-normal-c '-' cc-normal-c
204      *
205      * @param useNrage Ignored.
206      * @return This returns no NrageToken.
207      */

208     protected RangeToken parseCharacterClass(boolean useNrange) throws ParseException {
209         this.setContext(S_INBRACKETS);
210         this.next(); // '['
211
boolean nrange = false;
212         RangeToken base = null;
213         RangeToken tok;
214         if (this.read() == T_CHAR && this.chardata == '^') {
215             nrange = true;
216             this.next(); // '^'
217
base = Token.createRange();
218             base.addRange(0, Token.UTF16_MAX);
219             tok = Token.createRange();
220         } else {
221             tok = Token.createRange();
222         }
223         int type;
224         boolean firstloop = true;
225         while ((type = this.read()) != T_EOF) { // Don't use 'cotinue' for this loop.
226
// single-range | from-to-range | subtraction
227
if (type == T_CHAR && this.chardata == ']' && !firstloop) {
228                 if (nrange) {
229                     base.subtractRanges(tok);
230                     tok = base;
231                 }
232                 break;
233             }
234             int c = this.chardata;
235             boolean end = false;
236             if (type == T_BACKSOLIDUS) {
237                 switch (c) {
238                   case 'd': case 'D':
239                   case 'w': case 'W':
240                   case 's': case 'S':
241                     tok.mergeRanges(this.getTokenForShorthand(c));
242                     end = true;
243                     break;
244
245                   case 'i': case 'I':
246                   case 'c': case 'C':
247                     c = this.processCIinCharacterClass(tok, c);
248                     if (c < 0) end = true;
249                     break;
250                     
251                   case 'p':
252                   case 'P':
253                     int pstart = this.offset;
254                     RangeToken tok2 = this.processBacksolidus_pP(c);
255                     if (tok2 == null) throw this.ex("parser.atom.5", pstart);
256                     tok.mergeRanges(tok2);
257                     end = true;
258                     break;
259
260                   default:
261                     c = this.decodeEscaped();
262                 } // \ + c
263
} // backsolidus
264
else if (type == T_XMLSCHEMA_CC_SUBTRACTION && !firstloop) {
265                                                 // Subraction
266
if (nrange) {
267                     base.subtractRanges(tok);
268                     tok = base;
269                 }
270                 RangeToken range2 = this.parseCharacterClass(false);
271                 tok.subtractRanges(range2);
272                 if (this.read() != T_CHAR || this.chardata != ']')
273                     throw this.ex("parser.cc.5", this.offset);
274                 break; // Exit this loop
275
}
276             
277             this.next();
278             if (!end) { // if not shorthands...
279
if (type == T_CHAR) {
280                     if (c == '[') throw this.ex("parser.cc.6", this.offset-2);
281                     if (c == ']') throw this.ex("parser.cc.7", this.offset-2);
282                 }
283                 if (this.read() != T_CHAR || this.chardata != '-') { // Here is no '-'.
284
tok.addRange(c, c);
285                 } else { // Found '-'
286
// Is this '-' is a from-to token??
287
this.next(); // Skips '-'
288
if ((type = this.read()) == T_EOF) throw this.ex("parser.cc.2", this.offset);
289                                                 // c '-' ']' -> '-' is a single-range.
290
if (type == T_CHAR && this.chardata == ']') {
291                         tok.addRange(c, c);
292                         tok.addRange('-', '-');
293                     }
294                                                 // c '-' '-[' -> '-' is a single-range.
295
else if (type == T_XMLSCHEMA_CC_SUBTRACTION) {
296                         tok.addRange(c, c);
297                         tok.addRange('-', '-');
298                     } else {
299                         int rangeend = this.chardata;
300                         if (type == T_CHAR) {
301                             if (rangeend == '[') throw this.ex("parser.cc.6", this.offset-1);
302                             if (rangeend == ']') throw this.ex("parser.cc.7", this.offset-1);
303                             if (rangeend == '-') throw new RuntimeException JavaDoc("Invalid character '-' in the middle of positive character range");
304                         }
305                         if (type == T_BACKSOLIDUS)
306                             rangeend = this.decodeEscaped();
307                         this.next();
308                         if (c > rangeend) {
309                            throw new RuntimeException JavaDoc("The range end code point '"+(char) rangeend
310                                                       + "' is less than the start code point '" +(char)c +"'");
311                         }
312                         tok.addRange(c, rangeend);
313                     }
314                 }
315             }
316             firstloop = false;
317         }
318         if (this.read() == T_EOF)
319             throw this.ex("parser.cc.2", this.offset);
320         tok.sortRanges();
321         tok.compactRanges();
322         //tok.dumpRanges();
323
this.setContext(S_NORMAL);
324         this.next(); // Skips ']'
325

326         return tok;
327     }
328
329     protected RangeToken parseSetOperations() throws ParseException {
330         throw this.ex("parser.process.1", this.offset);
331     }
332  
333     Token getTokenForShorthand(int ch) {
334         switch (ch) {
335           case 'd':
336             return ParserForXMLSchema.getRange("xml:isDigit", true);
337           case 'D':
338             return ParserForXMLSchema.getRange("xml:isDigit", false);
339           case 'w':
340             return ParserForXMLSchema.getRange("xml:isWord", true);
341           case 'W':
342             return ParserForXMLSchema.getRange("xml:isWord", false);
343           case 's':
344             return ParserForXMLSchema.getRange("xml:isSpace", true);
345           case 'S':
346             return ParserForXMLSchema.getRange("xml:isSpace", false);
347           case 'c':
348             return ParserForXMLSchema.getRange("xml:isNameChar", true);
349           case 'C':
350             return ParserForXMLSchema.getRange("xml:isNameChar", false);
351           case 'i':
352             return ParserForXMLSchema.getRange("xml:isInitialNameChar", true);
353           case 'I':
354             return ParserForXMLSchema.getRange("xml:isInitialNameChar", false);
355           default:
356             throw new RuntimeException JavaDoc("Internal Error: shorthands: \\u"+Integer.toString(ch, 16));
357         }
358     }
359     
360     int decodeEscaped() throws ParseException {
361         if (this.read() != T_BACKSOLIDUS) throw ex("parser.next.1", this.offset-1);
362         int c = this.chardata;
363         switch (c) {
364           case 'n': c = '\n'; break; // LINE FEED U+000A
365
case 'r': c = '\r'; break; // CRRIAGE RETURN U+000D
366
case 't': c = '\t'; break; // HORIZONTAL TABULATION U+0009
367

368           // XML Schema REC: Single Character Escape
369
case '\\':
370           case '|':
371           case '.':
372           case '^':
373           case '-':
374           case '?':
375           case '*':
376           case '+':
377           case '{':
378           case '}':
379           case '(':
380           case ')':
381           case '[':
382           case ']':
383                 break;
384          default:
385             throw new RuntimeException JavaDoc("Regular expression: unrecognized character '\\"+(char)c+"' in charRange");
386         }
387         return c;
388     }
389
390     static protected Hashtable JavaDoc ranges = null;
391     static protected Hashtable JavaDoc ranges2 = null;
392     static synchronized protected RangeToken getRange(String JavaDoc name, boolean positive) {
393         if (ranges == null) {
394             ranges = new Hashtable JavaDoc();
395             ranges2 = new Hashtable JavaDoc();
396
397             Token tok = Token.createRange();
398             setupRange(tok, SPACES);
399             ranges.put("xml:isSpace", tok);
400             ranges2.put("xml:isSpace", Token.complementRanges(tok));
401
402             tok = Token.createRange();
403             setupRange(tok, DIGITS);
404             ranges.put("xml:isDigit", tok);
405             ranges2.put("xml:isDigit", Token.complementRanges(tok));
406
407             tok = Token.createRange();
408             setupRange(tok, DIGITS);
409             ranges.put("xml:isDigit", tok);
410             ranges2.put("xml:isDigit", Token.complementRanges(tok));
411
412             tok = Token.createRange();
413             setupRange(tok, LETTERS);
414             tok.mergeRanges((Token)ranges.get("xml:isDigit"));
415             ranges.put("xml:isWord", tok);
416             ranges2.put("xml:isWord", Token.complementRanges(tok));
417
418             tok = Token.createRange();
419             setupRange(tok, NAMECHARS);
420             ranges.put("xml:isNameChar", tok);
421             ranges2.put("xml:isNameChar", Token.complementRanges(tok));
422
423             tok = Token.createRange();
424             setupRange(tok, LETTERS);
425             tok.addRange('_', '_');
426             tok.addRange(':', ':');
427             ranges.put("xml:isInitialNameChar", tok);
428             ranges2.put("xml:isInitialNameChar", Token.complementRanges(tok));
429         }
430         RangeToken tok = positive ? (RangeToken)ranges.get(name)
431             : (RangeToken)ranges2.get(name);
432         return tok;
433     }
434
435     static void setupRange(Token range, String JavaDoc src) {
436         int len = src.length();
437         for (int i = 0; i < len; i += 2)
438             range.addRange(src.charAt(i), src.charAt(i+1));
439     }
440
441     private static final String JavaDoc SPACES = "\t\n\r\r ";
442     private static final String JavaDoc NAMECHARS =
443         "\u002d\u002e\u0030\u003a\u0041\u005a\u005f\u005f\u0061\u007a\u00b7\u00b7\u00c0\u00d6"
444         +"\u00d8\u00f6\u00f8\u0131\u0134\u013e\u0141\u0148\u014a\u017e\u0180\u01c3\u01cd\u01f0"
445         +"\u01f4\u01f5\u01fa\u0217\u0250\u02a8\u02bb\u02c1\u02d0\u02d1\u0300\u0345\u0360\u0361"
446         +"\u0386\u038a\u038c\u038c\u038e\u03a1\u03a3\u03ce\u03d0\u03d6\u03da\u03da\u03dc\u03dc"
447         +"\u03de\u03de\u03e0\u03e0\u03e2\u03f3\u0401\u040c\u040e\u044f\u0451\u045c\u045e\u0481"
448         +"\u0483\u0486\u0490\u04c4\u04c7\u04c8\u04cb\u04cc\u04d0\u04eb\u04ee\u04f5\u04f8\u04f9"
449         +"\u0531\u0556\u0559\u0559\u0561\u0586\u0591\u05a1\u05a3\u05b9\u05bb\u05bd\u05bf\u05bf"
450         +"\u05c1\u05c2\u05c4\u05c4\u05d0\u05ea\u05f0\u05f2\u0621\u063a\u0640\u0652\u0660\u0669"
451         +"\u0670\u06b7\u06ba\u06be\u06c0\u06ce\u06d0\u06d3\u06d5\u06e8\u06ea\u06ed\u06f0\u06f9"
452         +"\u0901\u0903\u0905\u0939\u093c\u094d\u0951\u0954\u0958\u0963\u0966\u096f\u0981\u0983"
453         +"\u0985\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b2\u09b2\u09b6\u09b9\u09bc\u09bc"
454         +"\u09be\u09c4\u09c7\u09c8\u09cb\u09cd\u09d7\u09d7\u09dc\u09dd\u09df\u09e3\u09e6\u09f1"
455         +"\u0a02\u0a02\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a\u0a30\u0a32\u0a33\u0a35\u0a36"
456         +"\u0a38\u0a39\u0a3c\u0a3c\u0a3e\u0a42\u0a47\u0a48\u0a4b\u0a4d\u0a59\u0a5c\u0a5e\u0a5e"
457         +"\u0a66\u0a74\u0a81\u0a83\u0a85\u0a8b\u0a8d\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0"
458         +"\u0ab2\u0ab3\u0ab5\u0ab9\u0abc\u0ac5\u0ac7\u0ac9\u0acb\u0acd\u0ae0\u0ae0\u0ae6\u0aef"
459         +"\u0b01\u0b03\u0b05\u0b0c\u0b0f\u0b10\u0b13\u0b28\u0b2a\u0b30\u0b32\u0b33\u0b36\u0b39"
460         +"\u0b3c\u0b43\u0b47\u0b48\u0b4b\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f\u0b61\u0b66\u0b6f"
461         +"\u0b82\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95\u0b99\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f"
462         +"\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb5\u0bb7\u0bb9\u0bbe\u0bc2\u0bc6\u0bc8\u0bca\u0bcd"
463         +"\u0bd7\u0bd7\u0be7\u0bef\u0c01\u0c03\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c33"
464         +"\u0c35\u0c39\u0c3e\u0c44\u0c46\u0c48\u0c4a\u0c4d\u0c55\u0c56\u0c60\u0c61\u0c66\u0c6f"
465         +"\u0c82\u0c83\u0c85\u0c8c\u0c8e\u0c90\u0c92\u0ca8\u0caa\u0cb3\u0cb5\u0cb9\u0cbe\u0cc4"
466         +"\u0cc6\u0cc8\u0cca\u0ccd\u0cd5\u0cd6\u0cde\u0cde\u0ce0\u0ce1\u0ce6\u0cef\u0d02\u0d03"
467         +"\u0d05\u0d0c\u0d0e\u0d10\u0d12\u0d28\u0d2a\u0d39\u0d3e\u0d43\u0d46\u0d48\u0d4a\u0d4d"
468         +"\u0d57\u0d57\u0d60\u0d61\u0d66\u0d6f\u0e01\u0e2e\u0e30\u0e3a\u0e40\u0e4e\u0e50\u0e59"
469         +"\u0e81\u0e82\u0e84\u0e84\u0e87\u0e88\u0e8a\u0e8a\u0e8d\u0e8d\u0e94\u0e97\u0e99\u0e9f"
470         +"\u0ea1\u0ea3\u0ea5\u0ea5\u0ea7\u0ea7\u0eaa\u0eab\u0ead\u0eae\u0eb0\u0eb9\u0ebb\u0ebd"
471         +"\u0ec0\u0ec4\u0ec6\u0ec6\u0ec8\u0ecd\u0ed0\u0ed9\u0f18\u0f19\u0f20\u0f29\u0f35\u0f35"
472         +"\u0f37\u0f37\u0f39\u0f39\u0f3e\u0f47\u0f49\u0f69\u0f71\u0f84\u0f86\u0f8b\u0f90\u0f95"
473         +"\u0f97\u0f97\u0f99\u0fad\u0fb1\u0fb7\u0fb9\u0fb9\u10a0\u10c5\u10d0\u10f6\u1100\u1100"
474         +"\u1102\u1103\u1105\u1107\u1109\u1109\u110b\u110c\u110e\u1112\u113c\u113c\u113e\u113e"
475         +"\u1140\u1140\u114c\u114c\u114e\u114e\u1150\u1150\u1154\u1155\u1159\u1159\u115f\u1161"
476         +"\u1163\u1163\u1165\u1165\u1167\u1167\u1169\u1169\u116d\u116e\u1172\u1173\u1175\u1175"
477         +"\u119e\u119e\u11a8\u11a8\u11ab\u11ab\u11ae\u11af\u11b7\u11b8\u11ba\u11ba\u11bc\u11c2"
478         +"\u11eb\u11eb\u11f0\u11f0\u11f9\u11f9\u1e00\u1e9b\u1ea0\u1ef9\u1f00\u1f15\u1f18\u1f1d"
479         +"\u1f20\u1f45\u1f48\u1f4d\u1f50\u1f57\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f\u1f7d"
480         +"\u1f80\u1fb4\u1fb6\u1fbc\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0\u1fd3\u1fd6\u1fdb"
481         +"\u1fe0\u1fec\u1ff2\u1ff4\u1ff6\u1ffc\u20d0\u20dc\u20e1\u20e1\u2126\u2126\u212a\u212b"
482         +"\u212e\u212e\u2180\u2182\u3005\u3005\u3007\u3007\u3021\u302f\u3031\u3035\u3041\u3094"
483         +"\u3099\u309a\u309d\u309e\u30a1\u30fa\u30fc\u30fe\u3105\u312c\u4e00\u9fa5\uac00\ud7a3"
484         +"";
485     private static final String JavaDoc LETTERS =
486         "\u0041\u005a\u0061\u007a\u00c0\u00d6\u00d8\u00f6\u00f8\u0131\u0134\u013e\u0141\u0148"
487         +"\u014a\u017e\u0180\u01c3\u01cd\u01f0\u01f4\u01f5\u01fa\u0217\u0250\u02a8\u02bb\u02c1"
488         +"\u0386\u0386\u0388\u038a\u038c\u038c\u038e\u03a1\u03a3\u03ce\u03d0\u03d6\u03da\u03da"
489         +"\u03dc\u03dc\u03de\u03de\u03e0\u03e0\u03e2\u03f3\u0401\u040c\u040e\u044f\u0451\u045c"
490         +"\u045e\u0481\u0490\u04c4\u04c7\u04c8\u04cb\u04cc\u04d0\u04eb\u04ee\u04f5\u04f8\u04f9"
491         +"\u0531\u0556\u0559\u0559\u0561\u0586\u05d0\u05ea\u05f0\u05f2\u0621\u063a\u0641\u064a"
492         +"\u0671\u06b7\u06ba\u06be\u06c0\u06ce\u06d0\u06d3\u06d5\u06d5\u06e5\u06e6\u0905\u0939"
493         +"\u093d\u093d\u0958\u0961\u0985\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b2\u09b2"
494         +"\u09b6\u09b9\u09dc\u09dd\u09df\u09e1\u09f0\u09f1\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28"
495         +"\u0a2a\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a5e\u0a5e\u0a72\u0a74"
496         +"\u0a85\u0a8b\u0a8d\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5\u0ab9"
497         +"\u0abd\u0abd\u0ae0\u0ae0\u0b05\u0b0c\u0b0f\u0b10\u0b13\u0b28\u0b2a\u0b30\u0b32\u0b33"
498         +"\u0b36\u0b39\u0b3d\u0b3d\u0b5c\u0b5d\u0b5f\u0b61\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95"
499         +"\u0b99\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb5\u0bb7\u0bb9"
500         +"\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c33\u0c35\u0c39\u0c60\u0c61\u0c85\u0c8c"
501         +"\u0c8e\u0c90\u0c92\u0ca8\u0caa\u0cb3\u0cb5\u0cb9\u0cde\u0cde\u0ce0\u0ce1\u0d05\u0d0c"
502         +"\u0d0e\u0d10\u0d12\u0d28\u0d2a\u0d39\u0d60\u0d61\u0e01\u0e2e\u0e30\u0e30\u0e32\u0e33"
503         +"\u0e40\u0e45\u0e81\u0e82\u0e84\u0e84\u0e87\u0e88\u0e8a\u0e8a\u0e8d\u0e8d\u0e94\u0e97"
504         +"\u0e99\u0e9f\u0ea1\u0ea3\u0ea5\u0ea5\u0ea7\u0ea7\u0eaa\u0eab\u0ead\u0eae\u0eb0\u0eb0"
505         +"\u0eb2\u0eb3\u0ebd\u0ebd\u0ec0\u0ec4\u0f40\u0f47\u0f49\u0f69\u10a0\u10c5\u10d0\u10f6"
506         +"\u1100\u1100\u1102\u1103\u1105\u1107\u1109\u1109\u110b\u110c\u110e\u1112\u113c\u113c"
507         +"\u113e\u113e\u1140\u1140\u114c\u114c\u114e\u114e\u1150\u1150\u1154\u1155\u1159\u1159"
508         +"\u115f\u1161\u1163\u1163\u1165\u1165\u1167\u1167\u1169\u1169\u116d\u116e\u1172\u1173"
509         +"\u1175\u1175\u119e\u119e\u11a8\u11a8\u11ab\u11ab\u11ae\u11af\u11b7\u11b8\u11ba\u11ba"
510         +"\u11bc\u11c2\u11eb\u11eb\u11f0\u11f0\u11f9\u11f9\u1e00\u1e9b\u1ea0\u1ef9\u1f00\u1f15"
511         +"\u1f18\u1f1d\u1f20\u1f45\u1f48\u1f4d\u1f50\u1f57\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d"
512         +"\u1f5f\u1f7d\u1f80\u1fb4\u1fb6\u1fbc\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0\u1fd3"
513         +"\u1fd6\u1fdb\u1fe0\u1fec\u1ff2\u1ff4\u1ff6\u1ffc\u2126\u2126\u212a\u212b\u212e\u212e"
514         +"\u2180\u2182\u3007\u3007\u3021\u3029\u3041\u3094\u30a1\u30fa\u3105\u312c\u4e00\u9fa5"
515         +"\uac00\ud7a3";
516     private static final String JavaDoc DIGITS =
517         "\u0030\u0039\u0660\u0669\u06F0\u06F9\u0966\u096F\u09E6\u09EF\u0A66\u0A6F\u0AE6\u0AEF"
518         +"\u0B66\u0B6F\u0BE7\u0BEF\u0C66\u0C6F\u0CE6\u0CEF\u0D66\u0D6F\u0E50\u0E59\u0ED0\u0ED9"
519         +"\u0F20\u0F29";
520 }
521
Popular Tags