← Back to branch summary

~vcs-imports/xena/trunk

« back to all changes in this revision

Viewing changes to ext/src/xerces-2_9_1/src/org/apache/xerces/util/XMLChar.java

  • Committer: matthewoliver
  • Date: 2009-12-10 03:18:07 UTC
  • Revision ID: vcs-imports@canonical.com-20091210031807-l086qguzdlljtkl9
Merged Xena Testing into Xena Stable for the Xena 5 release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/src/xerces-2_9_1/src/org/apache/xerces/util/XMLChar.java
 
1
/*
 
2
 * Licensed to the Apache Software Foundation (ASF) under one or more
 
3
 * contributor license agreements.  See the NOTICE file distributed with
 
4
 * this work for additional information regarding copyright ownership.
 
5
 * The ASF licenses this file to You under the Apache License, Version 2.0
 
6
 * (the "License"); you may not use this file except in compliance with
 
7
 * the License.  You may obtain a copy of the License at
 
8
 * 
 
9
 *      http://www.apache.org/licenses/LICENSE-2.0
 
10
 * 
 
11
 * Unless required by applicable law or agreed to in writing, software
 
12
 * distributed under the License is distributed on an "AS IS" BASIS,
 
13
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
14
 * See the License for the specific language governing permissions and
 
15
 * limitations under the License.
 
16
 */
 
17
 
 
18
package org.apache.xerces.util;
 
19
 
 
20
import java.util.Arrays;
 
21
 
 
22
/**
 
23
 * This class defines the basic XML character properties. The data
 
24
 * in this class can be used to verify that a character is a valid
 
25
 * XML character or if the character is a space, name start, or name
 
26
 * character.
 
27
 * <p>
 
28
 * A series of convenience methods are supplied to ease the burden
 
29
 * of the developer. Because inlining the checks can improve per
 
30
 * character performance, the tables of character properties are
 
31
 * public. Using the character as an index into the <code>CHARS</code>
 
32
 * array and applying the appropriate mask flag (e.g.
 
33
 * <code>MASK_VALID</code>), yields the same results as calling the
 
34
 * convenience methods. There is one exception: check the comments
 
35
 * for the <code>isValid</code> method for details.
 
36
 *
 
37
 * @author Glenn Marcy, IBM
 
38
 * @author Andy Clark, IBM
 
39
 * @author Eric Ye, IBM
 
40
 * @author Arnaud  Le Hors, IBM
 
41
 * @author Michael Glavassevich, IBM
 
42
 * @author Rahul Srivastava, Sun Microsystems Inc.
 
43
 *
 
44
 * @version $Id: XMLChar.java,v 1.2 2009/12/10 03:18:07 matthewoliver Exp $
 
45
 */
 
