Source Code Cross Referenced for XMLChar.java in  » 6.0-JDK-Modules » sjsxp » com » sun » xml » stream » xerces » util » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » 6.0 JDK Modules » sjsxp » com.sun.xml.stream.xerces.util 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


0001:        /*
0002:         * Copyright 1999-2004 The Apache Software Foundation.
0003:         * 
0004:         * Licensed under the Apache License, Version 2.0 (the "License");
0005:         * you may not use this file except in compliance with the License.
0006:         * You may obtain a copy of the License at
0007:         * 
0008:         *      http://www.apache.org/licenses/LICENSE-2.0
0009:         * 
0010:         * Unless required by applicable law or agreed to in writing, software
0011:         * distributed under the License is distributed on an "AS IS" BASIS,
0012:         * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0013:         * See the License for the specific language governing permissions and
0014:         * limitations under the License.
0015:         */
0016:
0017:        package com.sun.xml.stream.xerces.util;
0018:
0019:        import java.util.Arrays;
0020:
0021:        /**
0022:         * This class defines the basic XML character properties. The data
0023:         * in this class can be used to verify that a character is a valid
0024:         * XML character or if the character is a space, name start, or name
0025:         * character.
0026:         * <p>
0027:         * A series of convenience methods are supplied to ease the burden
0028:         * of the developer. Because inlining the checks can improve per
0029:         * character performance, the tables of character properties are
0030:         * public. Using the character as an index into the <code>CHARS</code>
0031:         * array and applying the appropriate mask flag (e.g.
0032:         * <code>MASK_VALID</code>), yields the same results as calling the
0033:         * convenience methods. There is one exception: check the comments
0034:         * for the <code>isValid</code> method for details.
0035:         *
0036:         * @author Glenn Marcy, IBM
0037:         * @author Andy Clark, IBM
0038:         * @author Eric Ye, IBM
0039:         * @author Arnaud  Le Hors, IBM
0040:         * @author Michael Glavassevich, IBM
0041:         * @author Rahul Srivastava, Sun Microsystems Inc.
0042:         *
0043:         * @version $Id: XMLChar.java,v 1.2 2006/04/01 06:01:40 jeffsuttor Exp $
0044:         */
0045:        public class XMLChar {
0046:
0047:            //
0048:            // Constants
0049:            //
0050:
0051:            /** Character flags. */
0052:            private static final byte[] CHARS = new byte[1 << 16];
0053:
0054:            /** Valid character mask. */
0055:            public static final int MASK_VALID = 0x01;
0056:
0057:            /** Space character mask. */
0058:            public static final int MASK_SPACE = 0x02;
0059:
0060:            /** Name start character mask. */
0061:            public static final int MASK_NAME_START = 0x04;
0062:
0063:            /** Name character mask. */
0064:            public static final int MASK_NAME = 0x08;
0065:
0066:            /** Pubid character mask. */
0067:            public static final int MASK_PUBID = 0x10;
0068:
0069:            /** 
0070:             * Content character mask. Special characters are those that can
0071:             * be considered the start of markup, such as '&lt;' and '&amp;'. 
0072:             * The various newline characters are considered special as well.
0073:             * All other valid XML characters can be considered content.
0074:             * <p>
0075:             * This is an optimization for the inner loop of character scanning.
0076:             */
0077:            public static final int MASK_CONTENT = 0x20;
0078:
0079:            /** NCName start character mask. */
0080:            public static final int MASK_NCNAME_START = 0x40;
0081:
0082:            /** NCName character mask. */
0083:            public static final int MASK_NCNAME = 0x80;
0084:
0085:            //
0086:            // Static initialization
0087:            //
0088:
0089:            static {
0090:
0091:                // Initializing the Character Flag Array
0092:                // Code generated by: XMLCharGenerator.
0093:
0094:                CHARS[9] = 35;
0095:                CHARS[10] = 19;
0096:                CHARS[13] = 19;
0097:                CHARS[32] = 51;
0098:                CHARS[33] = 49;
0099:                CHARS[34] = 33;
0100:                Arrays.fill(CHARS, 35, 38, (byte) 49); // Fill 3 of value (byte) 49
0101:                CHARS[38] = 1;
0102:                Arrays.fill(CHARS, 39, 45, (byte) 49); // Fill 6 of value (byte) 49
0103:                Arrays.fill(CHARS, 45, 47, (byte) -71); // Fill 2 of value (byte) -71
0104:                CHARS[47] = 49;
0105:                Arrays.fill(CHARS, 48, 58, (byte) -71); // Fill 10 of value (byte) -71
0106:                CHARS[58] = 61;
0107:                CHARS[59] = 49;
0108:                CHARS[60] = 1;
0109:                CHARS[61] = 49;
0110:                CHARS[62] = 33;
0111:                Arrays.fill(CHARS, 63, 65, (byte) 49); // Fill 2 of value (byte) 49
0112:                Arrays.fill(CHARS, 65, 91, (byte) -3); // Fill 26 of value (byte) -3
0113:                Arrays.fill(CHARS, 91, 93, (byte) 33); // Fill 2 of value (byte) 33
0114:                CHARS[93] = 1;
0115:                CHARS[94] = 33;
0116:                CHARS[95] = -3;
0117:                CHARS[96] = 33;
0118:                Arrays.fill(CHARS, 97, 123, (byte) -3); // Fill 26 of value (byte) -3
0119:                Arrays.fill(CHARS, 123, 183, (byte) 33); // Fill 60 of value (byte) 33
0120:                CHARS[183] = -87;
0121:                Arrays.fill(CHARS, 184, 192, (byte) 33); // Fill 8 of value (byte) 33
0122:                Arrays.fill(CHARS, 192, 215, (byte) -19); // Fill 23 of value (byte) -19
0123:                CHARS[215] = 33;
0124:                Arrays.fill(CHARS, 216, 247, (byte) -19); // Fill 31 of value (byte) -19
0125:                CHARS[247] = 33;
0126:                Arrays.fill(CHARS, 248, 306, (byte) -19); // Fill 58 of value (byte) -19
0127:                Arrays.fill(CHARS, 306, 308, (byte) 33); // Fill 2 of value (byte) 33
0128:                Arrays.fill(CHARS, 308, 319, (byte) -19); // Fill 11 of value (byte) -19
0129:                Arrays.fill(CHARS, 319, 321, (byte) 33); // Fill 2 of value (byte) 33
0130:                Arrays.fill(CHARS, 321, 329, (byte) -19); // Fill 8 of value (byte) -19
0131:                CHARS[329] = 33;
0132:                Arrays.fill(CHARS, 330, 383, (byte) -19); // Fill 53 of value (byte) -19
0133:                CHARS[383] = 33;
0134:                Arrays.fill(CHARS, 384, 452, (byte) -19); // Fill 68 of value (byte) -19
0135:                Arrays.fill(CHARS, 452, 461, (byte) 33); // Fill 9 of value (byte) 33
0136:                Arrays.fill(CHARS, 461, 497, (byte) -19); // Fill 36 of value (byte) -19
0137:                Arrays.fill(CHARS, 497, 500, (byte) 33); // Fill 3 of value (byte) 33
0138:                Arrays.fill(CHARS, 500, 502, (byte) -19); // Fill 2 of value (byte) -19
0139:                Arrays.fill(CHARS, 502, 506, (byte) 33); // Fill 4 of value (byte) 33
0140:                Arrays.fill(CHARS, 506, 536, (byte) -19); // Fill 30 of value (byte) -19
0141:                Arrays.fill(CHARS, 536, 592, (byte) 33); // Fill 56 of value (byte) 33
0142:                Arrays.fill(CHARS, 592, 681, (byte) -19); // Fill 89 of value (byte) -19
0143:                Arrays.fill(CHARS, 681, 699, (byte) 33); // Fill 18 of value (byte) 33
0144:                Arrays.fill(CHARS, 699, 706, (byte) -19); // Fill 7 of value (byte) -19
0145:                Arrays.fill(CHARS, 706, 720, (byte) 33); // Fill 14 of value (byte) 33
0146:                Arrays.fill(CHARS, 720, 722, (byte) -87); // Fill 2 of value (byte) -87
0147:                Arrays.fill(CHARS, 722, 768, (byte) 33); // Fill 46 of value (byte) 33
0148:                Arrays.fill(CHARS, 768, 838, (byte) -87); // Fill 70 of value (byte) -87
0149:                Arrays.fill(CHARS, 838, 864, (byte) 33); // Fill 26 of value (byte) 33
0150:                Arrays.fill(CHARS, 864, 866, (byte) -87); // Fill 2 of value (byte) -87
0151:                Arrays.fill(CHARS, 866, 902, (byte) 33); // Fill 36 of value (byte) 33
0152:                CHARS[902] = -19;
0153:                CHARS[903] = -87;
0154:                Arrays.fill(CHARS, 904, 907, (byte) -19); // Fill 3 of value (byte) -19
0155:                CHARS[907] = 33;
0156:                CHARS[908] = -19;
0157:                CHARS[909] = 33;
0158:                Arrays.fill(CHARS, 910, 930, (byte) -19); // Fill 20 of value (byte) -19
0159:                CHARS[930] = 33;
0160:                Arrays.fill(CHARS, 931, 975, (byte) -19); // Fill 44 of value (byte) -19
0161:                CHARS[975] = 33;
0162:                Arrays.fill(CHARS, 976, 983, (byte) -19); // Fill 7 of value (byte) -19
0163:                Arrays.fill(CHARS, 983, 986, (byte) 33); // Fill 3 of value (byte) 33
0164:                CHARS[986] = -19;
0165:                CHARS[987] = 33;
0166:                CHARS[988] = -19;
0167:                CHARS[989] = 33;
0168:                CHARS[990] = -19;
0169:                CHARS[991] = 33;
0170:                CHARS[992] = -19;
0171:                CHARS[993] = 33;
0172:                Arrays.fill(CHARS, 994, 1012, (byte) -19); // Fill 18 of value (byte) -19
0173:                Arrays.fill(CHARS, 1012, 1025, (byte) 33); // Fill 13 of value (byte) 33
0174:                Arrays.fill(CHARS, 1025, 1037, (byte) -19); // Fill 12 of value (byte) -19
0175:                CHARS[1037] = 33;
0176:                Arrays.fill(CHARS, 1038, 1104, (byte) -19); // Fill 66 of value (byte) -19
0177:                CHARS[1104] = 33;
0178:                Arrays.fill(CHARS, 1105, 1117, (byte) -19); // Fill 12 of value (byte) -19
0179:                CHARS[1117] = 33;
0180:                Arrays.fill(CHARS, 1118, 1154, (byte) -19); // Fill 36 of value (byte) -19
0181:                CHARS[1154] = 33;
0182:                Arrays.fill(CHARS, 1155, 1159, (byte) -87); // Fill 4 of value (byte) -87
0183:                Arrays.fill(CHARS, 1159, 1168, (byte) 33); // Fill 9 of value (byte) 33
0184:                Arrays.fill(CHARS, 1168, 1221, (byte) -19); // Fill 53 of value (byte) -19
0185:                Arrays.fill(CHARS, 1221, 1223, (byte) 33); // Fill 2 of value (byte) 33
0186:                Arrays.fill(CHARS, 1223, 1225, (byte) -19); // Fill 2 of value (byte) -19
0187:                Arrays.fill(CHARS, 1225, 1227, (byte) 33); // Fill 2 of value (byte) 33
0188:                Arrays.fill(CHARS, 1227, 1229, (byte) -19); // Fill 2 of value (byte) -19
0189:                Arrays.fill(CHARS, 1229, 1232, (byte) 33); // Fill 3 of value (byte) 33
0190:                Arrays.fill(CHARS, 1232, 1260, (byte) -19); // Fill 28 of value (byte) -19
0191:                Arrays.fill(CHARS, 1260, 1262, (byte) 33); // Fill 2 of value (byte) 33
0192:                Arrays.fill(CHARS, 1262, 1270, (byte) -19); // Fill 8 of value (byte) -19
0193:                Arrays.fill(CHARS, 1270, 1272, (byte) 33); // Fill 2 of value (byte) 33
0194:                Arrays.fill(CHARS, 1272, 1274, (byte) -19); // Fill 2 of value (byte) -19
0195:                Arrays.fill(CHARS, 1274, 1329, (byte) 33); // Fill 55 of value (byte) 33
0196:                Arrays.fill(CHARS, 1329, 1367, (byte) -19); // Fill 38 of value (byte) -19
0197:                Arrays.fill(CHARS, 1367, 1369, (byte) 33); // Fill 2 of value (byte) 33
0198:                CHARS[1369] = -19;
0199:                Arrays.fill(CHARS, 1370, 1377, (byte) 33); // Fill 7 of value (byte) 33
0200:                Arrays.fill(CHARS, 1377, 1415, (byte) -19); // Fill 38 of value (byte) -19
0201:                Arrays.fill(CHARS, 1415, 1425, (byte) 33); // Fill 10 of value (byte) 33
0202:                Arrays.fill(CHARS, 1425, 1442, (byte) -87); // Fill 17 of value (byte) -87
0203:                CHARS[1442] = 33;
0204:                Arrays.fill(CHARS, 1443, 1466, (byte) -87); // Fill 23 of value (byte) -87
0205:                CHARS[1466] = 33;
0206:                Arrays.fill(CHARS, 1467, 1470, (byte) -87); // Fill 3 of value (byte) -87
0207:                CHARS[1470] = 33;
0208:                CHARS[1471] = -87;
0209:                CHARS[1472] = 33;
0210:                Arrays.fill(CHARS, 1473, 1475, (byte) -87); // Fill 2 of value (byte) -87
0211:                CHARS[1475] = 33;
0212:                CHARS[1476] = -87;
0213:                Arrays.fill(CHARS, 1477, 1488, (byte) 33); // Fill 11 of value (byte) 33
0214:                Arrays.fill(CHARS, 1488, 1515, (byte) -19); // Fill 27 of value (byte) -19
0215:                Arrays.fill(CHARS, 1515, 1520, (byte) 33); // Fill 5 of value (byte) 33
0216:                Arrays.fill(CHARS, 1520, 1523, (byte) -19); // Fill 3 of value (byte) -19
0217:                Arrays.fill(CHARS, 1523, 1569, (byte) 33); // Fill 46 of value (byte) 33
0218:                Arrays.fill(CHARS, 1569, 1595, (byte) -19); // Fill 26 of value (byte) -19
0219:                Arrays.fill(CHARS, 1595, 1600, (byte) 33); // Fill 5 of value (byte) 33
0220:                CHARS[1600] = -87;
0221:                Arrays.fill(CHARS, 1601, 1611, (byte) -19); // Fill 10 of value (byte) -19
0222:                Arrays.fill(CHARS, 1611, 1619, (byte) -87); // Fill 8 of value (byte) -87
0223:                Arrays.fill(CHARS, 1619, 1632, (byte) 33); // Fill 13 of value (byte) 33
0224:                Arrays.fill(CHARS, 1632, 1642, (byte) -87); // Fill 10 of value (byte) -87
0225:                Arrays.fill(CHARS, 1642, 1648, (byte) 33); // Fill 6 of value (byte) 33
0226:                CHARS[1648] = -87;
0227:                Arrays.fill(CHARS, 1649, 1720, (byte) -19); // Fill 71 of value (byte) -19
0228:                Arrays.fill(CHARS, 1720, 1722, (byte) 33); // Fill 2 of value (byte) 33
0229:                Arrays.fill(CHARS, 1722, 1727, (byte) -19); // Fill 5 of value (byte) -19
0230:                CHARS[1727] = 33;
0231:                Arrays.fill(CHARS, 1728, 1743, (byte) -19); // Fill 15 of value (byte) -19
0232:                CHARS[1743] = 33;
0233:                Arrays.fill(CHARS, 1744, 1748, (byte) -19); // Fill 4 of value (byte) -19
0234:                CHARS[1748] = 33;
0235:                CHARS[1749] = -19;
0236:                Arrays.fill(CHARS, 1750, 1765, (byte) -87); // Fill 15 of value (byte) -87
0237:                Arrays.fill(CHARS, 1765, 1767, (byte) -19); // Fill 2 of value (byte) -19
0238:                Arrays.fill(CHARS, 1767, 1769, (byte) -87); // Fill 2 of value (byte) -87
0239:                CHARS[1769] = 33;
0240:                Arrays.fill(CHARS, 1770, 1774, (byte) -87); // Fill 4 of value (byte) -87
0241:                Arrays.fill(CHARS, 1774, 1776, (byte) 33); // Fill 2 of value (byte) 33
0242:                Arrays.fill(CHARS, 1776, 1786, (byte) -87); // Fill 10 of value (byte) -87
0243:                Arrays.fill(CHARS, 1786, 2305, (byte) 33); // Fill 519 of value (byte) 33
0244:                Arrays.fill(CHARS, 2305, 2308, (byte) -87); // Fill 3 of value (byte) -87
0245:                CHARS[2308] = 33;
0246:                Arrays.fill(CHARS, 2309, 2362, (byte) -19); // Fill 53 of value (byte) -19
0247:                Arrays.fill(CHARS, 2362, 2364, (byte) 33); // Fill 2 of value (byte) 33
0248:                CHARS[2364] = -87;
0249:                CHARS[2365] = -19;
0250:                Arrays.fill(CHARS, 2366, 2382, (byte) -87); // Fill 16 of value (byte) -87
0251:                Arrays.fill(CHARS, 2382, 2385, (byte) 33); // Fill 3 of value (byte) 33
0252:                Arrays.fill(CHARS, 2385, 2389, (byte) -87); // Fill 4 of value (byte) -87
0253:                Arrays.fill(CHARS, 2389, 2392, (byte) 33); // Fill 3 of value (byte) 33
0254:                Arrays.fill(CHARS, 2392, 2402, (byte) -19); // Fill 10 of value (byte) -19
0255:                Arrays.fill(CHARS, 2402, 2404, (byte) -87); // Fill 2 of value (byte) -87
0256:                Arrays.fill(CHARS, 2404, 2406, (byte) 33); // Fill 2 of value (byte) 33
0257:                Arrays.fill(CHARS, 2406, 2416, (byte) -87); // Fill 10 of value (byte) -87
0258:                Arrays.fill(CHARS, 2416, 2433, (byte) 33); // Fill 17 of value (byte) 33
0259:                Arrays.fill(CHARS, 2433, 2436, (byte) -87); // Fill 3 of value (byte) -87
0260:                CHARS[2436] = 33;
0261:                Arrays.fill(CHARS, 2437, 2445, (byte) -19); // Fill 8 of value (byte) -19
0262:                Arrays.fill(CHARS, 2445, 2447, (byte) 33); // Fill 2 of value (byte) 33
0263:                Arrays.fill(CHARS, 2447, 2449, (byte) -19); // Fill 2 of value (byte) -19
0264:                Arrays.fill(CHARS, 2449, 2451, (byte) 33); // Fill 2 of value (byte) 33
0265:                Arrays.fill(CHARS, 2451, 2473, (byte) -19); // Fill 22 of value (byte) -19
0266:                CHARS[2473] = 33;
0267:                Arrays.fill(CHARS, 2474, 2481, (byte) -19); // Fill 7 of value (byte) -19
0268:                CHARS[2481] = 33;
0269:                CHARS[2482] = -19;
0270:                Arrays.fill(CHARS, 2483, 2486, (byte) 33); // Fill 3 of value (byte) 33
0271:                Arrays.fill(CHARS, 2486, 2490, (byte) -19); // Fill 4 of value (byte) -19
0272:                Arrays.fill(CHARS, 2490, 2492, (byte) 33); // Fill 2 of value (byte) 33
0273:                CHARS[2492] = -87;
0274:                CHARS[2493] = 33;
0275:                Arrays.fill(CHARS, 2494, 2501, (byte) -87); // Fill 7 of value (byte) -87
0276:                Arrays.fill(CHARS, 2501, 2503, (byte) 33); // Fill 2 of value (byte) 33
0277:                Arrays.fill(CHARS, 2503, 2505, (byte) -87); // Fill 2 of value (byte) -87
0278:                Arrays.fill(CHARS, 2505, 2507, (byte) 33); // Fill 2 of value (byte) 33
0279:                Arrays.fill(CHARS, 2507, 2510, (byte) -87); // Fill 3 of value (byte) -87
0280:                Arrays.fill(CHARS, 2510, 2519, (byte) 33); // Fill 9 of value (byte) 33
0281:                CHARS[2519] = -87;
0282:                Arrays.fill(CHARS, 2520, 2524, (byte) 33); // Fill 4 of value (byte) 33
0283:                Arrays.fill(CHARS, 2524, 2526, (byte) -19); // Fill 2 of value (byte) -19
0284:                CHARS[2526] = 33;
0285:                Arrays.fill(CHARS, 2527, 2530, (byte) -19); // Fill 3 of value (byte) -19
0286:                Arrays.fill(CHARS, 2530, 2532, (byte) -87); // Fill 2 of value (byte) -87
0287:                Arrays.fill(CHARS, 2532, 2534, (byte) 33); // Fill 2 of value (byte) 33
0288:                Arrays.fill(CHARS, 2534, 2544, (byte) -87); // Fill 10 of value (byte) -87
0289:                Arrays.fill(CHARS, 2544, 2546, (byte) -19); // Fill 2 of value (byte) -19
0290:                Arrays.fill(CHARS, 2546, 2562, (byte) 33); // Fill 16 of value (byte) 33
0291:                CHARS[2562] = -87;
0292:                Arrays.fill(CHARS, 2563, 2565, (byte) 33); // Fill 2 of value (byte) 33
0293:                Arrays.fill(CHARS, 2565, 2571, (byte) -19); // Fill 6 of value (byte) -19
0294:                Arrays.fill(CHARS, 2571, 2575, (byte) 33); // Fill 4 of value (byte) 33
0295:                Arrays.fill(CHARS, 2575, 2577, (byte) -19); // Fill 2 of value (byte) -19
0296:                Arrays.fill(CHARS, 2577, 2579, (byte) 33); // Fill 2 of value (byte) 33
0297:                Arrays.fill(CHARS, 2579, 2601, (byte) -19); // Fill 22 of value (byte) -19
0298:                CHARS[2601] = 33;
0299:                Arrays.fill(CHARS, 2602, 2609, (byte) -19); // Fill 7 of value (byte) -19
0300:                CHARS[2609] = 33;
0301:                Arrays.fill(CHARS, 2610, 2612, (byte) -19); // Fill 2 of value (byte) -19
0302:                CHARS[2612] = 33;
0303:                Arrays.fill(CHARS, 2613, 2615, (byte) -19); // Fill 2 of value (byte) -19
0304:                CHARS[2615] = 33;
0305:                Arrays.fill(CHARS, 2616, 2618, (byte) -19); // Fill 2 of value (byte) -19
0306:                Arrays.fill(CHARS, 2618, 2620, (byte) 33); // Fill 2 of value (byte) 33
0307:                CHARS[2620] = -87;
0308:                CHARS[2621] = 33;
0309:                Arrays.fill(CHARS, 2622, 2627, (byte) -87); // Fill 5 of value (byte) -87
0310:                Arrays.fill(CHARS, 2627, 2631, (byte) 33); // Fill 4 of value (byte) 33
0311:                Arrays.fill(CHARS, 2631, 2633, (byte) -87); // Fill 2 of value (byte) -87
0312:                Arrays.fill(CHARS, 2633, 2635, (byte) 33); // Fill 2 of value (byte) 33
0313:                Arrays.fill(CHARS, 2635, 2638, (byte) -87); // Fill 3 of value (byte) -87
0314:                Arrays.fill(CHARS, 2638, 2649, (byte) 33); // Fill 11 of value (byte) 33
0315:                Arrays.fill(CHARS, 2649, 2653, (byte) -19); // Fill 4 of value (byte) -19
0316:                CHARS[2653] = 33;
0317:                CHARS[2654] = -19;
0318:                Arrays.fill(CHARS, 2655, 2662, (byte) 33); // Fill 7 of value (byte) 33
0319:                Arrays.fill(CHARS, 2662, 2674, (byte) -87); // Fill 12 of value (byte) -87
0320:                Arrays.fill(CHARS, 2674, 2677, (byte) -19); // Fill 3 of value (byte) -19
0321:                Arrays.fill(CHARS, 2677, 2689, (byte) 33); // Fill 12 of value (byte) 33
0322:                Arrays.fill(CHARS, 2689, 2692, (byte) -87); // Fill 3 of value (byte) -87
0323:                CHARS[2692] = 33;
0324:                Arrays.fill(CHARS, 2693, 2700, (byte) -19); // Fill 7 of value (byte) -19
0325:                CHARS[2700] = 33;
0326:                CHARS[2701] = -19;
0327:                CHARS[2702] = 33;
0328:                Arrays.fill(CHARS, 2703, 2706, (byte) -19); // Fill 3 of value (byte) -19
0329:                CHARS[2706] = 33;
0330:                Arrays.fill(CHARS, 2707, 2729, (byte) -19); // Fill 22 of value (byte) -19
0331:                CHARS[2729] = 33;
0332:                Arrays.fill(CHARS, 2730, 2737, (byte) -19); // Fill 7 of value (byte) -19
0333:                CHARS[2737] = 33;
0334:                Arrays.fill(CHARS, 2738, 2740, (byte) -19); // Fill 2 of value (byte) -19
0335:                CHARS[2740] = 33;
0336:                Arrays.fill(CHARS, 2741, 2746, (byte) -19); // Fill 5 of value (byte) -19
0337:                Arrays.fill(CHARS, 2746, 2748, (byte) 33); // Fill 2 of value (byte) 33
0338:                CHARS[2748] = -87;
0339:                CHARS[2749] = -19;
0340:                Arrays.fill(CHARS, 2750, 2758, (byte) -87); // Fill 8 of value (byte) -87
0341:                CHARS[2758] = 33;
0342:                Arrays.fill(CHARS, 2759, 2762, (byte) -87); // Fill 3 of value (byte) -87
0343:                CHARS[2762] = 33;
0344:                Arrays.fill(CHARS, 2763, 2766, (byte) -87); // Fill 3 of value (byte) -87
0345:                Arrays.fill(CHARS, 2766, 2784, (byte) 33); // Fill 18 of value (byte) 33
0346:                CHARS[2784] = -19;
0347:                Arrays.fill(CHARS, 2785, 2790, (byte) 33); // Fill 5 of value (byte) 33
0348:                Arrays.fill(CHARS, 2790, 2800, (byte) -87); // Fill 10 of value (byte) -87
0349:                Arrays.fill(CHARS, 2800, 2817, (byte) 33); // Fill 17 of value (byte) 33
0350:                Arrays.fill(CHARS, 2817, 2820, (byte) -87); // Fill 3 of value (byte) -87
0351:                CHARS[2820] = 33;
0352:                Arrays.fill(CHARS, 2821, 2829, (byte) -19); // Fill 8 of value (byte) -19
0353:                Arrays.fill(CHARS, 2829, 2831, (byte) 33); // Fill 2 of value (byte) 33
0354:                Arrays.fill(CHARS, 2831, 2833, (byte) -19); // Fill 2 of value (byte) -19
0355:                Arrays.fill(CHARS, 2833, 2835, (byte) 33); // Fill 2 of value (byte) 33
0356:                Arrays.fill(CHARS, 2835, 2857, (byte) -19); // Fill 22 of value (byte) -19
0357:                CHARS[2857] = 33;
0358:                Arrays.fill(CHARS, 2858, 2865, (byte) -19); // Fill 7 of value (byte) -19
0359:                CHARS[2865] = 33;
0360:                Arrays.fill(CHARS, 2866, 2868, (byte) -19); // Fill 2 of value (byte) -19
0361:                Arrays.fill(CHARS, 2868, 2870, (byte) 33); // Fill 2 of value (byte) 33
0362:                Arrays.fill(CHARS, 2870, 2874, (byte) -19); // Fill 4 of value (byte) -19
0363:                Arrays.fill(CHARS, 2874, 2876, (byte) 33); // Fill 2 of value (byte) 33
0364:                CHARS[2876] = -87;
0365:                CHARS[2877] = -19;
0366:                Arrays.fill(CHARS, 2878, 2884, (byte) -87); // Fill 6 of value (byte) -87
0367:                Arrays.fill(CHARS, 2884, 2887, (byte) 33); // Fill 3 of value (byte) 33
0368:                Arrays.fill(CHARS, 2887, 2889, (byte) -87); // Fill 2 of value (byte) -87
0369:                Arrays.fill(CHARS, 2889, 2891, (byte) 33); // Fill 2 of value (byte) 33
0370:                Arrays.fill(CHARS, 2891, 2894, (byte) -87); // Fill 3 of value (byte) -87
0371:                Arrays.fill(CHARS, 2894, 2902, (byte) 33); // Fill 8 of value (byte) 33
0372:                Arrays.fill(CHARS, 2902, 2904, (byte) -87); // Fill 2 of value (byte) -87
0373:                Arrays.fill(CHARS, 2904, 2908, (byte) 33); // Fill 4 of value (byte) 33
0374:                Arrays.fill(CHARS, 2908, 2910, (byte) -19); // Fill 2 of value (byte) -19
0375:                CHARS[2910] = 33;
0376:                Arrays.fill(CHARS, 2911, 2914, (byte) -19); // Fill 3 of value (byte) -19
0377:                Arrays.fill(CHARS, 2914, 2918, (byte) 33); // Fill 4 of value (byte) 33
0378:                Arrays.fill(CHARS, 2918, 2928, (byte) -87); // Fill 10 of value (byte) -87
0379:                Arrays.fill(CHARS, 2928, 2946, (byte) 33); // Fill 18 of value (byte) 33
0380:                Arrays.fill(CHARS, 2946, 2948, (byte) -87); // Fill 2 of value (byte) -87
0381:                CHARS[2948] = 33;
0382:                Arrays.fill(CHARS, 2949, 2955, (byte) -19); // Fill 6 of value (byte) -19
0383:                Arrays.fill(CHARS, 2955, 2958, (byte) 33); // Fill 3 of value (byte) 33
0384:                Arrays.fill(CHARS, 2958, 2961, (byte) -19); // Fill 3 of value (byte) -19
0385:                CHARS[2961] = 33;
0386:                Arrays.fill(CHARS, 2962, 2966, (byte) -19); // Fill 4 of value (byte) -19
0387:                Arrays.fill(CHARS, 2966, 2969, (byte) 33); // Fill 3 of value (byte) 33
0388:                Arrays.fill(CHARS, 2969, 2971, (byte) -19); // Fill 2 of value (byte) -19
0389:                CHARS[2971] = 33;
0390:                CHARS[2972] = -19;
0391:                CHARS[2973] = 33;
0392:                Arrays.fill(CHARS, 2974, 2976, (byte) -19); // Fill 2 of value (byte) -19
0393:                Arrays.fill(CHARS, 2976, 2979, (byte) 33); // Fill 3 of value (byte) 33
0394:                Arrays.fill(CHARS, 2979, 2981, (byte) -19); // Fill 2 of value (byte) -19
0395:                Arrays.fill(CHARS, 2981, 2984, (byte) 33); // Fill 3 of value (byte) 33
0396:                Arrays.fill(CHARS, 2984, 2987, (byte) -19); // Fill 3 of value (byte) -19
0397:                Arrays.fill(CHARS, 2987, 2990, (byte) 33); // Fill 3 of value (byte) 33
0398:                Arrays.fill(CHARS, 2990, 2998, (byte) -19); // Fill 8 of value (byte) -19
0399:                CHARS[2998] = 33;
0400:                Arrays.fill(CHARS, 2999, 3002, (byte) -19); // Fill 3 of value (byte) -19
0401:                Arrays.fill(CHARS, 3002, 3006, (byte) 33); // Fill 4 of value (byte) 33
0402:                Arrays.fill(CHARS, 3006, 3011, (byte) -87); // Fill 5 of value (byte) -87
0403:                Arrays.fill(CHARS, 3011, 3014, (byte) 33); // Fill 3 of value (byte) 33
0404:                Arrays.fill(CHARS, 3014, 3017, (byte) -87); // Fill 3 of value (byte) -87
0405:                CHARS[3017] = 33;
0406:                Arrays.fill(CHARS, 3018, 3022, (byte) -87); // Fill 4 of value (byte) -87
0407:                Arrays.fill(CHARS, 3022, 3031, (byte) 33); // Fill 9 of value (byte) 33
0408:                CHARS[3031] = -87;
0409:                Arrays.fill(CHARS, 3032, 3047, (byte) 33); // Fill 15 of value (byte) 33
0410:                Arrays.fill(CHARS, 3047, 3056, (byte) -87); // Fill 9 of value (byte) -87
0411:                Arrays.fill(CHARS, 3056, 3073, (byte) 33); // Fill 17 of value (byte) 33
0412:                Arrays.fill(CHARS, 3073, 3076, (byte) -87); // Fill 3 of value (byte) -87
0413:                CHARS[3076] = 33;
0414:                Arrays.fill(CHARS, 3077, 3085, (byte) -19); // Fill 8 of value (byte) -19
0415:                CHARS[3085] = 33;
0416:                Arrays.fill(CHARS, 3086, 3089, (byte) -19); // Fill 3 of value (byte) -19
0417:                CHARS[3089] = 33;
0418:                Arrays.fill(CHARS, 3090, 3113, (byte) -19); // Fill 23 of value (byte) -19
0419:                CHARS[3113] = 33;
0420:                Arrays.fill(CHARS, 3114, 3124, (byte) -19); // Fill 10 of value (byte) -19
0421:                CHARS[3124] = 33;
0422:                Arrays.fill(CHARS, 3125, 3130, (byte) -19); // Fill 5 of value (byte) -19
0423:                Arrays.fill(CHARS, 3130, 3134, (byte) 33); // Fill 4 of value (byte) 33
0424:                Arrays.fill(CHARS, 3134, 3141, (byte) -87); // Fill 7 of value (byte) -87
0425:                CHARS[3141] = 33;
0426:                Arrays.fill(CHARS, 3142, 3145, (byte) -87); // Fill 3 of value (byte) -87
0427:                CHARS[3145] = 33;
0428:                Arrays.fill(CHARS, 3146, 3150, (byte) -87); // Fill 4 of value (byte) -87
0429:                Arrays.fill(CHARS, 3150, 3157, (byte) 33); // Fill 7 of value (byte) 33
0430:                Arrays.fill(CHARS, 3157, 3159, (byte) -87); // Fill 2 of value (byte) -87
0431:                Arrays.fill(CHARS, 3159, 3168, (byte) 33); // Fill 9 of value (byte) 33
0432:                Arrays.fill(CHARS, 3168, 3170, (byte) -19); // Fill 2 of value (byte) -19
0433:                Arrays.fill(CHARS, 3170, 3174, (byte) 33); // Fill 4 of value (byte) 33
0434:                Arrays.fill(CHARS, 3174, 3184, (byte) -87); // Fill 10 of value (byte) -87
0435:                Arrays.fill(CHARS, 3184, 3202, (byte) 33); // Fill 18 of value (byte) 33
0436:                Arrays.fill(CHARS, 3202, 3204, (byte) -87); // Fill 2 of value (byte) -87
0437:                CHARS[3204] = 33;
0438:                Arrays.fill(CHARS, 3205, 3213, (byte) -19); // Fill 8 of value (byte) -19
0439:                CHARS[3213] = 33;
0440:                Arrays.fill(CHARS, 3214, 3217, (byte) -19); // Fill 3 of value (byte) -19
0441:                CHARS[3217] = 33;
0442:                Arrays.fill(CHARS, 3218, 3241, (byte) -19); // Fill 23 of value (byte) -19
0443:                CHARS[3241] = 33;
0444:                Arrays.fill(CHARS, 3242, 3252, (byte) -19); // Fill 10 of value (byte) -19
0445:                CHARS[3252] = 33;
0446:                Arrays.fill(CHARS, 3253, 3258, (byte) -19); // Fill 5 of value (byte) -19
0447:                Arrays.fill(CHARS, 3258, 3262, (byte) 33); // Fill 4 of value (byte) 33
0448:                Arrays.fill(CHARS, 3262, 3269, (byte) -87); // Fill 7 of value (byte) -87
0449:                CHARS[3269] = 33;
0450:                Arrays.fill(CHARS, 3270, 3273, (byte) -87); // Fill 3 of value (byte) -87
0451:                CHARS[3273] = 33;
0452:                Arrays.fill(CHARS, 3274, 3278, (byte) -87); // Fill 4 of value (byte) -87
0453:                Arrays.fill(CHARS, 3278, 3285, (byte) 33); // Fill 7 of value (byte) 33
0454:                Arrays.fill(CHARS, 3285, 3287, (byte) -87); // Fill 2 of value (byte) -87
0455:                Arrays.fill(CHARS, 3287, 3294, (byte) 33); // Fill 7 of value (byte) 33
0456:                CHARS[3294] = -19;
0457:                CHARS[3295] = 33;
0458:                Arrays.fill(CHARS, 3296, 3298, (byte) -19); // Fill 2 of value (byte) -19
0459:                Arrays.fill(CHARS, 3298, 3302, (byte) 33); // Fill 4 of value (byte) 33
0460:                Arrays.fill(CHARS, 3302, 3312, (byte) -87); // Fill 10 of value (byte) -87
0461:                Arrays.fill(CHARS, 3312, 3330, (byte) 33); // Fill 18 of value (byte) 33
0462:                Arrays.fill(CHARS, 3330, 3332, (byte) -87); // Fill 2 of value (byte) -87
0463:                CHARS[3332] = 33;
0464:                Arrays.fill(CHARS, 3333, 3341, (byte) -19); // Fill 8 of value (byte) -19
0465:                CHARS[3341] = 33;
0466:                Arrays.fill(CHARS, 3342, 3345, (byte) -19); // Fill 3 of value (byte) -19
0467:                CHARS[3345] = 33;
0468:                Arrays.fill(CHARS, 3346, 3369, (byte) -19); // Fill 23 of value (byte) -19
0469:                CHARS[3369] = 33;
0470:                Arrays.fill(CHARS, 3370, 3386, (byte) -19); // Fill 16 of value (byte) -19
0471:                Arrays.fill(CHARS, 3386, 3390, (byte) 33); // Fill 4 of value (byte) 33
0472:                Arrays.fill(CHARS, 3390, 3396, (byte) -87); // Fill 6 of value (byte) -87
0473:                Arrays.fill(CHARS, 3396, 3398, (byte) 33); // Fill 2 of value (byte) 33
0474:                Arrays.fill(CHARS, 3398, 3401, (byte) -87); // Fill 3 of value (byte) -87
0475:                CHARS[3401] = 33;
0476:                Arrays.fill(CHARS, 3402, 3406, (byte) -87); // Fill 4 of value (byte) -87
0477:                Arrays.fill(CHARS, 3406, 3415, (byte) 33); // Fill 9 of value (byte) 33
0478:                CHARS[3415] = -87;
0479:                Arrays.fill(CHARS, 3416, 3424, (byte) 33); // Fill 8 of value (byte) 33
0480:                Arrays.fill(CHARS, 3424, 3426, (byte) -19); // Fill 2 of value (byte) -19
0481:                Arrays.fill(CHARS, 3426, 3430, (byte) 33); // Fill 4 of value (byte) 33
0482:                Arrays.fill(CHARS, 3430, 3440, (byte) -87); // Fill 10 of value (byte) -87
0483:                Arrays.fill(CHARS, 3440, 3585, (byte) 33); // Fill 145 of value (byte) 33
0484:                Arrays.fill(CHARS, 3585, 3631, (byte) -19); // Fill 46 of value (byte) -19
0485:                CHARS[3631] = 33;
0486:                CHARS[3632] = -19;
0487:                CHARS[3633] = -87;
0488:                Arrays.fill(CHARS, 3634, 3636, (byte) -19); // Fill 2 of value (byte) -19
0489:                Arrays.fill(CHARS, 3636, 3643, (byte) -87); // Fill 7 of value (byte) -87
0490:                Arrays.fill(CHARS, 3643, 3648, (byte) 33); // Fill 5 of value (byte) 33
0491:                Arrays.fill(CHARS, 3648, 3654, (byte) -19); // Fill 6 of value (byte) -19
0492:                Arrays.fill(CHARS, 3654, 3663, (byte) -87); // Fill 9 of value (byte) -87
0493:                CHARS[3663] = 33;
0494:                Arrays.fill(CHARS, 3664, 3674, (byte) -87); // Fill 10 of value (byte) -87
0495:                Arrays.fill(CHARS, 3674, 3713, (byte) 33); // Fill 39 of value (byte) 33
0496:                Arrays.fill(CHARS, 3713, 3715, (byte) -19); // Fill 2 of value (byte) -19
0497:                CHARS[3715] = 33;
0498:                CHARS[3716] = -19;
0499:                Arrays.fill(CHARS, 3717, 3719, (byte) 33); // Fill 2 of value (byte) 33
0500:                Arrays.fill(CHARS, 3719, 3721, (byte) -19); // Fill 2 of value (byte) -19
0501:                CHARS[3721] = 33;
0502:                CHARS[3722] = -19;
0503:                Arrays.fill(CHARS, 3723, 3725, (byte) 33); // Fill 2 of value (byte) 33
0504:                CHARS[3725] = -19;
0505:                Arrays.fill(CHARS, 3726, 3732, (byte) 33); // Fill 6 of value (byte) 33
0506:                Arrays.fill(CHARS, 3732, 3736, (byte) -19); // Fill 4 of value (byte) -19
0507:                CHARS[3736] = 33;
0508:                Arrays.fill(CHARS, 3737, 3744, (byte) -19); // Fill 7 of value (byte) -19
0509:                CHARS[3744] = 33;
0510:                Arrays.fill(CHARS, 3745, 3748, (byte) -19); // Fill 3 of value (byte) -19
0511:                CHARS[3748] = 33;
0512:                CHARS[3749] = -19;
0513:                CHARS[3750] = 33;
0514:                CHARS[3751] = -19;
0515:                Arrays.fill(CHARS, 3752, 3754, (byte) 33); // Fill 2 of value (byte) 33
0516:                Arrays.fill(CHARS, 3754, 3756, (byte) -19); // Fill 2 of value (byte) -19
0517:                CHARS[3756] = 33;
0518:                Arrays.fill(CHARS, 3757, 3759, (byte) -19); // Fill 2 of value (byte) -19
0519:                CHARS[3759] = 33;
0520:                CHARS[3760] = -19;
0521:                CHARS[3761] = -87;
0522:                Arrays.fill(CHARS, 3762, 3764, (byte) -19); // Fill 2 of value (byte) -19
0523:                Arrays.fill(CHARS, 3764, 3770, (byte) -87); // Fill 6 of value (byte) -87
0524:                CHARS[3770] = 33;
0525:                Arrays.fill(CHARS, 3771, 3773, (byte) -87); // Fill 2 of value (byte) -87
0526:                CHARS[3773] = -19;
0527:                Arrays.fill(CHARS, 3774, 3776, (byte) 33); // Fill 2 of value (byte) 33
0528:                Arrays.fill(CHARS, 3776, 3781, (byte) -19); // Fill 5 of value (byte) -19
0529:                CHARS[3781] = 33;
0530:                CHARS[3782] = -87;
0531:                CHARS[3783] = 33;
0532:                Arrays.fill(CHARS, 3784, 3790, (byte) -87); // Fill 6 of value (byte) -87
0533:                Arrays.fill(CHARS, 3790, 3792, (byte) 33); // Fill 2 of value (byte) 33
0534:                Arrays.fill(CHARS, 3792, 3802, (byte) -87); // Fill 10 of value (byte) -87
0535:                Arrays.fill(CHARS, 3802, 3864, (byte) 33); // Fill 62 of value (byte) 33
0536:                Arrays.fill(CHARS, 3864, 3866, (byte) -87); // Fill 2 of value (byte) -87
0537:                Arrays.fill(CHARS, 3866, 3872, (byte) 33); // Fill 6 of value (byte) 33
0538:                Arrays.fill(CHARS, 3872, 3882, (byte) -87); // Fill 10 of value (byte) -87
0539:                Arrays.fill(CHARS, 3882, 3893, (byte) 33); // Fill 11 of value (byte) 33
0540:                CHARS[3893] = -87;
0541:                CHARS[3894] = 33;
0542:                CHARS[3895] = -87;
0543:                CHARS[3896] = 33;
0544:                CHARS[3897] = -87;
0545:                Arrays.fill(CHARS, 3898, 3902, (byte) 33); // Fill 4 of value (byte) 33
0546:                Arrays.fill(CHARS, 3902, 3904, (byte) -87); // Fill 2 of value (byte) -87
0547:                Arrays.fill(CHARS, 3904, 3912, (byte) -19); // Fill 8 of value (byte) -19
0548:                CHARS[3912] = 33;
0549:                Arrays.fill(CHARS, 3913, 3946, (byte) -19); // Fill 33 of value (byte) -19
0550:                Arrays.fill(CHARS, 3946, 3953, (byte) 33); // Fill 7 of value (byte) 33
0551:                Arrays.fill(CHARS, 3953, 3973, (byte) -87); // Fill 20 of value (byte) -87
0552:                CHARS[3973] = 33;
0553:                Arrays.fill(CHARS, 3974, 3980, (byte) -87); // Fill 6 of value (byte) -87
0554:                Arrays.fill(CHARS, 3980, 3984, (byte) 33); // Fill 4 of value (byte) 33
0555:                Arrays.fill(CHARS, 3984, 3990, (byte) -87); // Fill 6 of value (byte) -87
0556:                CHARS[3990] = 33;
0557:                CHARS[3991] = -87;
0558:                CHARS[3992] = 33;
0559:                Arrays.fill(CHARS, 3993, 4014, (byte) -87); // Fill 21 of value (byte) -87
0560:                Arrays.fill(CHARS, 4014, 4017, (byte) 33); // Fill 3 of value (byte) 33
0561:                Arrays.fill(CHARS, 4017, 4024, (byte) -87); // Fill 7 of value (byte) -87
0562:                CHARS[4024] = 33;
0563:                CHARS[4025] = -87;
0564:                Arrays.fill(CHARS, 4026, 4256, (byte) 33); // Fill 230 of value (byte) 33
0565:                Arrays.fill(CHARS, 4256, 4294, (byte) -19); // Fill 38 of value (byte) -19
0566:                Arrays.fill(CHARS, 4294, 4304, (byte) 33); // Fill 10 of value (byte) 33
0567:                Arrays.fill(CHARS, 4304, 4343, (byte) -19); // Fill 39 of value (byte) -19
0568:                Arrays.fill(CHARS, 4343, 4352, (byte) 33); // Fill 9 of value (byte) 33
0569:                CHARS[4352] = -19;
0570:                CHARS[4353] = 33;
0571:                Arrays.fill(CHARS, 4354, 4356, (byte) -19); // Fill 2 of value (byte) -19
0572:                CHARS[4356] = 33;
0573:                Arrays.fill(CHARS, 4357, 4360, (byte) -19); // Fill 3 of value (byte) -19
0574:                CHARS[4360] = 33;
0575:                CHARS[4361] = -19;
0576:                CHARS[4362] = 33;
0577:                Arrays.fill(CHARS, 4363, 4365, (byte) -19); // Fill 2 of value (byte) -19
0578:                CHARS[4365] = 33;
0579:                Arrays.fill(CHARS, 4366, 4371, (byte) -19); // Fill 5 of value (byte) -19
0580:                Arrays.fill(CHARS, 4371, 4412, (byte) 33); // Fill 41 of value (byte) 33
0581:                CHARS[4412] = -19;
0582:                CHARS[4413] = 33;
0583:                CHARS[4414] = -19;
0584:                CHARS[4415] = 33;
0585:                CHARS[4416] = -19;
0586:                Arrays.fill(CHARS, 4417, 4428, (byte) 33); // Fill 11 of value (byte) 33
0587:                CHARS[4428] = -19;
0588:                CHARS[4429] = 33;
0589:                CHARS[4430] = -19;
0590:                CHARS[4431] = 33;
0591:                CHARS[4432] = -19;
0592:                Arrays.fill(CHARS, 4433, 4436, (byte) 33); // Fill 3 of value (byte) 33
0593:                Arrays.fill(CHARS, 4436, 4438, (byte) -19); // Fill 2 of value (byte) -19
0594:                Arrays.fill(CHARS, 4438, 4441, (byte) 33); // Fill 3 of value (byte) 33
0595:                CHARS[4441] = -19;
0596:                Arrays.fill(CHARS, 4442, 4447, (byte) 33); // Fill 5 of value (byte) 33
0597:                Arrays.fill(CHARS, 4447, 4450, (byte) -19); // Fill 3 of value (byte) -19
0598:                CHARS[4450] = 33;
0599:                CHARS[4451] = -19;
0600:                CHARS[4452] = 33;
0601:                CHARS[4453] = -19;
0602:                CHARS[4454] = 33;
0603:                CHARS[4455] = -19;
0604:                CHARS[4456] = 33;
0605:                CHARS[4457] = -19;
0606:                Arrays.fill(CHARS, 4458, 4461, (byte) 33); // Fill 3 of value (byte) 33
0607:                Arrays.fill(CHARS, 4461, 4463, (byte) -19); // Fill 2 of value (byte) -19
0608:                Arrays.fill(CHARS, 4463, 4466, (byte) 33); // Fill 3 of value (byte) 33
0609:                Arrays.fill(CHARS, 4466, 4468, (byte) -19); // Fill 2 of value (byte) -19
0610:                CHARS[4468] = 33;
0611:                CHARS[4469] = -19;
0612:                Arrays.fill(CHARS, 4470, 4510, (byte) 33); // Fill 40 of value (byte) 33
0613:                CHARS[4510] = -19;
0614:                Arrays.fill(CHARS, 4511, 4520, (byte) 33); // Fill 9 of value (byte) 33
0615:                CHARS[4520] = -19;
0616:                Arrays.fill(CHARS, 4521, 4523, (byte) 33); // Fill 2 of value (byte) 33
0617:                CHARS[4523] = -19;
0618:                Arrays.fill(CHARS, 4524, 4526, (byte) 33); // Fill 2 of value (byte) 33
0619:                Arrays.fill(CHARS, 4526, 4528, (byte) -19); // Fill 2 of value (byte) -19
0620:                Arrays.fill(CHARS, 4528, 4535, (byte) 33); // Fill 7 of value (byte) 33
0621:                Arrays.fill(CHARS, 4535, 4537, (byte) -19); // Fill 2 of value (byte) -19
0622:                CHARS[4537] = 33;
0623:                CHARS[4538] = -19;
0624:                CHARS[4539] = 33;
0625:                Arrays.fill(CHARS, 4540, 4547, (byte) -19); // Fill 7 of value (byte) -19
0626:                Arrays.fill(CHARS, 4547, 4587, (byte) 33); // Fill 40 of value (byte) 33
0627:                CHARS[4587] = -19;
0628:                Arrays.fill(CHARS, 4588, 4592, (byte) 33); // Fill 4 of value (byte) 33
0629:                CHARS[4592] = -19;
0630:                Arrays.fill(CHARS, 4593, 4601, (byte) 33); // Fill 8 of value (byte) 33
0631:                CHARS[4601] = -19;
0632:                Arrays.fill(CHARS, 4602, 7680, (byte) 33); // Fill 3078 of value (byte) 33
0633:                Arrays.fill(CHARS, 7680, 7836, (byte) -19); // Fill 156 of value (byte) -19
0634:                Arrays.fill(CHARS, 7836, 7840, (byte) 33); // Fill 4 of value (byte) 33
0635:                Arrays.fill(CHARS, 7840, 7930, (byte) -19); // Fill 90 of value (byte) -19
0636:                Arrays.fill(CHARS, 7930, 7936, (byte) 33); // Fill 6 of value (byte) 33
0637:                Arrays.fill(CHARS, 7936, 7958, (byte) -19); // Fill 22 of value (byte) -19
0638:                Arrays.fill(CHARS, 7958, 7960, (byte) 33); // Fill 2 of value (byte) 33
0639:                Arrays.fill(CHARS, 7960, 7966, (byte) -19); // Fill 6 of value (byte) -19
0640:                Arrays.fill(CHARS, 7966, 7968, (byte) 33); // Fill 2 of value (byte) 33
0641:                Arrays.fill(CHARS, 7968, 8006, (byte) -19); // Fill 38 of value (byte) -19
0642:                Arrays.fill(CHARS, 8006, 8008, (byte) 33); // Fill 2 of value (byte) 33
0643:                Arrays.fill(CHARS, 8008, 8014, (byte) -19); // Fill 6 of value (byte) -19
0644:                Arrays.fill(CHARS, 8014, 8016, (byte) 33); // Fill 2 of value (byte) 33
0645:                Arrays.fill(CHARS, 8016, 8024, (byte) -19); // Fill 8 of value (byte) -19
0646:                CHARS[8024] = 33;
0647:                CHARS[8025] = -19;
0648:                CHARS[8026] = 33;
0649:                CHARS[8027] = -19;
0650:                CHARS[8028] = 33;
0651:                CHARS[8029] = -19;
0652:                CHARS[8030] = 33;
0653:                Arrays.fill(CHARS, 8031, 8062, (byte) -19); // Fill 31 of value (byte) -19
0654:                Arrays.fill(CHARS, 8062, 8064, (byte) 33); // Fill 2 of value (byte) 33
0655:                Arrays.fill(CHARS, 8064, 8117, (byte) -19); // Fill 53 of value (byte) -19
0656:                CHARS[8117] = 33;
0657:                Arrays.fill(CHARS, 8118, 8125, (byte) -19); // Fill 7 of value (byte) -19
0658:                CHARS[8125] = 33;
0659:                CHARS[8126] = -19;
0660:                Arrays.fill(CHARS, 8127, 8130, (byte) 33); // Fill 3 of value (byte) 33
0661:                Arrays.fill(CHARS, 8130, 8133, (byte) -19); // Fill 3 of value (byte) -19
0662:                CHARS[8133] = 33;
0663:                Arrays.fill(CHARS, 8134, 8141, (byte) -19); // Fill 7 of value (byte) -19
0664:                Arrays.fill(CHARS, 8141, 8144, (byte) 33); // Fill 3 of value (byte) 33
0665:                Arrays.fill(CHARS, 8144, 8148, (byte) -19); // Fill 4 of value (byte) -19
0666:                Arrays.fill(CHARS, 8148, 8150, (byte) 33); // Fill 2 of value (byte) 33
0667:                Arrays.fill(CHARS, 8150, 8156, (byte) -19); // Fill 6 of value (byte) -19
0668:                Arrays.fill(CHARS, 8156, 8160, (byte) 33); // Fill 4 of value (byte) 33
0669:                Arrays.fill(CHARS, 8160, 8173, (byte) -19); // Fill 13 of value (byte) -19
0670:                Arrays.fill(CHARS, 8173, 8178, (byte) 33); // Fill 5 of value (byte) 33
0671:                Arrays.fill(CHARS, 8178, 8181, (byte) -19); // Fill 3 of value (byte) -19
0672:                CHARS[8181] = 33;
0673:                Arrays.fill(CHARS, 8182, 8189, (byte) -19); // Fill 7 of value (byte) -19
0674:                Arrays.fill(CHARS, 8189, 8400, (byte) 33); // Fill 211 of value (byte) 33
0675:                Arrays.fill(CHARS, 8400, 8413, (byte) -87); // Fill 13 of value (byte) -87
0676:                Arrays.fill(CHARS, 8413, 8417, (byte) 33); // Fill 4 of value (byte) 33
0677:                CHARS[8417] = -87;
0678:                Arrays.fill(CHARS, 8418, 8486, (byte) 33); // Fill 68 of value (byte) 33
0679:                CHARS[8486] = -19;
0680:                Arrays.fill(CHARS, 8487, 8490, (byte) 33); // Fill 3 of value (byte) 33
0681:                Arrays.fill(CHARS, 8490, 8492, (byte) -19); // Fill 2 of value (byte) -19
0682:                Arrays.fill(CHARS, 8492, 8494, (byte) 33); // Fill 2 of value (byte) 33
0683:                CHARS[8494] = -19;
0684:                Arrays.fill(CHARS, 8495, 8576, (byte) 33); // Fill 81 of value (byte) 33
0685:                Arrays.fill(CHARS, 8576, 8579, (byte) -19); // Fill 3 of value (byte) -19
0686:                Arrays.fill(CHARS, 8579, 12293, (byte) 33); // Fill 3714 of value (byte) 33
0687:                CHARS[12293] = -87;
0688:                CHARS[12294] = 33;
0689:                CHARS[12295] = -19;
0690:                Arrays.fill(CHARS, 12296, 12321, (byte) 33); // Fill 25 of value (byte) 33
0691:                Arrays.fill(CHARS, 12321, 12330, (byte) -19); // Fill 9 of value (byte) -19
0692:                Arrays.fill(CHARS, 12330, 12336, (byte) -87); // Fill 6 of value (byte) -87
0693:                CHARS[12336] = 33;
0694:                Arrays.fill(CHARS, 12337, 12342, (byte) -87); // Fill 5 of value (byte) -87
0695:                Arrays.fill(CHARS, 12342, 12353, (byte) 33); // Fill 11 of value (byte) 33
0696:                Arrays.fill(CHARS, 12353, 12437, (byte) -19); // Fill 84 of value (byte) -19
0697:                Arrays.fill(CHARS, 12437, 12441, (byte) 33); // Fill 4 of value (byte) 33
0698:                Arrays.fill(CHARS, 12441, 12443, (byte) -87); // Fill 2 of value (byte) -87
0699:                Arrays.fill(CHARS, 12443, 12445, (byte) 33); // Fill 2 of value (byte) 33
0700:                Arrays.fill(CHARS, 12445, 12447, (byte) -87); // Fill 2 of value (byte) -87
0701:                Arrays.fill(CHARS, 12447, 12449, (byte) 33); // Fill 2 of value (byte) 33
0702:                Arrays.fill(CHARS, 12449, 12539, (byte) -19); // Fill 90 of value (byte) -19
0703:                CHARS[12539] = 33;
0704:                Arrays.fill(CHARS, 12540, 12543, (byte) -87); // Fill 3 of value (byte) -87
0705:                Arrays.fill(CHARS, 12543, 12549, (byte) 33); // Fill 6 of value (byte) 33
0706:                Arrays.fill(CHARS, 12549, 12589, (byte) -19); // Fill 40 of value (byte) -19
0707:                Arrays.fill(CHARS, 12589, 19968, (byte) 33); // Fill 7379 of value (byte) 33
0708:                Arrays.fill(CHARS, 19968, 40870, (byte) -19); // Fill 20902 of value (byte) -19
0709:                Arrays.fill(CHARS, 40870, 44032, (byte) 33); // Fill 3162 of value (byte) 33
0710:                Arrays.fill(CHARS, 44032, 55204, (byte) -19); // Fill 11172 of value (byte) -19
0711:                Arrays.fill(CHARS, 55204, 55296, (byte) 33); // Fill 92 of value (byte) 33
0712:                Arrays.fill(CHARS, 57344, 65534, (byte) 33); // Fill 8190 of value (byte) 33
0713:
0714:            } // <clinit>()
0715:
0716:            //
0717:            // Public static methods
0718:            //
0719:
0720:            /**
0721:             * Returns true if the specified character is a supplemental character.
0722:             *
0723:             * @param c The character to check.
0724:             */
0725:            public static boolean isSupplemental(int c) {
0726:                return (c >= 0x10000 && c <= 0x10FFFF);
0727:            }
0728:
0729:            /**
0730:             * Returns true the supplemental character corresponding to the given
0731:             * surrogates.
0732:             *
0733:             * @param h The high surrogate.
0734:             * @param l The low surrogate.
0735:             */
0736:            public static int supplemental(char h, char l) {
0737:                return (h - 0xD800) * 0x400 + (l - 0xDC00) + 0x10000;
0738:            }
0739:
0740:            /**
0741:             * Returns the high surrogate of a supplemental character
0742:             *
0743:             * @param c The supplemental character to "split".
0744:             */
0745:            public static char highSurrogate(int c) {
0746:                return (char) (((c - 0x00010000) >> 10) + 0xD800);
0747:            }
0748:
0749:            /**
0750:             * Returns the low surrogate of a supplemental character
0751:             *
0752:             * @param c The supplemental character to "split".
0753:             */
0754:            public static char lowSurrogate(int c) {
0755:                return (char) (((c - 0x00010000) & 0x3FF) + 0xDC00);
0756:            }
0757:
0758:            /**
0759:             * Returns whether the given character is a high surrogate
0760:             *
0761:             * @param c The character to check.
0762:             */
0763:            public static boolean isHighSurrogate(int c) {
0764:                return (0xD800 <= c && c <= 0xDBFF);
0765:            }
0766:
0767:            /**
0768:             * Returns whether the given character is a low surrogate
0769:             *
0770:             * @param c The character to check.
0771:             */
0772:            public static boolean isLowSurrogate(int c) {
0773:                return (0xDC00 <= c && c <= 0xDFFF);
0774:            }
0775:
0776:            /**
0777:             * Returns true if the specified character is valid. This method
0778:             * also checks the surrogate character range from 0x10000 to 0x10FFFF.
0779:             * <p>
0780:             * If the program chooses to apply the mask directly to the
0781:             * <code>CHARS</code> array, then they are responsible for checking
0782:             * the surrogate character range.
0783:             *
0784:             * @param c The character to check.
0785:             */
0786:            public static boolean isValid(int c) {
0787:                return (c < 0x10000 && (CHARS[c] & MASK_VALID) != 0)
0788:                        || (0x10000 <= c && c <= 0x10FFFF);
0789:            } // isValid(int):boolean
0790:
0791:            /**
0792:             * Returns true if the specified character is invalid.
0793:             *
0794:             * @param c The character to check.
0795:             */
0796:            public static boolean isInvalid(int c) {
0797:                return !isValid(c);
0798:            } // isInvalid(int):boolean
0799:
0800:            /**
0801:             * Returns true if the specified character can be considered content.
0802:             *
0803:             * @param c The character to check.
0804:             */
0805:            public static boolean isContent(int c) {
0806:                return (c < 0x10000 && (CHARS[c] & MASK_CONTENT) != 0)
0807:                        || (0x10000 <= c && c <= 0x10FFFF);
0808:            } // isContent(int):boolean
0809:
0810:            /**
0811:             * Returns true if the specified character can be considered markup.
0812:             * Markup characters include '&lt;', '&amp;', and '%'.
0813:             *
0814:             * @param c The character to check.
0815:             */
0816:            public static boolean isMarkup(int c) {
0817:                return c == '<' || c == '&' || c == '%';
0818:            } // isMarkup(int):boolean
0819:
0820:            /**
0821:             * Returns true if the specified character is a space character
0822:             * as defined by production [3] in the XML 1.0 specification.
0823:             *
0824:             * @param c The character to check.
0825:             */
0826:            public static boolean isSpace(int c) {
0827:                return c <= 0x20 && (CHARS[c] & MASK_SPACE) != 0;
0828:            } // isSpace(int):boolean
0829:
0830:            /**
0831:             * Returns true if the specified character is a valid name start
0832:             * character as defined by production [5] in the XML 1.0
0833:             * specification.
0834:             *
0835:             * @param c The character to check.
0836:             */
0837:            public static boolean isNameStart(int c) {
0838:                return c < 0x10000 && (CHARS[c] & MASK_NAME_START) != 0;
0839:            } // isNameStart(int):boolean
0840:
0841:            /**
0842:             * Returns true if the specified character is a valid name
0843:             * character as defined by production [4] in the XML 1.0
0844:             * specification.
0845:             *
0846:             * @param c The character to check.
0847:             */
0848:            public static boolean isName(int c) {
0849:                return c < 0x10000 && (CHARS[c] & MASK_NAME) != 0;
0850:            } // isName(int):boolean
0851:
0852:            /**
0853:             * Returns true if the specified character is a valid NCName start
0854:             * character as defined by production [4] in Namespaces in XML
0855:             * recommendation.
0856:             *
0857:             * @param c The character to check.
0858:             */
0859:            public static boolean isNCNameStart(int c) {
0860:                return c < 0x10000 && (CHARS[c] & MASK_NCNAME_START) != 0;
0861:            } // isNCNameStart(int):boolean
0862:
0863:            /**
0864:             * Returns true if the specified character is a valid NCName
0865:             * character as defined by production [5] in Namespaces in XML
0866:             * recommendation.
0867:             *
0868:             * @param c The character to check.
0869:             */
0870:            public static boolean isNCName(int c) {
0871:                return c < 0x10000 && (CHARS[c] & MASK_NCNAME) != 0;
0872:            } // isNCName(int):boolean
0873:
0874:            /**
0875:             * Returns true if the specified character is a valid Pubid
0876:             * character as defined by production [13] in the XML 1.0
0877:             * specification.
0878:             *
0879:             * @param c The character to check.
0880:             */
0881:            public static boolean isPubid(int c) {
0882:                return c < 0x10000 && (CHARS[c] & MASK_PUBID) != 0;
0883:            } // isPubid(int):boolean
0884:
0885:            /*
0886:             * [5] Name ::= (Letter | '_' | ':') (NameChar)*
0887:             */
0888:            /**
0889:             * Check to see if a string is a valid Name according to [5]
0890:             * in the XML 1.0 Recommendation
0891:             *
0892:             * @param name string to check
0893:             * @return true if name is a valid Name
0894:             */
0895:            public static boolean isValidName(String name) {
0896:                if (name.length() == 0)
0897:                    return false;
0898:                char ch = name.charAt(0);
0899:                if (isNameStart(ch) == false)
0900:                    return false;
0901:                for (int i = 1; i < name.length(); i++) {
0902:                    ch = name.charAt(i);
0903:                    if (isName(ch) == false) {
0904:                        return false;
0905:                    }
0906:                }
0907:                return true;
0908:            } // isValidName(String):boolean
0909:
0910:            /*
0911:             * from the namespace rec
0912:             * [4] NCName ::= (Letter | '_') (NCNameChar)*
0913:             */
0914:            /**
0915:             * Check to see if a string is a valid NCName according to [4]
0916:             * from the XML Namespaces 1.0 Recommendation
0917:             *
0918:             * @param name string to check
0919:             * @return true if name is a valid NCName
0920:             */
0921:            public static boolean isValidNCName(String ncName) {
0922:                if (ncName.length() == 0)
0923:                    return false;
0924:                char ch = ncName.charAt(0);
0925:                if (isNCNameStart(ch) == false)
0926:                    return false;
0927:                for (int i = 1; i < ncName.length(); i++) {
0928:                    ch = ncName.charAt(i);
0929:                    if (isNCName(ch) == false) {
0930:                        return false;
0931:                    }
0932:                }
0933:                return true;
0934:            } // isValidNCName(String):boolean
0935:
0936:            /*
0937:             * [7] Nmtoken ::= (NameChar)+
0938:             */
0939:            /**
0940:             * Check to see if a string is a valid Nmtoken according to [7]
0941:             * in the XML 1.0 Recommendation
0942:             *
0943:             * @param nmtoken string to check
0944:             * @return true if nmtoken is a valid Nmtoken 
0945:             */
0946:            public static boolean isValidNmtoken(String nmtoken) {
0947:                if (nmtoken.length() == 0)
0948:                    return false;
0949:                for (int i = 0; i < nmtoken.length(); i++) {
0950:                    char ch = nmtoken.charAt(i);
0951:                    if (!isName(ch)) {
0952:                        return false;
0953:                    }
0954:                }
0955:                return true;
0956:            } // isValidName(String):boolean
0957:
0958:            // encodings
0959:
0960:            /**
0961:             * Returns true if the encoding name is a valid IANA encoding.
0962:             * This method does not verify that there is a decoder available
0963:             * for this encoding, only that the characters are valid for an
0964:             * IANA encoding name.
0965:             *
0966:             * @param ianaEncoding The IANA encoding name.
0967:             */
0968:            public static boolean isValidIANAEncoding(String ianaEncoding) {
0969:                if (ianaEncoding != null) {
0970:                    int length = ianaEncoding.length();
0971:                    if (length > 0) {
0972:                        char c = ianaEncoding.charAt(0);
0973:                        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
0974:                            for (int i = 1; i < length; i++) {
0975:                                c = ianaEncoding.charAt(i);
0976:                                if ((c < 'A' || c > 'Z')
0977:                                        && (c < 'a' || c > 'z')
0978:                                        && (c < '0' || c > '9') && c != '.'
0979:                                        && c != '_' && c != '-') {
0980:                                    return false;
0981:                                }
0982:                            }
0983:                            return true;
0984:                        }
0985:                    }
0986:                }
0987:                return false;
0988:            } // isValidIANAEncoding(String):boolean
0989:
0990:            /**
0991:             * Returns true if the encoding name is a valid Java encoding.
0992:             * This method does not verify that there is a decoder available
0993:             * for this encoding, only that the characters are valid for an
0994:             * Java encoding name.
0995:             *
0996:             * @param javaEncoding The Java encoding name.
0997:             */
0998:            public static boolean isValidJavaEncoding(String javaEncoding) {
0999:                if (javaEncoding != null) {
1000:                    int length = javaEncoding.length();
1001:                    if (length > 0) {
1002:                        for (int i = 1; i < length; i++) {
1003:                            char c = javaEncoding.charAt(i);
1004:                            if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z')
1005:                                    && (c < '0' || c > '9') && c != '.'
1006:                                    && c != '_' && c != '-') {
1007:                                return false;
1008:                            }
1009:                        }
1010:                        return true;
1011:                    }
1012:                }
1013:                return false;
1014:            } // isValidIANAEncoding(String):boolean
1015:
1016:        } // class XMLChar
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.