46
public class XMLChar {
 
47
 
 
48
    //
 
49
    // Constants
 
50
    //
 
51
 
 
52
    /** Character flags. */
 
53
    private static final byte[] CHARS = new byte[1 << 16];
 
54
 
 
55
    /** Valid character mask. */
 
56
    public static final int MASK_VALID = 0x01;
 
57
 
 
58
    /** Space character mask. */
 
59
    public static final int MASK_SPACE = 0x02;
 
60
 
 
61
    /** Name start character mask. */
 
62
    public static final int MASK_NAME_START = 0x04;
 
63
 
 
64
    /** Name character mask. */
 
65
    public static final int MASK_NAME = 0x08;
 
66
 
 
67
    /** Pubid character mask. */
 
68
    public static final int MASK_PUBID = 0x10;
 
69
    
 
70
    /** 
 
71
     * Content character mask. Special characters are those that can
 
72
     * be considered the start of markup, such as '&lt;' and '&amp;'. 
 
73
     * The various newline characters are considered special as well.
 
74
     * All other valid XML characters can be considered content.
 
75
     * <p>
 
76
     * This is an optimization for the inner loop of character scanning.
 
77
     */
 
78
    public static final int MASK_CONTENT = 0x20;
 
79
 
 
80
    /** NCName start character mask. */
 
81
    public static final int MASK_NCNAME_START = 0x40;
 
82
 
 
83
    /** NCName character mask. */
 
84
    public static final int MASK_NCNAME = 0x80;
 
85
 
 
86
    //
 
87
    // Static initialization
 
88
    //
 
89
 
 
90
    static {
 
91
        
 
92
        // Initializing the Character Flag Array
 
93
        // Code generated by: XMLCharGenerator.
 
94
        
 
95
        CHARS[9] = 35;
 
96
        CHARS[10] = 19;
 
97
        CHARS[13] = 19;
 
98
        CHARS[32] = 51;
 
99
        CHARS[33] = 49;
 
100
        CHARS[34] = 33;
 
101
        Arrays.fill(CHARS, 35, 38, (byte) 49 ); // Fill 3 of value (byte) 49
 
102
        CHARS[38] = 1;
 
103
        Arrays.fill(CHARS, 39, 45, (byte) 49 ); // Fill 6 of value (byte) 49
 
104
        Arrays.fill(CHARS, 45, 47, (byte) -71 ); // Fill 2 of value (byte) -71
 
105
        CHARS[47] = 49;
 
106
        Arrays.fill(CHARS, 48, 58, (byte) -71 ); // Fill 10 of value (byte) -71
 
107
        CHARS[58] = 61;
 
108
        CHARS[59] = 49;
 
109
        CHARS[60] = 1;
 
110
        CHARS[61] = 49;
 
111
        CHARS[62] = 33;
 
112
        Arrays.fill(CHARS, 63, 65, (byte) 49 ); // Fill 2 of value (byte) 49
 
113
        Arrays.fill(CHARS, 65, 91, (byte) -3 ); // Fill 26 of value (byte) -3
 
114
        Arrays.fill(CHARS, 91, 93, (byte) 33 ); // Fill 2 of value (byte) 33
 
115
        CHARS[93] = 1;
 
116
        CHARS[94] = 33;
 
117
        CHARS[95] = -3;
 
118
        CHARS[96] = 33;
 
119
        Arrays.fill(CHARS, 97, 123, (byte) -3 ); // Fill 26 of value (byte) -3
 
120
        Arrays.fill(CHARS, 123, 183, (byte) 33 ); // Fill 60 of value (byte) 33
 
121
        CHARS[183] = -87;
 
122
        Arrays.fill(CHARS, 184, 192, (byte) 33 ); // Fill 8 of value (byte) 33
 
123
        Arrays.fill(CHARS, 192, 215, (byte) -19 ); // Fill 23 of value (byte) -19
 
124
        CHARS[215] = 33;
 
125
        Arrays.fill(CHARS, 216, 247, (byte) -19 ); // Fill 31 of value (byte) -19
 
126
        CHARS[247] = 33;
 
127
        Arrays.fill(CHARS, 248, 306, (byte) -19 ); // Fill 58 of value (byte) -19
 
128
        Arrays.fill(CHARS, 306, 308, (byte) 33 ); // Fill 2 of value (byte) 33
 
129
        Arrays.fill(CHARS, 308, 319, (byte) -19 ); // Fill 11 of value (byte) -19
 
130
        Arrays.fill(CHARS, 319, 321, (byte) 33 ); // Fill 2 of value (byte) 33
 
131
        Arrays.fill(CHARS, 321, 329, (byte) -19 ); // Fill 8 of value (byte) -19
 
132
        CHARS[329] = 33;
 
133
        Arrays.fill(CHARS, 330, 383, (byte) -19 ); // Fill 53 of value (byte) -19
 
134
        CHARS[383] = 33;
 
135
        Arrays.fill(CHARS, 384, 452, (byte) -19 ); // Fill 68 of value (byte) -19
 
136
        Arrays.fill(CHARS, 452, 461, (byte) 33 ); // Fill 9 of value (byte) 33
 
137
        Arrays.fill(CHARS, 461, 497, (byte) -19 ); // Fill 36 of value (byte) -19
 
138
        Arrays.fill(CHARS, 497, 500, (byte) 33 ); // Fill 3 of value (byte) 33
 
139
        Arrays.fill(CHARS, 500, 502, (byte) -19 ); // Fill 2 of value (byte) -19
 
140
        Arrays.fill(CHARS, 502, 506, (byte) 33 ); // Fill 4 of value (byte) 33
 
141
        Arrays.fill(CHARS, 506, 536, (byte) -19 ); // Fill 30 of value (byte) -19
 
142
        Arrays.fill(CHARS, 536, 592, (byte) 33 ); // Fill 56 of value (byte) 33
 
143
        Arrays.fill(CHARS, 592, 681, (byte) -19 ); // Fill 89 of value (byte) -19
 
144
        Arrays.fill(CHARS, 681, 699, (byte) 33 ); // Fill 18 of value (byte) 33
 
145
        Arrays.fill(CHARS, 699, 706, (byte) -19 ); // Fill 7 of value (byte) -19
 
146
        Arrays.fill(CHARS, 706, 720, (byte) 33 ); // Fill 14 of value (byte) 33
 
147
        Arrays.fill(CHARS, 720, 722, (byte) -87 ); // Fill 2 of value (byte) -87
 
148
        Arrays.fill(CHARS, 722, 768, (byte) 33 ); // Fill 46 of value (byte) 33
 
149
        Arrays.fill(CHARS, 768, 838, (byte) -87 ); // Fill 70 of value (byte) -87
 
150
        Arrays.fill(CHARS, 838, 864, (byte) 33 ); // Fill 26 of value (byte) 33
 
151
        Arrays.fill(CHARS, 864, 866, (byte) -87 ); // Fill 2 of value (byte) -87
 
152
        Arrays.fill(CHARS, 866, 902, (byte) 33 ); // Fill 36 of value (byte) 33
 
153
        CHARS[902] = -19;
 
154
        CHARS[903] = -87;
 
155
        Arrays.fill(CHARS, 904, 907, (byte) -19 ); // Fill 3 of value (byte) -19
 
156
        CHARS[907] = 33;
 
157
        CHARS[908] = -19;
 
158
        CHARS[909] = 33;
 
159
        Arrays.fill(CHARS, 910, 930, (byte) -19 ); // Fill 20 of value (byte) -19
 
160
        CHARS[930] = 33;
 
161
        Arrays.fill(CHARS, 931, 975, (byte) -19 ); // Fill 44 of value (byte) -19
 
162
        CHARS[975] = 33;
 
163
        Arrays.fill(CHARS, 976, 983, (byte) -19 ); // Fill 7 of value (byte) -19
 
164
        Arrays.fill(CHARS, 983, 986, (byte) 33 ); // Fill 3 of value (byte) 33
 
165
        CHARS[986] = -19;
 
166
        CHARS[987] = 33;
 
167
        CHARS[988] = -19;
 
168
        CHARS[989] = 33;
 
169
        CHARS[990] = -19;
 
170
        CHARS[991] = 33;
 
171
        CHARS[992] = -19;
 
172
        CHARS[993] = 33;
 
173
        Arrays.fill(CHARS, 994, 1012, (byte) -19 ); // Fill 18 of value (byte) -19
 
174
        Arrays.fill(CHARS, 1012, 1025, (byte) 33 ); // Fill 13 of value (byte) 33
 
175
        Arrays.fill(CHARS, 1025, 1037, (byte) -19 ); // Fill 12 of value (byte) -19
 
176
        CHARS[1037] = 33;
 
177
        Arrays.fill(CHARS, 1038, 1104, (byte) -19 ); // Fill 66 of value (byte) -19
 
178
        CHARS[1104] = 33;
 
179
        Arrays.fill(CHARS, 1105, 1117, (byte) -19 ); // Fill 12 of value (byte) -19
 
180
        CHARS[1117] = 33;
 
181
        Arrays.fill(CHARS, 1118, 1154, (byte) -19 ); // Fill 36 of value (byte) -19
 
182
        CHARS[1154] = 33;
 
183
        Arrays.fill(CHARS, 1155, 1159, (byte) -87 ); // Fill 4 of value (byte) -87
 
184
        Arrays.fill(CHARS, 1159, 1168, (byte) 33 ); // Fill 9 of value (byte) 33
 
185
        Arrays.fill(CHARS, 1168, 1221, (byte) -19 ); // Fill 53 of value (byte) -19
 
186
        Arrays.fill(CHARS, 1221, 1223, (byte) 33 ); // Fill 2 of value (byte) 33
 
187
        Arrays.fill(CHARS, 1223, 1225, (byte) -19 ); // Fill 2 of value (byte) -19
 
188
        Arrays.fill(CHARS, 1225, 1227, (byte) 33 ); // Fill 2 of value (byte) 33
 
189
        Arrays.fill(CHARS, 1227, 1229, (byte) -19 ); // Fill 2 of value (byte) -19
 
190
        Arrays.fill(CHARS, 1229, 1232, (byte) 33 ); // Fill 3 of value (byte) 33
 
191
        Arrays.fill(CHARS, 1232, 1260, (byte) -19 ); // Fill 28 of value (byte) -19
 
192
        Arrays.fill(CHARS, 1260, 1262, (byte) 33 ); // Fill 2 of value (byte) 33
 
193
        Arrays.fill(CHARS, 1262, 1270, (byte) -19 ); // Fill 8 of value (byte) -19
 
194
        Arrays.fill(CHARS, 1270, 1272, (byte) 33 ); // Fill 2 of value (byte) 33
 
195
        Arrays.fill(CHARS, 1272, 1274, (byte) -19 ); // Fill 2 of value (byte) -19
 
196
        Arrays.fill(CHARS, 1274, 1329, (byte) 33 ); // Fill 55 of value (byte) 33
 
197
        Arrays.fill(CHARS, 1329, 1367, (byte) -19 ); // Fill 38 of value (byte) -19
 
198
        Arrays.fill(CHARS, 1367, 1369, (byte) 33 ); // Fill 2 of value (byte) 33
 
199
        CHARS[1369] = -19;
 
200
        Arrays.fill(CHARS, 1370, 1377, (byte) 33 ); // Fill 7 of value (byte) 33
 
201
        Arrays.fill(CHARS, 1377, 1415, (byte) -19 ); // Fill 38 of value (byte) -19
 
202
        Arrays.fill(CHARS, 1415, 1425, (byte) 33 ); // Fill 10 of value (byte) 33
 
203
        Arrays.fill(CHARS, 1425, 1442, (byte) -87 ); // Fill 17 of value (byte) -87
 
204
        CHARS[1442] = 33;
 
205
        Arrays.fill(CHARS, 1443, 1466, (byte) -87 ); // Fill 23 of value (byte) -87
 
206
        CHARS[1466] = 33;
 
207
        Arrays.fill(CHARS, 1467, 1470, (byte) -87 ); // Fill 3 of value (byte) -87
 
208
        CHARS[1470] = 33;
 
209
        CHARS[1471] = -87;
 
210
        CHARS[1472] = 33;
 
211
        Arrays.fill(CHARS, 1473, 1475, (byte) -87 ); // Fill 2 of value (byte) -87
 
212
        CHARS[1475] = 33;
 
213
        CHARS[1476] = -87;
 
214
        Arrays.fill(CHARS, 1477, 1488, (byte) 33 ); // Fill 11 of value (byte) 33
 
215
        Arrays.fill(CHARS, 1488, 1515, (byte) -19 ); // Fill 27 of value (byte) -19
 
216
        Arrays.fill(CHARS, 1515, 1520, (byte) 33 ); // Fill 5 of value (byte) 33
 
217
        Arrays.fill(CHARS, 1520, 1523, (byte) -19 ); // Fill 3 of value (byte) -19
 
218
        Arrays.fill(CHARS, 1523, 1569, (byte) 33 ); // Fill 46 of value (byte) 33
 
219
        Arrays.fill(CHARS, 1569, 1595, (byte) -19 ); // Fill 26 of value (byte) -19
 
220
        Arrays.fill(CHARS, 1595, 1600, (byte) 33 ); // Fill 5 of value (byte) 33
 
221
        CHARS[1600] = -87;
 
222
        Arrays.fill(CHARS, 1601, 1611, (byte) -19 ); // Fill 10 of value (byte) -19
 
223
        Arrays.fill(CHARS, 1611, 1619, (byte) -87 ); // Fill 8 of value (byte) -87
 
224
        Arrays.fill(CHARS, 1619, 1632, (byte) 33 ); // Fill 13 of value (byte) 33
 
225
        Arrays.fill(CHARS, 1632, 1642, (byte) -87 ); // Fill 10 of value (byte) -87
 
226
        Arrays.fill(CHARS, 1642, 1648, (byte) 33 ); // Fill 6 of value (byte) 33
 
227
        CHARS[1648] = -87;
 
228
        Arrays.fill(CHARS, 1649, 1720, (byte) -19 ); // Fill 71 of value (byte) -19
 
229
        Arrays.fill(CHARS, 1720, 1722, (byte) 33 ); // Fill 2 of value (byte) 33
 
230
        Arrays.fill(CHARS, 1722, 1727, (byte) -19 ); // Fill 5 of value (byte) -19
 
231
        CHARS[1727] = 33;
 
232
        Arrays.fill(CHARS, 1728, 1743, (byte) -19 ); // Fill 15 of value (byte) -19
 
233
        CHARS[1743] = 33;
 
234
        Arrays.fill(CHARS, 1744, 1748, (byte) -19 ); // Fill 4 of value (byte) -19
 
235
        CHARS[1748] = 33;
 
236
        CHARS[1749] = -19;
 
237
        Arrays.fill(CHARS, 1750, 1765, (byte) -87 ); // Fill 15 of value (byte) -87
 
238
        Arrays.fill(CHARS, 1765, 1767, (byte) -19 ); // Fill 2 of value (byte) -19
 
239
        Arrays.fill(CHARS, 1767, 1769, (byte) -87 ); // Fill 2 of value (byte) -87
 
240
        CHARS[1769] = 33;
 
241
        Arrays.fill(CHARS, 1770, 1774, (byte) -87 ); // Fill 4 of value (byte) -87
 
242
        Arrays.fill(CHARS, 1774, 1776, (byte) 33 ); // Fill 2 of value (byte) 33
 
243
        Arrays.fill(CHARS, 1776, 1786, (byte) -87 ); // Fill 10 of value (byte) -87
 
244
        Arrays.fill(CHARS, 1786, 2305, (byte) 33 ); // Fill 519 of value (byte) 33
 
245
        Arrays.fill(CHARS, 2305, 2308, (byte) -87 ); // Fill 3 of value (byte) -87
 
246
        CHARS[2308] = 33;
 
247
        Arrays.fill(CHARS, 2309, 2362, (byte) -19 ); // Fill 53 of value (byte) -19
 
248
        Arrays.fill(CHARS, 2362, 2364, (byte) 33 ); // Fill 2 of value (byte) 33
 
249
        CHARS[2364] = -87;
 
250
        CHARS[2365] = -19;
 
251
        Arrays.fill(CHARS, 2366, 2382, (byte) -87 ); // Fill 16 of value (byte) -87
 
252
        Arrays.fill(CHARS, 2382, 2385, (byte) 33 ); // Fill 3 of value (byte) 33
 
253
        Arrays.fill(CHARS, 2385, 2389, (byte) -87 ); // Fill 4 of value (byte) -87
 
254
        Arrays.fill(CHARS, 2389, 2392, (byte) 33 ); // Fill 3 of value (byte) 33
 
255
        Arrays.fill(CHARS, 2392, 2402, (byte) -19 ); // Fill 10 of value (byte) -19
 
256
        Arrays.fill(CHARS, 2402, 2404, (byte) -87 ); // Fill 2 of value (byte) -87
 
257
        Arrays.fill(CHARS, 2404, 2406, (byte) 33 ); // Fill 2 of value (byte) 33
 
258
        Arrays.fill(CHARS, 2406, 2416, (byte) -87 ); // Fill 10 of value (byte) -87
 
259
        Arrays.fill(CHARS, 2416, 2433, (byte) 33 ); // Fill 17 of value (byte) 33
 
260
        Arrays.fill(CHARS, 2433, 2436, (byte) -87 ); // Fill 3 of value (byte) -87
 
261
        CHARS[2436] = 33;
 
262
        Arrays.fill(CHARS, 2437, 2445, (byte) -19 ); // Fill 8 of value (byte) -19
 
263
        Arrays.fill(CHARS, 2445, 2447, (byte) 33 ); // Fill 2 of value (byte) 33
 
264
        Arrays.fill(CHARS, 2447, 2449, (byte) -19 ); // Fill 2 of value (byte) -19
 
265
        Arrays.fill(CHARS, 2449, 2451, (byte) 33 ); // Fill 2 of value (byte) 33
 
266
        Arrays.fill(CHARS, 2451, 2473, (byte) -19 ); // Fill 22 of value (byte) -19
 
267
        CHARS[2473] = 33;
 
268
        Arrays.fill(CHARS, 2474, 2481, (byte) -19 ); // Fill 7 of value (byte) -19
 
269
        CHARS[2481] = 33;
 
270
        CHARS[2482] = -19;
 
271
        Arrays.fill(CHARS, 2483, 2486, (byte) 33 ); // Fill 3 of value (byte) 33
 
272
        Arrays.fill(CHARS, 2486, 2490, (byte) -19 ); // Fill 4 of value (byte) -19
 
273
        Arrays.fill(CHARS, 2490, 2492, (byte) 33 ); // Fill 2 of value (byte) 33
 
274
        CHARS[2492] = -87;
 
275
        CHARS[2493] = 33;
 
276
        Arrays.fill(CHARS, 2494, 2501, (byte) -87 ); // Fill 7 of value (byte) -87
 
277
        Arrays.fill(CHARS, 2501, 2503, (byte) 33 ); // Fill 2 of value (byte) 33
 
278
        Arrays.fill(CHARS, 2503, 2505, (byte) -87 ); // Fill 2 of value (byte) -87
 
279
        Arrays.fill(CHARS, 2505, 2507, (byte) 33 ); // Fill 2 of value (byte) 33
 
280
        Arrays.fill(CHARS, 2507, 2510, (byte) -87 ); // Fill 3 of value (byte) -87
 
281
        Arrays.fill(CHARS, 2510, 2519, (byte) 33 ); // Fill 9 of value (byte) 33
 
282
        CHARS[2519] = -87;
 
283
        Arrays.fill(CHARS, 2520, 2524, (byte) 33 ); // Fill 4 of value (byte) 33
 
284
        Arrays.fill(CHARS, 2524, 2526, (byte) -19 ); // Fill 2 of value (byte) -19
 
285
        CHARS[2526] = 33;
 
286
        Arrays.fill(CHARS, 2527, 2530, (byte) -19 ); // Fill 3 of value (byte) -19
 
287
        Arrays.fill(CHARS, 2530, 2532, (byte) -87 ); // Fill 2 of value (byte) -87
 
288
        Arrays.fill(CHARS, 2532, 2534, (byte) 33 ); // Fill 2 of value (byte) 33
 
289
        Arrays.fill(CHARS, 2534, 2544, (byte) -87 ); // Fill 10 of value (byte) -87
 
290
        Arrays.fill(CHARS, 2544, 2546, (byte) -19 ); // Fill 2 of value (byte) -19
 
291
        Arrays.fill(CHARS, 2546, 2562, (byte) 33 ); // Fill 16 of value (byte) 33
 
292
        CHARS[2562] = -87;
 
293
        Arrays.fill(CHARS, 2563, 2565, (byte) 33 ); // Fill 2 of value (byte) 33
 
294
        Arrays.fill(CHARS, 2565, 2571, (byte) -19 ); // Fill 6 of value (byte) -19
 
295
        Arrays.fill(CHARS, 2571, 2575, (byte) 33 ); // Fill 4 of value (byte) 33
 
296
        Arrays.fill(CHARS, 2575, 2577, (byte) -19 ); // Fill 2 of value (byte) -19
 
297
        Arrays.fill(CHARS, 2577, 2579, (byte) 33 ); // Fill 2 of value (byte) 33
 
298
        Arrays.fill(CHARS, 2579, 2601, (byte) -19 ); // Fill 22 of value (byte) -19
 
299
        CHARS[2601] = 33;
 
300
        Arrays.fill(CHARS, 2602, 2609, (byte) -19 ); // Fill 7 of value (byte) -19
 
301
        CHARS[2609] = 33;
 
302
        Arrays.fill(CHARS, 2610, 2612, (byte) -19 ); // Fill 2 of value (byte) -19
 
303
        CHARS[2612] = 33;
 
304
        Arrays.fill(CHARS, 2613, 2615, (byte) -19 ); // Fill 2 of value (byte) -19
 
305
        CHARS[2615] = 33;
 
306
        Arrays.fill(CHARS, 2616, 2618, (byte) -19 ); // Fill 2 of value (byte) -19
 
307
        Arrays.fill(CHARS, 2618, 2620, (byte) 33 ); // Fill 2 of value (byte) 33
 
308
        CHARS[2620] = -87;
 
309
        CHARS[2621] = 33;
 
310
        Arrays.fill(CHARS, 2622, 2627, (byte) -87 ); // Fill 5 of value (byte) -87
 
311
        Arrays.fill(CHARS, 2627, 2631, (byte) 33 ); // Fill 4 of value (byte) 33
 
312
        Arrays.fill(CHARS, 2631, 2633, (byte) -87 ); // Fill 2 of value (byte) -87
 
313
        Arrays.fill(CHARS, 2633, 2635, (byte) 33 ); // Fill 2 of value (byte) 33
 
314
        Arrays.fill(CHARS, 2635, 2638, (byte) -87 ); // Fill 3 of value (byte) -87
 
315
        Arrays.fill(CHARS, 2638, 2649, (byte) 33 ); // Fill 11 of value (byte) 33
 
316
        Arrays.fill(CHARS, 2649, 2653, (byte) -19 ); // Fill 4 of value (byte) -19
 
317
        CHARS[2653] = 33;
 
318
        CHARS[2654] = -19;
 
319
        Arrays.fill(CHARS, 2655, 2662, (byte) 33 ); // Fill 7 of value (byte) 33
 
320
        Arrays.fill(CHARS, 2662, 2674, (byte) -87 ); // Fill 12 of value (byte) -87
 
321
        Arrays.fill(CHARS, 2674, 2677, (byte) -19 ); // Fill 3 of value (byte) -19
 
322
        Arrays.fill(CHARS, 2677, 2689, (byte) 33 ); // Fill 12 of value (byte) 33
 
323
        Arrays.fill(CHARS, 2689, 2692, (byte) -87 ); // Fill 3 of value (byte) -87
 
324
        CHARS[2692] = 33;
 
325
        Arrays.fill(CHARS, 2693, 2700, (byte) -19 ); // Fill 7 of value (byte) -19
 
326
        CHARS[2700] = 33;
 
327
        CHARS[2701] = -19;
 
328
        CHARS[2702] = 33;
 
329
        Arrays.fill(CHARS, 2703, 2706, (byte) -19 ); // Fill 3 of value (byte) -19
 
330
        CHARS[2706] = 33;
 
331
        Arrays.fill(CHARS, 2707, 2729, (byte) -19 ); // Fill 22 of value (byte) -19
 
332
        CHARS[2729] = 33;
 
333
        Arrays.fill(CHARS, 2730, 2737, (byte) -19 ); // Fill 7 of value (byte) -19
 
334
        CHARS[2737] = 33;
 
335
        Arrays.fill(CHARS, 2738, 2740, (byte) -19 ); // Fill 2 of value (byte) -19
 
336
        CHARS[2740] = 33;
 
337
        Arrays.fill(CHARS, 2741, 2746, (byte) -19 ); // Fill 5 of value (byte) -19
 
338
        Arrays.fill(CHARS, 2746, 2748, (byte) 33 ); // Fill 2 of value (byte) 33
 
339
        CHARS[2748] = -87;
 
340
        CHARS[2749] = -19;
 
341
        Arrays.fill(CHARS, 2750, 2758, (byte) -87 ); // Fill 8 of value (byte) -87
 
342
        CHARS[2758] = 33;
 
343
        Arrays.fill(CHARS, 2759, 2762, (byte) -87 ); // Fill 3 of value (byte) -87
 
344
        CHARS[2762] = 33;
 
345
        Arrays.fill(CHARS, 2763, 2766, (byte) -87 ); // Fill 3 of value (byte) -87
 
346
        Arrays.fill(CHARS, 2766, 2784, (byte) 33 ); // Fill 18 of value (byte) 33
 
347
        CHARS[2784] = -19;
 
348
        Arrays.fill(CHARS, 2785, 2790, (byte) 33 ); // Fill 5 of value (byte) 33
 
349
        Arrays.fill(CHARS, 2790, 2800, (byte) -87 ); // Fill 10 of value (byte) -87
 
350
        Arrays.fill(CHARS, 2800, 2817, (byte) 33 ); // Fill 17 of value (byte) 33
 
351
        Arrays.fill(CHARS, 2817, 2820, (byte) -87 ); // Fill 3 of value (byte) -87
 
352
        CHARS[2820] = 33;
 
353
        Arrays.fill(CHARS, 2821, 2829, (byte) -19 ); // Fill 8 of value (byte) -19
 
354
        Arrays.fill(CHARS, 2829, 2831, (byte) 33 ); // Fill 2 of value (byte) 33
 
355
        Arrays.fill(CHARS, 2831, 2833, (byte) -19 ); // Fill 2 of value (byte) -19
 
356
        Arrays.fill(CHARS, 2833, 2835, (byte) 33 ); // Fill 2 of value (byte) 33
 
357
        Arrays.fill(CHARS, 2835, 2857, (byte) -19 ); // Fill 22 of value (byte) -19
 
358
        CHARS[2857] = 33;
 
359
        Arrays.fill(CHARS, 2858, 2865, (byte) -19 ); // Fill 7 of value (byte) -19
 
360
        CHARS[2865] = 33;
 
361
        Arrays.fill(CHARS, 2866, 2868, (byte) -19 ); // Fill 2 of value (byte) -19
 
362
        Arrays.fill(CHARS, 2868, 2870, (byte) 33 ); // Fill 2 of value (byte) 33
 
363
        Arrays.fill(CHARS, 2870, 2874, (byte) -19 ); // Fill 4 of value (byte) -19
 
364
        Arrays.fill(CHARS, 2874, 2876, (byte) 33 ); // Fill 2 of value (byte) 33
 
365
        CHARS[2876] = -87;
 
366
        CHARS[2877] = -19;
 
367
        Arrays.fill(CHARS, 2878, 2884, (byte) -87 ); // Fill 6 of value (byte) -87
 
368
        Arrays.fill(CHARS, 2884, 2887, (byte) 33 ); // Fill 3 of value (byte) 33
 
369
        Arrays.fill(CHARS, 2887, 2889, (byte) -87 ); // Fill 2 of value (byte) -87
 
370
        Arrays.fill(CHARS, 2889, 2891, (byte) 33 ); // Fill 2 of value (byte) 33
 
371
        Arrays.fill(CHARS, 2891, 2894, (byte) -87 ); // Fill 3 of value (byte) -87
 
372
        Arrays.fill(CHARS, 2894, 2902, (byte) 33 ); // Fill 8 of value (byte) 33
 
373
        Arrays.fill(CHARS, 2902, 2904, (byte) -87 ); // Fill 2 of value (byte) -87
 
374
        Arrays.fill(CHARS, 2904, 2908, (byte) 33 ); // Fill 4 of value (byte) 33
 
375
        Arrays.fill(CHARS, 2908, 2910, (byte) -19 ); // Fill 2 of value (byte) -19
 
376
        CHARS[2910] = 33;
 
377
        Arrays.fill(CHARS, 2911, 2914, (byte) -19 ); // Fill 3 of value (byte) -19
 
378
        Arrays.fill(CHARS, 2914, 2918, (byte) 33 ); // Fill 4 of value (byte) 33
 
379
        Arrays.fill(CHARS, 2918, 2928, (byte) -87 ); // Fill 10 of value (byte) -87
 
380
        Arrays.fill(CHARS, 2928, 2946, (byte) 33 ); // Fill 18 of value (byte) 33
 
381
        Arrays.fill(CHARS, 2946, 2948, (byte) -87 ); // Fill 2 of value (byte) -87
 
382
        CHARS[2948] = 33;
 
383
        Arrays.fill(CHARS, 2949, 2955, (byte) -19 ); // Fill 6 of value (byte) -19
 
384
        Arrays.fill(CHARS, 2955, 2958, (byte) 33 ); // Fill 3 of value (byte) 33
 
385
        Arrays.fill(CHARS, 2958, 2961, (byte) -19 ); // Fill 3 of value (byte) -19
 
386
        CHARS[2961] = 33;
 
387
        Arrays.fill(CHARS, 2962, 2966, (byte) -19 ); // Fill 4 of value (byte) -19
 
388
        Arrays.fill(CHARS, 2966, 2969, (byte) 33 ); // Fill 3 of value (byte) 33
 
389
        Arrays.fill(CHARS, 2969, 2971, (byte) -19 ); // Fill 2 of value (byte) -19
 
390
        CHARS[2971] = 33;
 
391
        CHARS[2972] = -19;
 
392
        CHARS[2973] = 33;
 
393
        Arrays.fill(CHARS, 2974, 2976, (byte) -19 ); // Fill 2 of value (byte) -19
 
394
        Arrays.fill(CHARS, 2976, 2979, (byte) 33 ); // Fill 3 of value (byte) 33
 
395
        Arrays.fill(CHARS, 2979, 2981, (byte) -19 ); // Fill 2 of value (byte) -19
 
396
        Arrays.fill(CHARS, 2981, 2984, (byte) 33 ); // Fill 3 of value (byte) 33
 
397
        Arrays.fill(CHARS, 2984, 2987, (byte) -19 ); // Fill 3 of value (byte) -19
 
398
        Arrays.fill(CHARS, 2987, 2990, (byte) 33 ); // Fill 3 of value (byte) 33
 
399
        Arrays.fill(CHARS, 2990, 2998, (byte) -19 ); // Fill 8 of value (byte) -19
 
400
        CHARS[2998] = 33;
 
401
        Arrays.fill(CHARS, 2999, 3002, (byte) -19 ); // Fill 3 of value (byte) -19
 
402
        Arrays.fill(CHARS, 3002, 3006, (byte) 33 ); // Fill 4 of value (byte) 33
 
403
        Arrays.fill(CHARS, 3006, 3011, (byte) -87 ); // Fill 5 of value (byte) -87
 
404
        Arrays.fill(CHARS, 3011, 3014, (byte) 33 ); // Fill 3 of value (byte) 33
 
405
        Arrays.fill(CHARS, 3014, 3017, (byte) -87 ); // Fill 3 of value (byte) -87
 
406
        CHARS[3017] = 33;
 
407
        Arrays.fill(CHARS, 3018, 3022, (byte) -87 ); // Fill 4 of value (byte) -87
 
408
        Arrays.fill(CHARS, 3022, 3031, (byte) 33 ); // Fill 9 of value (byte) 33
 
409
        CHARS[3031] = -87;
 
410
        Arrays.fill(CHARS, 3032, 3047, (byte) 33 ); // Fill 15 of value (byte) 33
 
411
        Arrays.fill(CHARS, 3047, 3056, (byte) -87 ); // Fill 9 of value (byte) -87
 
412
        Arrays.fill(CHARS, 3056, 3073, (byte) 33 ); // Fill 17 of value (byte) 33
 
413
        Arrays.fill(CHARS, 3073, 3076, (byte) -87 ); // Fill 3 of value (byte) -87
 
414
        CHARS[3076] = 33;
 
415
        Arrays.fill(CHARS, 3077, 3085, (byte) -19 ); // Fill 8 of value (byte) -19
 
416
        CHARS[3085] = 33;
 
417
        Arrays.fill(CHARS, 3086, 3089, (byte) -19 ); // Fill 3 of value (byte) -19
 
418
        CHARS[3089] = 33;
 
419
        Arrays.fill(CHARS, 3090, 3113, (byte) -19 ); // Fill 23 of value (byte) -19
 
420
        CHARS[3113] = 33;
 
421
        Arrays.fill(CHARS, 3114, 3124, (byte) -19 ); // Fill 10 of value (byte) -19
 
422
        CHARS[3124] = 33;
 
423
        Arrays.fill(CHARS, 3125, 3130, (byte) -19 ); // Fill 5 of value (byte) -19
 
424
        Arrays.fill(CHARS, 3130, 3134, (byte) 33 ); // Fill 4 of value (byte) 33
 
425
        Arrays.fill(CHARS, 3134, 3141, (byte) -87 ); // Fill 7 of value (byte) -87
 
426
        CHARS[3141] = 33;
 
427
        Arrays.fill(CHARS, 3142, 3145, (byte) -87 ); // Fill 3 of value (byte) -87
 
428
        CHARS[3145] = 33;
 
429
        Arrays.fill(CHARS, 3146, 3150, (byte) -87 ); // Fill 4 of value (byte) -87
 
430
        Arrays.fill(CHARS, 3150, 3157, (byte) 33 ); // Fill 7 of value (byte) 33
 
431
        Arrays.fill(CHARS, 3157, 3159, (byte) -87 ); // Fill 2 of value (byte) -87
 
432
        Arrays.fill(CHARS, 3159, 3168, (byte) 33 ); // Fill 9 of value (byte) 33
 
433
        Arrays.fill(CHARS, 3168, 3170, (byte) -19 ); // Fill 2 of value (byte) -19
 
434
        Arrays.fill(CHARS, 3170, 3174, (byte) 33 ); // Fill 4 of value (byte) 33
 
435
        Arrays.fill(CHARS, 3174, 3184, (byte) -87 ); // Fill 10 of value (byte) -87
 
436
        Arrays.fill(CHARS, 3184, 3202, (byte) 33 ); // Fill 18 of value (byte) 33
 
437
        Arrays.fill(CHARS, 3202, 3204, (byte) -87 ); // Fill 2 of value (byte) -87
 
438
        CHARS[3204] = 33;
 
439
        Arrays.fill(CHARS, 3205, 3213, (byte) -19 ); // Fill 8 of value (byte) -19
 
440
        CHARS[3213] = 33;
 
441
        Arrays.fill(CHARS, 3214, 3217, (byte) -19 ); // Fill 3 of value (byte) -19
 
442
        CHARS[3217] = 33;
 
443
        Arrays.fill(CHARS, 3218, 3241, (byte) -19 ); // Fill 23 of value (byte) -19
 
444
        CHARS[3241] = 33;
 
445
        Arrays.fill(CHARS, 3242, 3252, (byte) -19 ); // Fill 10 of value (byte) -19
 
446
        CHARS[3252] = 33;
 
447
        Arrays.fill(CHARS, 3253, 3258, (byte) -19 ); // Fill 5 of value (byte) -19
 
448
        Arrays.fill(CHARS, 3258, 3262, (byte) 33 ); // Fill 4 of value (byte) 33
 
449
        Arrays.fill(CHARS, 3262, 3269, (byte) -87 ); // Fill 7 of value (byte) -87
 
450
        CHARS[3269] = 33;
 
451
        Arrays.fill(CHARS, 3270, 3273, (byte) -87 ); // Fill 3 of value (byte) -87
 
452
        CHARS[3273] = 33;
 
453
        Arrays.fill(CHARS, 3274, 3278, (byte) -87 ); // Fill 4 of value (byte) -87
 
454
        Arrays.fill(CHARS, 3278, 3285, (byte) 33 ); // Fill 7 of value (byte) 33
 
455
        Arrays.fill(CHARS, 3285, 3287, (byte) -87 ); // Fill 2 of value (byte) -87
 
456
        Arrays.fill(CHARS, 3287, 3294, (byte) 33 ); // Fill 7 of value (byte) 33
 
457
        CHARS[3294] = -19;
 
458
        CHARS[3295] = 33;
 
459
        Arrays.fill(CHARS, 3296, 3298, (byte) -19 ); // Fill 2 of value (byte) -19
 
460
        Arrays.fill(CHARS, 3298, 3302, (byte) 33 ); // Fill 4 of value (byte) 33
 
461
        Arrays.fill(CHARS, 3302, 3312, (byte) -87 ); // Fill 10 of value (byte) -87
 
462
        Arrays.fill(CHARS, 3312, 3330, (byte) 33 ); // Fill 18 of value (byte) 33
 
463
        Arrays.fill(CHARS, 3330, 3332, (byte) -87 ); // Fill 2 of value (byte) -87
 
464
        CHARS[3332] = 33;
 
465
        Arrays.fill(CHARS, 3333, 3341, (byte) -19 ); // Fill 8 of value (byte) -19
 
466
        CHARS[3341] = 33;
 
467
        Arrays.fill(CHARS, 3342, 3345, (byte) -19 ); // Fill 3 of value (byte) -19
 
468
        CHARS[3345] = 33;
 
469
        Arrays.fill(CHARS, 3346, 3369, (byte) -19 ); // Fill 23 of value (byte) -19
 
470
        CHARS[3369] = 33;
 
471
        Arrays.fill(CHARS, 3370, 3386, (byte) -19 ); // Fill 16 of value (byte) -19
 
472
        Arrays.fill(CHARS, 3386, 3390, (byte) 33 ); // Fill 4 of value (byte) 33
 
473
        Arrays.fill(CHARS, 3390, 3396, (byte) -87 ); // Fill 6 of value (byte) -87
 
474
        Arrays.fill(CHARS, 3396, 3398, (byte) 33 ); // Fill 2 of value (byte) 33
 
475
        Arrays.fill(CHARS, 3398, 3401, (byte) -87 ); // Fill 3 of value (byte) -87
 
476
        CHARS[3401] = 33;
 
477
        Arrays.fill(CHARS, 3402, 3406, (byte) -87 ); // Fill 4 of value (byte) -87
 
478
        Arrays.fill(CHARS, 3406, 3415, (byte) 33 ); // Fill 9 of value (byte) 33
 
479
        CHARS[3415] = -87;
 
480
        Arrays.fill(CHARS, 3416, 3424, (byte) 33 ); // Fill 8 of value (byte) 33
 
481
        Arrays.fill(CHARS, 3424, 3426, (byte) -19 ); // Fill 2 of value (byte) -19
 
482
        Arrays.fill(CHARS, 3426, 3430, (byte) 33 ); // Fill 4 of value (byte) 33
 
483
        Arrays.fill(CHARS, 3430, 3440, (byte) -87 ); // Fill 10 of value (byte) -87
 
484
        Arrays.fill(CHARS, 3440, 3585, (byte) 33 ); // Fill 145 of value (byte) 33
 
485
        Arrays.fill(CHARS, 3585, 3631, (byte) -19 ); // Fill 46 of value (byte) -19
 
486
        CHARS[3631] = 33;
 
487
        CHARS[3632] = -19;
 
488
        CHARS[3633] = -87;
 
489
        Arrays.fill(CHARS, 3634, 3636, (byte) -19 ); // Fill 2 of value (byte) -19
 
490
        Arrays.fill(CHARS, 3636, 3643, (byte) -87 ); // Fill 7 of value (byte) -87
 
491
        Arrays.fill(CHARS, 3643, 3648, (byte) 33 ); // Fill 5 of value (byte) 33
 
492
        Arrays.fill(CHARS, 3648, 3654, (byte) -19 ); // Fill 6 of value (byte) -19
 
493
        Arrays.fill(CHARS, 3654, 3663, (byte) -87 ); // Fill 9 of value (byte) -87
 
494
        CHARS[3663] = 33;
 
495
        Arrays.fill(CHARS, 3664, 3674, (byte) -87 ); // Fill 10 of value (byte) -87
 
496
        Arrays.fill(CHARS, 3674, 3713, (byte) 33 ); // Fill 39 of value (byte) 33
 
497
        Arrays.fill(CHARS, 3713, 3715, (byte) -19 ); // Fill 2 of value (byte) -19
 
498
        CHARS[3715] = 33;
 
499
        CHARS[3716] = -19;
 
500
        Arrays.fill(CHARS, 3717, 3719, (byte) 33 ); // Fill 2 of value (byte) 33
 
501
        Arrays.fill(CHARS, 3719, 3721, (byte) -19 ); // Fill 2 of value (byte) -19
 
502
        CHARS[3721] = 33;
 
503
        CHARS[3722] = -19;
 
504
        Arrays.fill(CHARS, 3723, 3725, (byte) 33 ); // Fill 2 of value (byte) 33
 
505
        CHARS[3725] = -19;
 
506
        Arrays.fill(CHARS, 3726, 3732, (byte) 33 ); // Fill 6 of value (byte) 33
 
507
        Arrays.fill(CHARS, 3732, 3736, (byte) -19 ); // Fill 4 of value (byte) -19
 
508
        CHARS[3736] = 33;
 
509
        Arrays.fill(CHARS, 3737, 3744, (byte) -19 ); // Fill 7 of value (byte) -19
 
510
        CHARS[3744] = 33;
 
511
        Arrays.fill(CHARS, 3745, 3748, (byte) -19 ); // Fill 3 of value (byte) -19
 
512
        CHARS[3748] = 33;
 
513
        CHARS[3749] = -19;
 
514
        CHARS[3750] = 33;
 
515
        CHARS[3751] = -19;
 
516
        Arrays.fill(CHARS, 3752, 3754, (byte) 33 ); // Fill 2 of value (byte) 33
 
517
        Arrays.fill(CHARS, 3754, 3756, (byte) -19 ); // Fill 2 of value (byte) -19
 
518
        CHARS[3756] = 33;
 
519
        Arrays.fill(CHARS, 3757, 3759, (byte) -19 ); // Fill 2 of value (byte) -19
 
520
        CHARS[3759] = 33;
 
521
        CHARS[3760] = -19;
 
522
        CHARS[3761] = -87;
 
523
        Arrays.fill(CHARS, 3762, 3764, (byte) -19 ); // Fill 2 of value (byte) -19
 
524
        Arrays.fill(CHARS, 3764, 3770, (byte) -87 ); // Fill 6 of value (byte) -87
 
525
        CHARS[3770] = 33;
 
526
        Arrays.fill(CHARS, 3771, 3773, (byte) -87 ); // Fill 2 of value (byte) -87
 
527
        CHARS[3773] = -19;
 
528
        Arrays.fill(CHARS, 3774, 3776, (byte) 33 ); // Fill 2 of value (byte) 33
 
529
        Arrays.fill(CHARS, 3776, 3781, (byte) -19 ); // Fill 5 of value (byte) -19
 
530
        CHARS[3781] = 33;
 
531
        CHARS[3782] = -87;
 
532
        CHARS[3783] = 33;
 
533
        Arrays.fill(CHARS, 3784, 3790, (byte) -87 ); // Fill 6 of value (byte) -87
 
534
        Arrays.fill(CHARS, 3790, 3792, (byte) 33 ); // Fill 2 of value (byte) 33
 
535
        Arrays.fill(CHARS, 3792, 3802, (byte) -87 ); // Fill 10 of value (byte) -87
 
536
        Arrays.fill(CHARS, 3802, 3864, (byte) 33 ); // Fill 62 of value (byte) 33
 
537
        Arrays.fill(CHARS, 3864, 3866, (byte) -87 ); // Fill 2 of value (byte) -87
 
538
        Arrays.fill(CHARS, 3866, 3872, (byte) 33 ); // Fill 6 of value (byte) 33
 
539
        Arrays.fill(CHARS, 3872, 3882, (byte) -87 ); // Fill 10 of value (byte) -87
 
540
        Arrays.fill(CHARS, 3882, 3893, (byte) 33 ); // Fill 11 of value (byte) 33
 
541
        CHARS[3893] = -87;
 
542
        CHARS[3894] = 33;
 
543
        CHARS[3895] = -87;
 
544
        CHARS[3896] = 33;
 
545
        CHARS[3897] = -87;
 
546
        Arrays.fill(CHARS, 3898, 3902, (byte) 33 ); // Fill 4 of value (byte) 33
 
547
        Arrays.fill(CHARS, 3902, 3904, (byte) -87 ); // Fill 2 of value (byte) -87
 
548
        Arrays.fill(CHARS, 3904, 3912, (byte) -19 ); // Fill 8 of value (byte) -19
 
549
        CHARS[3912] = 33;
 
550
        Arrays.fill(CHARS, 3913, 3946, (byte) -19 ); // Fill 33 of value (byte) -19
 
551
        Arrays.fill(CHARS, 3946, 3953, (byte) 33 ); // Fill 7 of value (byte) 33
 
552
        Arrays.fill(CHARS, 3953, 3973, (byte) -87 ); // Fill 20 of value (byte) -87
 
553
        CHARS[3973] = 33;
 
554
        Arrays.fill(CHARS, 3974, 3980, (byte) -87 ); // Fill 6 of value (byte) -87
 
555
        Arrays.fill(CHARS, 3980, 3984, (byte) 33 ); // Fill 4 of value (byte) 33
 
556
        Arrays.fill(CHARS, 3984, 3990, (byte) -87 ); // Fill 6 of value (byte) -87
 
557
        CHARS[3990] = 33;
 
558
        CHARS[3991] = -87;
 
559
        CHARS[3992] = 33;
 
560
        Arrays.fill(CHARS, 3993, 4014, (byte) -87 ); // Fill 21 of value (byte) -87
 
561
        Arrays.fill(CHARS, 4014, 4017, (byte) 33 ); // Fill 3 of value (byte) 33
 
562
        Arrays.fill(CHARS, 4017, 4024, (byte) -87 ); // Fill 7 of value (byte) -87
 
563
        CHARS[4024] = 33;
 
564
        CHARS[4025] = -87;
 
565
        Arrays.fill(CHARS, 4026, 4256, (byte) 33 ); // Fill 230 of value (byte) 33
 
566
        Arrays.fill(CHARS, 4256, 4294, (byte) -19 ); // Fill 38 of value (byte) -19
 
567
        Arrays.fill(CHARS, 4294, 4304, (byte) 33 ); // Fill 10 of value (byte) 33
 
568
        Arrays.fill(CHARS, 4304, 4343, (byte) -19 ); // Fill 39 of value (byte) -19
 
569
        Arrays.fill(CHARS, 4343, 4352, (byte) 33 ); // Fill 9 of value (byte) 33
 
570
        CHARS[4352] = -19;
 
571
        CHARS[4353] = 33;
 
572
        Arrays.fill(CHARS, 4354, 4356, (byte) -19 ); // Fill 2 of value (byte) -19
 
573
        CHARS[4356] = 33;
 
574
        Arrays.fill(CHARS, 4357, 4360, (byte) -19 ); // Fill 3 of value (byte) -19
 
575
        CHARS[4360] = 33;
 
576
        CHARS[4361] = -19;
 
577
        CHARS[4362] = 33;
 
578
        Arrays.fill(CHARS, 4363, 4365, (byte) -19 ); // Fill 2 of value (byte) -19
 
579
        CHARS[4365] = 33;
 
580
        Arrays.fill(CHARS, 4366, 4371, (byte) -19 ); // Fill 5 of value (byte) -19
 
581
        Arrays.fill(CHARS, 4371, 4412, (byte) 33 ); // Fill 41 of value (byte) 33
 
582
        CHARS[4412] = -19;
 
583
        CHARS[4413] = 33;
 
584
        CHARS[4414] = -19;
 
585
        CHARS[4415] = 33;
 
586
        CHARS[4416] = -19;
 
587
        Arrays.fill(CHARS, 4417, 4428, (byte) 33 ); // Fill 11 of value (byte) 33
 
588
        CHARS[4428] = -19;
 
589
        CHARS[4429] = 33;
 
590
        CHARS[4430] = -19;
 
591
        CHARS[4431] = 33;
 
592
        CHARS[4432] = -19;
 
593
        Arrays.fill(CHARS, 4433, 4436, (byte) 33 ); // Fill 3 of value (byte) 33
 
594
        Arrays.fill(CHARS, 4436, 4438, (byte) -19 ); // Fill 2 of value (byte) -19
 
595
        Arrays.fill(CHARS, 4438, 4441, (byte) 33 ); // Fill 3 of value (byte) 33
 
596
        CHARS[4441] = -19;
 
597
        Arrays.fill(CHARS, 4442, 4447, (byte) 33 ); // Fill 5 of value (byte) 33
 
598
        Arrays.fill(CHARS, 4447, 4450, (byte) -19 ); // Fill 3 of value (byte) -19
 
599
        CHARS[4450] = 33;
 
600
        CHARS[4451] = -19;
 
601
        CHARS[4452] = 33;
 
602
        CHARS[4453] = -19;
 
603
        CHARS[4454] = 33;
 
604
        CHARS[4455] = -19;
 
605
        CHARS[4456] = 33;
 
606
        CHARS[4457] = -19;
 
607
        Arrays.fill(CHARS, 4458, 4461, (byte) 33 ); // Fill 3 of value (byte) 33
 
608
        Arrays.fill(CHARS, 4461, 4463, (byte) -19 ); // Fill 2 of value (byte) -19
 
609
        Arrays.fill(CHARS, 4463, 4466, (byte) 33 ); // Fill 3 of value (byte) 33
 
610
        Arrays.fill(CHARS, 4466, 4468, (byte) -19 ); // Fill 2 of value (byte) -19
 
611
        CHARS[4468] = 33;
 
612
        CHARS[4469] = -19;
 
613
        Arrays.fill(CHARS, 4470, 4510, (byte) 33 ); // Fill 40 of value (byte) 33
 
614
        CHARS[4510] = -19;
 
615
        Arrays.fill(CHARS, 4511, 4520, (byte) 33 ); // Fill 9 of value (byte) 33
 
616
        CHARS[4520] = -19;
 
617
        Arrays.fill(CHARS, 4521, 4523, (byte) 33 ); // Fill 2 of value (byte) 33
 
618
        CHARS[4523] = -19;
 
619
        Arrays.fill(CHARS, 4524, 4526, (byte) 33 ); // Fill 2 of value (byte) 33
 
620
        Arrays.fill(CHARS, 4526, 4528, (byte) -19 ); // Fill 2 of value (byte) -19
 
621
        Arrays.fill(CHARS, 4528, 4535, (byte) 33 ); // Fill 7 of value (byte) 33
 
622
        Arrays.fill(CHARS, 4535, 4537, (byte) -19 ); // Fill 2 of value (byte) -19
 
623
        CHARS[4537] = 33;
 
624
        CHARS[4538] = -19;
 
625
        CHARS[4539] = 33;
 
626
        Arrays.fill(CHARS, 4540, 4547, (byte) -19 ); // Fill 7 of value (byte) -19
 
627
        Arrays.fill(CHARS, 4547, 4587, (byte) 33 ); // Fill 40 of value (byte) 33
 
628
        CHARS[4587] = -19;
 
629
        Arrays.fill(CHARS, 4588, 4592, (byte) 33 ); // Fill 4 of value (byte) 33
 
630
        CHARS[4592] = -19;
 
631
        Arrays.fill(CHARS, 4593, 4601, (byte) 33 ); // Fill 8 of value (byte) 33
 
632
        CHARS[4601] = -19;
 
633
        Arrays.fill(CHARS, 4602, 7680, (byte) 33 ); // Fill 3078 of value (byte) 33
 
634
        Arrays.fill(CHARS, 7680, 7836, (byte) -19 ); // Fill 156 of value (byte) -19
 
635
        Arrays.fill(CHARS, 7836, 7840, (byte) 33 ); // Fill 4 of value (byte) 33
 
636
        Arrays.fill(CHARS, 7840, 7930, (byte) -19 ); // Fill 90 of value (byte) -19
 
637
        Arrays.fill(CHARS, 7930, 7936, (byte) 33 ); // Fill 6 of value (byte) 33
 
638
        Arrays.fill(CHARS, 7936, 7958, (byte) -19 ); // Fill 22 of value (byte) -19
 
639
        Arrays.fill(CHARS, 7958, 7960, (byte) 33 ); // Fill 2 of value (byte) 33
 
640
        Arrays.fill(CHARS, 7960, 7966, (byte) -19 ); // Fill 6 of value (byte) -19
 
641
        Arrays.fill(CHARS, 7966, 7968, (byte) 33 ); // Fill 2 of value (byte) 33
 
642
        Arrays.fill(CHARS, 7968, 8006, (byte) -19 ); // Fill 38 of value (byte) -19
 
643
        Arrays.fill(CHARS, 8006, 8008, (byte) 33 ); // Fill 2 of value (byte) 33
 
644
        Arrays.fill(CHARS, 8008, 8014, (byte) -19 ); // Fill 6 of value (byte) -19
 
645
        Arrays.fill(CHARS, 8014, 8016, (byte) 33 ); // Fill 2 of value (byte) 33
 
646
        Arrays.fill(CHARS, 8016, 8024, (byte) -19 ); // Fill 8 of value (byte) -19
 
647
        CHARS[8024] = 33;
 
648
        CHARS[8025] = -19;
 
649
        CHARS[8026] = 33;
 
650
        CHARS[8027] = -19;
 
651
        CHARS[8028] = 33;
 
652
        CHARS[8029] = -19;
 
653
        CHARS[8030] = 33;
 
654
        Arrays.fill(CHARS, 8031, 8062, (byte) -19 ); // Fill 31 of value (byte) -19
 
655
        Arrays.fill(CHARS, 8062, 8064, (byte) 33 ); // Fill 2 of value (byte) 33
 
656
        Arrays.fill(CHARS, 8064, 8117, (byte) -19 ); // Fill 53 of value (byte) -19
 
657
        CHARS[8117] = 33;
 
658
        Arrays.fill(CHARS, 8118, 8125, (byte) -19 ); // Fill 7 of value (byte) -19
 
659
        CHARS[8125] = 33;
 
660
        CHARS[8126] = -19;
 
661
        Arrays.fill(CHARS, 8127, 8130, (byte) 33 ); // Fill 3 of value (byte) 33
 
662
        Arrays.fill(CHARS, 8130, 8133, (byte) -19 ); // Fill 3 of value (byte) -19
 
663
        CHARS[8133] = 33;
 
664
        Arrays.fill(CHARS, 8134, 8141, (byte) -19 ); // Fill 7 of value (byte) -19
 
665
        Arrays.fill(CHARS, 8141, 8144, (byte) 33 ); // Fill 3 of value (byte) 33
 
666
        Arrays.fill(CHARS, 8144, 8148, (byte) -19 ); // Fill 4 of value (byte) -19
 
667
        Arrays.fill(CHARS, 8148, 8150, (byte) 33 ); // Fill 2 of value (byte) 33
 
668
        Arrays.fill(CHARS, 8150, 8156, (byte) -19 ); // Fill 6 of value (byte) -19
 
669
        Arrays.fill(CHARS, 8156, 8160, (byte) 33 ); // Fill 4 of value (byte) 33
 
670
        Arrays.fill(CHARS, 8160, 8173, (byte) -19 ); // Fill 13 of value (byte) -19
 
671
        Arrays.fill(CHARS, 8173, 8178, (byte) 33 ); // Fill 5 of value (byte) 33
 
672
        Arrays.fill(CHARS, 8178, 8181, (byte) -19 ); // Fill 3 of value (byte) -19
 
673
        CHARS[8181] = 33;
 
674
        Arrays.fill(CHARS, 8182, 8189, (byte) -19 ); // Fill 7 of value (byte) -19
 
675
        Arrays.fill(CHARS, 8189, 8400, (byte) 33 ); // Fill 211 of value (byte) 33
 
676
        Arrays.fill(CHARS, 8400, 8413, (byte) -87 ); // Fill 13 of value (byte) -87
 
677
        Arrays.fill(CHARS, 8413, 8417, (byte) 33 ); // Fill 4 of value (byte) 33
 
678
        CHARS[8417] = -87;
 
679
        Arrays.fill(CHARS, 8418, 8486, (byte) 33 ); // Fill 68 of value (byte) 33
 
680
        CHARS[8486] = -19;
 
681
        Arrays.fill(CHARS, 8487, 8490, (byte) 33 ); // Fill 3 of value (byte) 33
 
682
        Arrays.fill(CHARS, 8490, 8492, (byte) -19 ); // Fill 2 of value (byte) -19
 
683
        Arrays.fill(CHARS, 8492, 8494, (byte) 33 ); // Fill 2 of value (byte) 33
 
684
        CHARS[8494] = -19;
 
685
        Arrays.fill(CHARS, 8495, 8576, (byte) 33 ); // Fill 81 of value (byte) 33
 
686
        Arrays.fill(CHARS, 8576, 8579, (byte) -19 ); // Fill 3 of value (byte) -19
 
687
        Arrays.fill(CHARS, 8579, 12293, (byte) 33 ); // Fill 3714 of value (byte) 33
 
688
        CHARS[12293] = -87;
 
689
        CHARS[12294] = 33;
 
690
        CHARS[12295] = -19;
 
691
        Arrays.fill(CHARS, 12296, 12321, (byte) 33 ); // Fill 25 of value (byte) 33
 
692
        Arrays.fill(CHARS, 12321, 12330, (byte) -19 ); // Fill 9 of value (byte) -19
 
693
        Arrays.fill(CHARS, 12330, 12336, (byte) -87 ); // Fill 6 of value (byte) -87
 
694
        CHARS[12336] = 33;
 
695
        Arrays.fill(CHARS, 12337, 12342, (byte) -87 ); // Fill 5 of value (byte) -87
 
696
        Arrays.fill(CHARS, 12342, 12353, (byte) 33 ); // Fill 11 of value (byte) 33
 
697
        Arrays.fill(CHARS, 12353, 12437, (byte) -19 ); // Fill 84 of value (byte) -19
 
698
        Arrays.fill(CHARS, 12437, 12441, (byte) 33 ); // Fill 4 of value (byte) 33
 
699
        Arrays.fill(CHARS, 12441, 12443, (byte) -87 ); // Fill 2 of value (byte) -87
 
700
        Arrays.fill(CHARS, 12443, 12445, (byte) 33 ); // Fill 2 of value (byte) 33
 
701
        Arrays.fill(CHARS, 12445, 12447, (byte) -87 ); // Fill 2 of value (byte) -87
 
702
        Arrays.fill(CHARS, 12447, 12449, (byte) 33 ); // Fill 2 of value (byte) 33
 
703
        Arrays.fill(CHARS, 12449, 12539, (byte) -19 ); // Fill 90 of value (byte) -19
 
704
        CHARS[12539] = 33;
 
705
        Arrays.fill(CHARS, 12540, 12543, (byte) -87 ); // Fill 3 of value (byte) -87
 
706
        Arrays.fill(CHARS, 12543, 12549, (byte) 33 ); // Fill 6 of value (byte) 33
 
707
        Arrays.fill(CHARS, 12549, 12589, (byte) -19 ); // Fill 40 of value (byte) -19
 
708
        Arrays.fill(CHARS, 12589, 19968, (byte) 33 ); // Fill 7379 of value (byte) 33
 
709
        Arrays.fill(CHARS, 19968, 40870, (byte) -19 ); // Fill 20902 of value (byte) -19
 
710
        Arrays.fill(CHARS, 40870, 44032, (byte) 33 ); // Fill 3162 of value (byte) 33
 
711
        Arrays.fill(CHARS, 44032, 55204, (byte) -19 ); // Fill 11172 of value (byte) -19
 
712
        Arrays.fill(CHARS, 55204, 55296, (byte) 33 ); // Fill 92 of value (byte) 33
 
713
        Arrays.fill(CHARS, 57344, 65534, (byte) 33 ); // Fill 8190 of value (byte) 33
 
714
 
 
715
    } // <clinit>()
 
716
 
 
717
    //
 
718
    // Public static methods
 
719
    //
 
720
 
 
721
    /**
 
722
     * Returns true if the specified character is a supplemental character.
 
723
     *
 
724
     * @param c The character to check.
 
725
     */
 
726
    public static boolean isSupplemental(int c) {
 
727
        return (c >= 0x10000 && c <= 0x10FFFF);
 
728
    }
 
729
 
 
730
    /**
 
731
     * Returns true the supplemental character corresponding to the given
 
732
     * surrogates.
 
733
     *
 
734
     * @param h The high surrogate.
 
735
     * @param l The low surrogate.
 
736
     */
 
737
    public static int supplemental(char h, char l) {
 
738
        return (h - 0xD800) * 0x400 + (l - 0xDC00) + 0x10000;
 
739
    }
 
740
 
 
741
    /**
 
742
     * Returns the high surrogate of a supplemental character
 
743
     *
 
744
     * @param c The supplemental character to "split".
 
745
     */
 
746
    public static char highSurrogate(int c) {
 
747
        return (char) (((c - 0x00010000) >> 10) + 0xD800);
 
748
    }
 
749
 
 
750
    /**
 
751
     * Returns the low surrogate of a supplemental character
 
752
     *
 
753
     * @param c The supplemental character to "split".
 
754
     */
 
755
    public static char lowSurrogate(int c) {
 
756
        return (char) (((c - 0x00010000) & 0x3FF) + 0xDC00);
 
757
    }
 
758
 
 
759
    /**
 
760
     * Returns whether the given character is a high surrogate
 
761
     *
 
762
     * @param c The character to check.
 
763
     */
 
764
    public static boolean isHighSurrogate(int c) {
 
765
        return (0xD800 <= c && c <= 0xDBFF);
 
766
    }
 
767
 
 
768
    /**
 
769
     * Returns whether the given character is a low surrogate
 
770
     *
 
771
     * @param c The character to check.
 
772
     */
 
773
    public static boolean isLowSurrogate(int c) {
 
774
        return (0xDC00 <= c && c <= 0xDFFF);
 
775
    }
 
776
 
 
777
 
 
778
    /**
 
779
     * Returns true if the specified character is valid. This method
 
780
     * also checks the surrogate character range from 0x10000 to 0x10FFFF.
 
781
     * <p>
 
782
     * If the program chooses to apply the mask directly to the
 
783
     * <code>CHARS</code> array, then they are responsible for checking
 
784
     * the surrogate character range.
 
785
     *
 
786
     * @param c The character to check.
 
787
     */
 
788
    public static boolean isValid(int c) {
 
789
        return (c < 0x10000 && (CHARS[c] & MASK_VALID) != 0) ||
 
790
               (0x10000 <= c && c <= 0x10FFFF);
 
791
    } // isValid(int):boolean
 
792
 
 
793
    /**
 
794
     * Returns true if the specified character is invalid.
 
795
     *
 
796
     * @param c The character to check.
 
797
     */
 
798
    public static boolean isInvalid(int c) {
 
799
        return !isValid(c);
 
800
    } // isInvalid(int):boolean
 
801
 
 
802
    /**
 
803
     * Returns true if the specified character can be considered content.
 
804
     *
 
805
     * @param c The character to check.
 
806
     */
 
807
    public static boolean isContent(int c) {
 
808
        return (c < 0x10000 && (CHARS[c] & MASK_CONTENT) != 0) ||
 
809
               (0x10000 <= c && c <= 0x10FFFF);
 
810
    } // isContent(int):boolean
 
811
 
 
812
    /**
 
813
     * Returns true if the specified character can be considered markup.
 
814
     * Markup characters include '&lt;', '&amp;', and '%'.
 
815
     *
 
816
     * @param c The character to check.
 
817
     */
 
818
    public static boolean isMarkup(int c) {
 
819
        return c == '<' || c == '&' || c == '%';
 
820
    } // isMarkup(int):boolean
 
821
 
 
822
    /**
 
823
     * Returns true if the specified character is a space character
 
824
     * as defined by production [3] in the XML 1.0 specification.
 
825
     *
 
826
     * @param c The character to check.
 
827
     */
 
828
    public static boolean isSpace(int c) {
 
829
        return c <= 0x20 && (CHARS[c] & MASK_SPACE) != 0;
 
830
    } // isSpace(int):boolean
 
831
 
 
832
    /**
 
833
     * Returns true if the specified character is a valid name start
 
834
     * character as defined by production [5] in the XML 1.0
 
835
     * specification.
 
836
     *
 
837
     * @param c The character to check.
 
838
     */
 
839
    public static boolean isNameStart(int c) {
 
840
        return c < 0x10000 && (CHARS[c] & MASK_NAME_START) != 0;
 
841
    } // isNameStart(int):boolean
 
842
 
 
843
    /**
 
844
     * Returns true if the specified character is a valid name
 
845
     * character as defined by production [4] in the XML 1.0
 
846
     * specification.
 
847
     *
 
848
     * @param c The character to check.
 
849
     */
 
850
    public static boolean isName(int c) {
 
851
        return c < 0x10000 && (CHARS[c] & MASK_NAME) != 0;
 
852
    } // isName(int):boolean
 
853
 
 
854
    /**
 
855
     * Returns true if the specified character is a valid NCName start
 
856
     * character as defined by production [4] in Namespaces in XML
 
857
     * recommendation.
 
858
     *
 
859
     * @param c The character to check.
 
860
     */
 
861
    public static boolean isNCNameStart(int c) {
 
862
        return c < 0x10000 && (CHARS[c] & MASK_NCNAME_START) != 0;
 
863
    } // isNCNameStart(int):boolean
 
864
 
 
865
    /**
 
866
     * Returns true if the specified character is a valid NCName
 
867
     * character as defined by production [5] in Namespaces in XML
 
868
     * recommendation.
 
869
     *
 
870
     * @param c The character to check.
 
871
     */
 
872
    public static boolean isNCName(int c) {
 
873
        return c < 0x10000 && (CHARS[c] & MASK_NCNAME) != 0;
 
874
    } // isNCName(int):boolean
 
875
 
 
876
    /**
 
877
     * Returns true if the specified character is a valid Pubid
 
878
     * character as defined by production [13] in the XML 1.0
 
879
     * specification.
 
880
     *
 
881
     * @param c The character to check.
 
882
     */
 
883
    public static boolean isPubid(int c) {
 
884
        return c < 0x10000 && (CHARS[c] & MASK_PUBID) != 0;
 
885
    } // isPubid(int):boolean
 
886
 
 
887
    /*
 
888
     * [5] Name ::= (Letter | '_' | ':') (NameChar)*
 
889
     */
 
890
    /**
 
891
     * Check to see if a string is a valid Name according to [5]
 
892
     * in the XML 1.0 Recommendation
 
893
     *
 
894
     * @param name string to check
 
895
     * @return true if name is a valid Name
 
896
     */
 
897
    public static boolean isValidName(String name) {
 
898
        if (name.length() == 0)
 
899
            return false;
 
900
        char ch = name.charAt(0);
 
901
        if( isNameStart(ch) == false)
 
902
           return false;
 
903
        for (int i = 1; i < name.length(); i++ ) {
 
904
           ch = name.charAt(i);
 
905
           if( isName( ch ) == false ){
 
906
              return false;
 
907
           }
 
908
        }
 
909
        return true;
 
910
    } // isValidName(String):boolean
 
911
    
 
912
 
 
913
    /*
 
914
     * from the namespace rec
 
915
     * [4] NCName ::= (Letter | '_') (NCNameChar)*
 
916
     */
 
917
    /**
 
918
     * Check to see if a string is a valid NCName according to [4]
 
919
     * from the XML Namespaces 1.0 Recommendation
 
920
     *
 
921
     * @param ncName string to check
 
922
     * @return true if name is a valid NCName
 
923
     */
 
924
    public static boolean isValidNCName(String ncName) {
 
925
        if (ncName.length() == 0)
 
926
            return false;
 
927
        char ch = ncName.charAt(0);
 
928
        if( isNCNameStart(ch) == false)
 
929
           return false;
 
930
        for (int i = 1; i < ncName.length(); i++ ) {
 
931
           ch = ncName.charAt(i);
 
932
           if( isNCName( ch ) == false ){
 
933
              return false;
 
934
           }
 
935
        }
 
936
        return true;
 
937
    } // isValidNCName(String):boolean
 
938
 
 
939
    /*
 
940
     * [7] Nmtoken ::= (NameChar)+
 
941
     */
 
942
    /**
 
943
     * Check to see if a string is a valid Nmtoken according to [7]
 
944
     * in the XML 1.0 Recommendation
 
945
     *
 
946
     * @param nmtoken string to check
 
947
     * @return true if nmtoken is a valid Nmtoken 
 
948
     */
 
949
    public static boolean isValidNmtoken(String nmtoken) {
 
950
        if (nmtoken.length() == 0)
 
951
            return false;
 
952
        for (int i = 0; i < nmtoken.length(); i++ ) {
 
953
           char ch = nmtoken.charAt(i);
 
954
           if(  ! isName( ch ) ){
 
955
              return false;
 
956
           }
 
957
        }
 
958
        return true;
 
959
    } // isValidName(String):boolean
 
960
 
 
961
 
 
962
 
 
963
 
 
964
 
 
965
    // encodings
 
966
 
 
967
    /**
 
968
     * Returns true if the encoding name is a valid IANA encoding.
 
969
     * This method does not verify that there is a decoder available
 
970
     * for this encoding, only that the characters are valid for an
 
971
     * IANA encoding name.
 
972
     *
 
973
     * @param ianaEncoding The IANA encoding name.
 
974
     */
 
975
    public static boolean isValidIANAEncoding(String ianaEncoding) {
 
976
        if (ianaEncoding != null) {
 
977
            int length = ianaEncoding.length();
 
978
            if (length > 0) {
 
979
                char c = ianaEncoding.charAt(0);
 
980
                if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
 
981
                    for (int i = 1; i < length; i++) {
 
982
                        c = ianaEncoding.charAt(i);
 
983
                        if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') &&
 
984
                            (c < '0' || c > '9') && c != '.' && c != '_' &&
 
985
                            c != '-') {
 
986
                            return false;
 
987
                        }
 
988
                    }
 
989
                    return true;
 
990
                }
 
991
            }
 
992
        }
 
993
        return false;
 
994
    } // isValidIANAEncoding(String):boolean
 
995
 
 
996
    /**
 
997
     * Returns true if the encoding name is a valid Java encoding.
 
998
     * This method does not verify that there is a decoder available
 
999
     * for this encoding, only that the characters are valid for an
 
1000
     * Java encoding name.
 
1001
     *
 
1002
     * @param javaEncoding The Java encoding name.
 
1003
     */
 
1004
    public static boolean isValidJavaEncoding(String javaEncoding) {
 
1005
        if (javaEncoding != null) {
 
1006
            int length = javaEncoding.length();
 
1007
            if (length > 0) {
 
1008
                for (int i = 1; i < length; i++) {
 
1009
                    char c = javaEncoding.charAt(i);
 
1010
                    if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') &&
 
1011
                        (c < '0' || c > '9') && c != '.' && c != '_' &&
 
1012
                        c != '-') {
 
1013
                        return false;
 
1014
                    }
 
1015
                }
 
1016
                return true;
 
1017
            }
 
1018
        }
 
1019
        return false;
 
1020
    } // isValidIANAEncoding(String):boolean
 
1021
    
 
1022
    // other methods
 
1023
    
 
1024
    /**
 
1025
     * Trims space characters as defined by production [3] in 
 
1026
     * the XML 1.0 specification from both ends of the given string.
 
1027
     * 
 
1028
     * @param value the string to be trimmed
 
1029
     * @return the given string with the space characters trimmed
 
1030
     * from both ends
 
1031
     */
 
1032
    public static String trim(String value) {
 
1033
        int start;
 
1034
        int end;
 
1035
        final int lengthMinusOne = value.length() - 1;
 
1036
        for (start = 0; start <= lengthMinusOne; ++start) {
 
1037
            if (!isSpace(value.charAt(start))) {
 
1038
                break;
 
1039
            }
 
1040
        }
 
1041
        for (end = lengthMinusOne; end >= start; --end) {
 
1042
            if (!isSpace(value.charAt(end))) {
 
1043
                break;
 
1044
            }
 
1045
        }
 
1046
        if (start == 0 && end == lengthMinusOne) {
 
1047
            return value;
 
1048
        }
 
1049
        if (start > lengthMinusOne) {
 
1050
            return "";
 
1051
        }
 
1052
        return value.substring(start, end + 1);
 
1053
    } // trim(String):String
 
1054
 
 
1055
} // class XMLChar