XMLChar


1   /*
2    * Copyright 1999-2002,2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.apache.axis.utils;
18  
19  /**
20   * This class defines the basic XML character properties. The data
21   * in this class can be used to verify that a character is a valid
22   * XML character or if the character is a space, name start, or name
23   * character.
24   * <p>
25   * A series of convenience methods are supplied to ease the burden
26   * of the developer. Because inlining the checks can improve per
27   * character performance, the tables of character properties are
28   * public. Using the character as an index into the <code>CHARS</code>
29   * array and applying the appropriate mask flag (e.g.
30   * <code>MASK_VALID</code>), yields the same results as calling the
31   * convenience methods. There is one exception: check the comments
32   * for the <code>isValid</code> method for details.
33   *
34   * @author Glenn Marcy, IBM
35   * @author Andy Clark, IBM
36   * @author Eric Ye, IBM
37   * @author Arnaud  Le Hors, IBM
38   * @author Rahul Srivastava, Sun Microsystems Inc.
39   */
40  public class XMLChar {
41  
42      //
43      // Constants
44      //
45  
46      /** Character flags. */
47      private static final byte[] CHARS = new byte[1 << 16];
48  
49      /** Valid character mask. */
50      public static final int MASK_VALID = 0x01;
51  
52      /** Space character mask. */
53      public static final int MASK_SPACE = 0x02;
54  
55      /** Name start character mask. */
56      public static final int MASK_NAME_START = 0x04;
57  
58      /** Name character mask. */
59      public static final int MASK_NAME = 0x08;
60  
61      /** Pubid character mask. */
62      public static final int MASK_PUBID = 0x10;
63  
64      /**
65       * Content character mask. Special characters are those that can
66       * be considered the start of markup, such as '&lt;' and '&amp;'.
67       * The various newline characters are considered special as well.
68       * All other valid XML characters can be considered content.
69       * <p>
70       * This is an optimization for the inner loop of character scanning.
71       */
72      public static final int MASK_CONTENT = 0x20;
73  
74      /** NCName start character mask. */
75      public static final int MASK_NCNAME_START = 0x40;
76  
77      /** NCName character mask. */
78      public static final int MASK_NCNAME = 0x80;
79  
80      //
81      // Static initialization
82      //
83  
84      static {
85  
86          //
87          // [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] |
88          //              [#xE000-#xFFFD] | [#x10000-#x10FFFF]
89          //
90  
91          int charRange[] = {
92              0x0009, 0x000A, 0x000D, 0x000D, 0x0020, 0xD7FF, 0xE000, 0xFFFD,
93          };
94  
95          //
96          // [3] S ::= (#x20 | #x9 | #xD | #xA)+
97          //
98  
99          int spaceChar[] = {
100             0x0020, 0x0009, 0x000D, 0x000A,
101         };
102 
103         //
104         // [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
105         //                  CombiningChar | Extender
106         //
107 
108         int nameChar[] = {
109             0x002D, 0x002E, // '-' and '.'
110         };
111 
112         //
113         // [5] Name ::= (Letter | '_' | ':') (NameChar)*
114         //
115 
116         int nameStartChar[] = {
117             0x003A, 0x005F, // ':' and '_'
118         };
119 
120         //
121         // [13] PubidChar ::= #x20 | 0xD | 0xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
122         //
123 
124         int pubidChar[] = {
125             0x000A, 0x000D, 0x0020, 0x0021, 0x0023, 0x0024, 0x0025, 0x003D,
126             0x005F
127         };
128 
129         int pubidRange[] = {
130             0x0027, 0x003B, 0x003F, 0x005A, 0x0061, 0x007A
131         };
132 
133         //
134         // [84] Letter ::= BaseChar | Ideographic
135         //
136 
137         int letterRange[] = {
138             // BaseChar
139             0x0041, 0x005A, 0x0061, 0x007A, 0x00C0, 0x00D6, 0x00D8, 0x00F6,
140             0x00F8, 0x0131, 0x0134, 0x013E, 0x0141, 0x0148, 0x014A, 0x017E,
141             0x0180, 0x01C3, 0x01CD, 0x01F0, 0x01F4, 0x01F5, 0x01FA, 0x0217,
142             0x0250, 0x02A8, 0x02BB, 0x02C1, 0x0388, 0x038A, 0x038E, 0x03A1,
143             0x03A3, 0x03CE, 0x03D0, 0x03D6, 0x03E2, 0x03F3, 0x0401, 0x040C,
144             0x040E, 0x044F, 0x0451, 0x045C, 0x045E, 0x0481, 0x0490, 0x04C4,
145             0x04C7, 0x04C8, 0x04CB, 0x04CC, 0x04D0, 0x04EB, 0x04EE, 0x04F5,
146             0x04F8, 0x04F9, 0x0531, 0x0556, 0x0561, 0x0586, 0x05D0, 0x05EA,
147             0x05F0, 0x05F2, 0x0621, 0x063A, 0x0641, 0x064A, 0x0671, 0x06B7,
148             0x06BA, 0x06BE, 0x06C0, 0x06CE, 0x06D0, 0x06D3, 0x06E5, 0x06E6,
149             0x0905, 0x0939, 0x0958, 0x0961, 0x0985, 0x098C, 0x098F, 0x0990,
150             0x0993, 0x09A8, 0x09AA, 0x09B0, 0x09B6, 0x09B9, 0x09DC, 0x09DD,
151             0x09DF, 0x09E1, 0x09F0, 0x09F1, 0x0A05, 0x0A0A, 0x0A0F, 0x0A10,
152             0x0A13, 0x0A28, 0x0A2A, 0x0A30, 0x0A32, 0x0A33, 0x0A35, 0x0A36,
153             0x0A38, 0x0A39, 0x0A59, 0x0A5C, 0x0A72, 0x0A74, 0x0A85, 0x0A8B,
154             0x0A8F, 0x0A91, 0x0A93, 0x0AA8, 0x0AAA, 0x0AB0, 0x0AB2, 0x0AB3,
155             0x0AB5, 0x0AB9, 0x0B05, 0x0B0C, 0x0B0F, 0x0B10, 0x0B13, 0x0B28,
156             0x0B2A, 0x0B30, 0x0B32, 0x0B33, 0x0B36, 0x0B39, 0x0B5C, 0x0B5D,
157             0x0B5F, 0x0B61, 0x0B85, 0x0B8A, 0x0B8E, 0x0B90, 0x0B92, 0x0B95,
158             0x0B99, 0x0B9A, 0x0B9E, 0x0B9F, 0x0BA3, 0x0BA4, 0x0BA8, 0x0BAA,
159             0x0BAE, 0x0BB5, 0x0BB7, 0x0BB9, 0x0C05, 0x0C0C, 0x0C0E, 0x0C10,
160             0x0C12, 0x0C28, 0x0C2A, 0x0C33, 0x0C35, 0x0C39, 0x0C60, 0x0C61,
161             0x0C85, 0x0C8C, 0x0C8E, 0x0C90, 0x0C92, 0x0CA8, 0x0CAA, 0x0CB3,
162             0x0CB5, 0x0CB9, 0x0CE0, 0x0CE1, 0x0D05, 0x0D0C, 0x0D0E, 0x0D10,
163             0x0D12, 0x0D28, 0x0D2A, 0x0D39, 0x0D60, 0x0D61, 0x0E01, 0x0E2E,
164             0x0E32, 0x0E33, 0x0E40, 0x0E45, 0x0E81, 0x0E82, 0x0E87, 0x0E88,
165             0x0E94, 0x0E97, 0x0E99, 0x0E9F, 0x0EA1, 0x0EA3, 0x0EAA, 0x0EAB,
166             0x0EAD, 0x0EAE, 0x0EB2, 0x0EB3, 0x0EC0, 0x0EC4, 0x0F40, 0x0F47,
167             0x0F49, 0x0F69, 0x10A0, 0x10C5, 0x10D0, 0x10F6, 0x1102, 0x1103,
168             0x1105, 0x1107, 0x110B, 0x110C, 0x110E, 0x1112, 0x1154, 0x1155,
169             0x115F, 0x1161, 0x116D, 0x116E, 0x1172, 0x1173, 0x11AE, 0x11AF,
170             0x11B7, 0x11B8, 0x11BC, 0x11C2, 0x1E00, 0x1E9B, 0x1EA0, 0x1EF9,
171             0x1F00, 0x1F15, 0x1F18, 0x1F1D, 0x1F20, 0x1F45, 0x1F48, 0x1F4D,
172             0x1F50, 0x1F57, 0x1F5F, 0x1F7D, 0x1F80, 0x1FB4, 0x1FB6, 0x1FBC,
173             0x1FC2, 0x1FC4, 0x1FC6, 0x1FCC, 0x1FD0, 0x1FD3, 0x1FD6, 0x1FDB,
174             0x1FE0, 0x1FEC, 0x1FF2, 0x1FF4, 0x1FF6, 0x1FFC, 0x212A, 0x212B,
175             0x2180, 0x2182, 0x3041, 0x3094, 0x30A1, 0x30FA, 0x3105, 0x312C,
176             0xAC00, 0xD7A3,
177             // Ideographic
178             0x3021, 0x3029, 0x4E00, 0x9FA5,
179         };
180         int letterChar[] = {
181             // BaseChar
182             0x0386, 0x038C, 0x03DA, 0x03DC, 0x03DE, 0x03E0, 0x0559, 0x06D5,
183             0x093D, 0x09B2, 0x0A5E, 0x0A8D, 0x0ABD, 0x0AE0, 0x0B3D, 0x0B9C,
184             0x0CDE, 0x0E30, 0x0E84, 0x0E8A, 0x0E8D, 0x0EA5, 0x0EA7, 0x0EB0,
185             0x0EBD, 0x1100, 0x1109, 0x113C, 0x113E, 0x1140, 0x114C, 0x114E,
186             0x1150, 0x1159, 0x1163, 0x1165, 0x1167, 0x1169, 0x1175, 0x119E,
187             0x11A8, 0x11AB, 0x11BA, 0x11EB, 0x11F0, 0x11F9, 0x1F59, 0x1F5B,
188             0x1F5D, 0x1FBE, 0x2126, 0x212E,
189             // Ideographic
190             0x3007,
191         };
192 
193         //
194         // [87] CombiningChar ::= ...
195         //
196 
197         int combiningCharRange[] = {
198             0x0300, 0x0345, 0x0360, 0x0361, 0x0483, 0x0486, 0x0591, 0x05A1,
199             0x05A3, 0x05B9, 0x05BB, 0x05BD, 0x05C1, 0x05C2, 0x064B, 0x0652,
200             0x06D6, 0x06DC, 0x06DD, 0x06DF, 0x06E0, 0x06E4, 0x06E7, 0x06E8,
201             0x06EA, 0x06ED, 0x0901, 0x0903, 0x093E, 0x094C, 0x0951, 0x0954,
202             0x0962, 0x0963, 0x0981, 0x0983, 0x09C0, 0x09C4, 0x09C7, 0x09C8,
203             0x09CB, 0x09CD, 0x09E2, 0x09E3, 0x0A40, 0x0A42, 0x0A47, 0x0A48,
204             0x0A4B, 0x0A4D, 0x0A70, 0x0A71, 0x0A81, 0x0A83, 0x0ABE, 0x0AC5,
205             0x0AC7, 0x0AC9, 0x0ACB, 0x0ACD, 0x0B01, 0x0B03, 0x0B3E, 0x0B43,
206             0x0B47, 0x0B48, 0x0B4B, 0x0B4D, 0x0B56, 0x0B57, 0x0B82, 0x0B83,
207             0x0BBE, 0x0BC2, 0x0BC6, 0x0BC8, 0x0BCA, 0x0BCD, 0x0C01, 0x0C03,
208             0x0C3E, 0x0C44, 0x0C46, 0x0C48, 0x0C4A, 0x0C4D, 0x0C55, 0x0C56,
209             0x0C82, 0x0C83, 0x0CBE, 0x0CC4, 0x0CC6, 0x0CC8, 0x0CCA, 0x0CCD,
210             0x0CD5, 0x0CD6, 0x0D02, 0x0D03, 0x0D3E, 0x0D43, 0x0D46, 0x0D48,
211             0x0D4A, 0x0D4D, 0x0E34, 0x0E3A, 0x0E47, 0x0E4E, 0x0EB4, 0x0EB9,
212             0x0EBB, 0x0EBC, 0x0EC8, 0x0ECD, 0x0F18, 0x0F19, 0x0F71, 0x0F84,
213             0x0F86, 0x0F8B, 0x0F90, 0x0F95, 0x0F99, 0x0FAD, 0x0FB1, 0x0FB7,
214             0x20D0, 0x20DC, 0x302A, 0x302F,
215         };
216 
217         int combiningCharChar[] = {
218             0x05BF, 0x05C4, 0x0670, 0x093C, 0x094D, 0x09BC, 0x09BE, 0x09BF,
219             0x09D7, 0x0A02, 0x0A3C, 0x0A3E, 0x0A3F, 0x0ABC, 0x0B3C, 0x0BD7,
220             0x0D57, 0x0E31, 0x0EB1, 0x0F35, 0x0F37, 0x0F39, 0x0F3E, 0x0F3F,
221             0x0F97, 0x0FB9, 0x20E1, 0x3099, 0x309A,
222         };
223 
224         //
225         // [88] Digit ::= ...
226         //
227 
228         int digitRange[] = {
229             0x0030, 0x0039, 0x0660, 0x0669, 0x06F0, 0x06F9, 0x0966, 0x096F,
230             0x09E6, 0x09EF, 0x0A66, 0x0A6F, 0x0AE6, 0x0AEF, 0x0B66, 0x0B6F,
231             0x0BE7, 0x0BEF, 0x0C66, 0x0C6F, 0x0CE6, 0x0CEF, 0x0D66, 0x0D6F,
232             0x0E50, 0x0E59, 0x0ED0, 0x0ED9, 0x0F20, 0x0F29,
233         };
234 
235         //
236         // [89] Extender ::= ...
237         //
238 
239         int extenderRange[] = {
240             0x3031, 0x3035, 0x309D, 0x309E, 0x30FC, 0x30FE,
241         };
242 
243         int extenderChar[] = {
244             0x00B7, 0x02D0, 0x02D1, 0x0387, 0x0640, 0x0E46, 0x0EC6, 0x3005,
245         };
246 
247         //
248         // SpecialChar ::= '<', '&', '\n', '\r', ']'
249         //
250 
251         int specialChar[] = {
252             '<', '&', '\n', '\r', ']',
253         };
254 
255         //
256         // Initialize
257         //
258 
259         // set valid characters
260         for (int i = 0; i < charRange.length; i += 2) {
261             for (int j = charRange[i]; j <= charRange[i + 1]; j++) {
262                 CHARS[j] |= MASK_VALID | MASK_CONTENT;
263             }
264         }
265 
266         // remove special characters
267         for (int i = 0; i < specialChar.length; i++) {
268             CHARS[specialChar[i]] = (byte)(CHARS[specialChar[i]] & ~MASK_CONTENT);
269         }
270 
271         // set space characters
272         for (int i = 0; i < spaceChar.length; i++) {
273             CHARS[spaceChar[i]] |= MASK_SPACE;
274         }
275 
276         // set name start characters
277         for (int i = 0; i < nameStartChar.length; i++) {
278             CHARS[nameStartChar[i]] |= MASK_NAME_START | MASK_NAME |
279                                        MASK_NCNAME_START | MASK_NCNAME;
280         }
281         for (int i = 0; i < letterRange.length; i += 2) {
282             for (int j = letterRange[i]; j <= letterRange[i + 1]; j++) {
283                 CHARS[j] |= MASK_NAME_START | MASK_NAME |
284                             MASK_NCNAME_START | MASK_NCNAME;
285             }
286         }
287         for (int i = 0; i < letterChar.length; i++) {
288             CHARS[letterChar[i]] |= MASK_NAME_START | MASK_NAME |
289                                     MASK_NCNAME_START | MASK_NCNAME;
290         }
291 
292         // set name characters
293         for (int i = 0; i < nameChar.length; i++) {
294             CHARS[nameChar[i]] |= MASK_NAME | MASK_NCNAME;
295         }
296         for (int i = 0; i < digitRange.length; i += 2) {
297             for (int j = digitRange[i]; j <= digitRange[i + 1]; j++) {
298                 CHARS[j] |= MASK_NAME | MASK_NCNAME;
299             }
300         }
301         for (int i = 0; i < combiningCharRange.length; i += 2) {
302             for (int j = combiningCharRange[i]; j <= combiningCharRange[i + 1]; j++) {
303                 CHARS[j] |= MASK_NAME | MASK_NCNAME;
304             }
305         }
306         for (int i = 0; i < combiningCharChar.length; i++) {
307             CHARS[combiningCharChar[i]] |= MASK_NAME | MASK_NCNAME;
308         }
309         for (int i = 0; i < extenderRange.length; i += 2) {
310             for (int j = extenderRange[i]; j <= extenderRange[i + 1]; j++) {
311                 CHARS[j] |= MASK_NAME | MASK_NCNAME;
312             }
313         }
314         for (int i = 0; i < extenderChar.length; i++) {
315             CHARS[extenderChar[i]] |= MASK_NAME | MASK_NCNAME;
316         }
317 
318         // remove ':' from allowable MASK_NCNAME_START and MASK_NCNAME chars
319         CHARS[':'] &= ~(MASK_NCNAME_START | MASK_NCNAME);
320 
321         // set Pubid characters
322         for (int i = 0; i < pubidChar.length; i++) {
323             CHARS[pubidChar[i]] |= MASK_PUBID;
324         }
325         for (int i = 0; i < pubidRange.length; i += 2) {
326             for (int j = pubidRange[i]; j <= pubidRange[i + 1]; j++) {
327                 CHARS[j] |= MASK_PUBID;
328             }
329         }
330 
331     } // <clinit>()
332 
333     //
334     // Public static methods
335     //
336 
337     /**
338      * Returns true if the specified character is a supplemental character.
339      *
340      * @param c The character to check.
341      */
342     public static boolean isSupplemental(int c) {
343         return (c >= 0x10000 && c <= 0x10FFFF);
344     }
345 
346     /**
347      * Returns true the supplemental character corresponding to the given
348      * surrogates.
349      *
350      * @param h The high surrogate.
351      * @param l The low surrogate.
352      */
353     public static int supplemental(char h, char l) {
354         return (h - 0xD800) * 0x400 + (l - 0xDC00) + 0x10000;
355     }
356 
357     /**
358      * Returns the high surrogate of a supplemental character
359      *
360      * @param c The supplemental character to "split".
361      */
362     public static char highSurrogate(int c) {
363         return (char) (((c - 0x00010000) >> 10) + 0xD800);
364     }
365 
366     /**
367      * Returns the low surrogate of a supplemental character
368      *
369      * @param c The supplemental character to "split".
370      */
371     public static char lowSurrogate(int c) {
372         return (char) (((c - 0x00010000) & 0x3FF) + 0xDC00);
373     }
374 
375     /**
376      * Returns whether the given character is a high surrogate
377      *
378      * @param c The character to check.
379      */
380     public static boolean isHighSurrogate(int c) {
381         return (0xD800 <= c && c <= 0xDBFF);
382     }
383 
384     /**
385      * Returns whether the given character is a low surrogate
386      *
387      * @param c The character to check.
388      */
389     public static boolean isLowSurrogate(int c) {
390         return (0xDC00 <= c && c <= 0xDFFF);
391     }
392 
393 
394     /**
395      * Returns true if the specified character is valid. This method
396      * also checks the surrogate character range from 0x10000 to 0x10FFFF.
397      * <p>
398      * If the program chooses to apply the mask directly to the
399      * <code>CHARS</code> array, then they are responsible for checking
400      * the surrogate character range.
401      *
402      * @param c The character to check.
403      */
404     public static boolean isValid(int c) {
405         return (c < 0x10000 && (CHARS[c] & MASK_VALID) != 0) ||
406                (0x10000 <= c && c <= 0x10FFFF);
407     } // isValid(int):boolean
408 
409     /**
410      * Returns true if the specified character is invalid.
411      *
412      * @param c The character to check.
413      */
414     public static boolean isInvalid(int c) {
415         return !isValid(c);
416     } // isInvalid(int):boolean
417 
418     /**
419      * Returns true if the specified character can be considered content.
420      *
421      * @param c The character to check.
422      */
423     public static boolean isContent(int c) {
424         return (c < 0x10000 && (CHARS[c] & MASK_CONTENT) != 0) ||
425                (0x10000 <= c && c <= 0x10FFFF);
426     } // isContent(int):boolean
427 
428     /**
429      * Returns true if the specified character can be considered markup.
430      * Markup characters include '&lt;', '&amp;', and '%'.
431      *
432      * @param c The character to check.
433      */
434     public static boolean isMarkup(int c) {
435         return c == '<' || c == '&' || c == '%';
436     } // isMarkup(int):boolean
437 
438     /**
439      * Returns true if the specified character is a space character
440      * as defined by production [3] in the XML 1.0 specification.
441      *
442      * @param c The character to check.
443      */
444     public static boolean isSpace(int c) {
445         return c < 0x10000 && (CHARS[c] & MASK_SPACE) != 0;
446     } // isSpace(int):boolean
447 
448     /**
449      * Returns true if the specified character is a space character
450      * as amdended in the XML 1.1 specification.
451      *
452      * @param c The character to check.
453      */
454     public static boolean isXML11Space(int c) {
455         return (c < 0x10000 && (CHARS[c] & MASK_SPACE) != 0) ||
456             c == 0x85 || c == 0x2028;
457     } // isXML11Space(int):boolean
458 
459     /**
460      * Returns true if the specified character is a valid name start
461      * character as defined by production [5] in the XML 1.0
462      * specification.
463      *
464      * @param c The character to check.
465      */
466     public static boolean isNameStart(int c) {
467         return c < 0x10000 && (CHARS[c] & MASK_NAME_START) != 0;
468     } // isNameStart(int):boolean
469 
470     /**
471      * Returns true if the specified character is a valid name
472      * character as defined by production [4] in the XML 1.0
473      * specification.
474      *
475      * @param c The character to check.
476      */
477     public static boolean isName(int c) {
478         return c < 0x10000 && (CHARS[c] & MASK_NAME) != 0;
479     } // isName(int):boolean
480 
481     /**
482      * Returns true if the specified character is a valid NCName start
483      * character as defined by production [4] in Namespaces in XML
484      * recommendation.
485      *
486      * @param c The character to check.
487      */
488     public static boolean isNCNameStart(int c) {
489         return c < 0x10000 && (CHARS[c] & MASK_NCNAME_START) != 0;
490     } // isNCNameStart(int):boolean
491 
492     /**
493      * Returns true if the specified character is a valid NCName
494      * character as defined by production [5] in Namespaces in XML
495      * recommendation.
496      *
497      * @param c The character to check.
498      */
499     public static boolean isNCName(int c) {
500         return c < 0x10000 && (CHARS[c] & MASK_NCNAME) != 0;
501     } // isNCName(int):boolean
502 
503     /**
504      * Returns true if the specified character is a valid Pubid
505      * character as defined by production [13] in the XML 1.0
506      * specification.
507      *
508      * @param c The character to check.
509      */
510     public static boolean isPubid(int c) {
511         return c < 0x10000 && (CHARS[c] & MASK_PUBID) != 0;
512     } // isPubid(int):boolean
513 
514     /*
515      * [5] Name ::= (Letter | '_' | ':') (NameChar)*
516      */
517     /**
518      * Check to see if a string is a valid Name according to [5]
519      * in the XML 1.0 Recommendation
520      *
521      * @param name string to check
522      * @return true if name is a valid Name
523      */
524     public static boolean isValidName(String   name) {
525         if (name.length() == 0)
526             return false;
527         char ch = name.charAt(0);
528         if( isNameStart(ch) == false)
529            return false;
530         for (int i = 1; i < name.length(); i++ ) {
531            ch = name.charAt(i);
532            if( isName( ch ) == false ){
533               return false;
534            }
535         }
536         return true;
537     } // isValidName(String):boolean
538 
539 
540     /*
541      * from the namespace rec
542      * [4] NCName ::= (Letter | '_') (NCNameChar)*
543      */
544     /**
545      * Check to see if a string is a valid NCName according to [4]
546      * from the XML Namespaces 1.0 Recommendation
547      *
548      * @param ncName string to check
549      * @return true if name is a valid NCName
550      */
551     public static boolean isValidNCName(String   ncName) {
552         if (ncName.length() == 0)
553             return false;
554         char ch = ncName.charAt(0);
555         if( isNCNameStart(ch) == false)
556            return false;
557         for (int i = 1; i < ncName.length(); i++ ) {
558            ch = ncName.charAt(i);
559            if( isNCName( ch ) == false ){
560               return false;
561            }
562         }
563         return true;
564     } // isValidNCName(String):boolean
565 
566     /*
567      * [7] Nmtoken ::= (NameChar)+
568      */
569     /**
570      * Check to see if a string is a valid Nmtoken according to [7]
571      * in the XML 1.0 Recommendation
572      *
573      * @param nmtoken string to check
574      * @return true if nmtoken is a valid Nmtoken
575      */
576     public static boolean isValidNmtoken(String   nmtoken) {
577         if (nmtoken.length() == 0)
578             return false;
579         for (int i = 0; i < nmtoken.length(); i++ ) {
580            char ch = nmtoken.charAt(i);
581            if(  ! isName( ch ) ){
582               return false;
583            }
584         }
585         return true;
586     } // isValidName(String):boolean
587 
588 
589 
590 
591 
592     // encodings
593 
594     /**
595      * Returns true if the encoding name is a valid IANA encoding.
596      * This method does not verify that there is a decoder available
597      * for this encoding, only that the characters are valid for an
598      * IANA encoding name.
599      *
600      * @param ianaEncoding The IANA encoding name.
601      */
602     public static boolean isValidIANAEncoding(String   ianaEncoding) {
603         if (ianaEncoding != null) {
604             int length = ianaEncoding.length();
605             if (length > 0) {
606                 char c = ianaEncoding.charAt(0);
607                 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
608                     for (int i = 1; i < length; i++) {
609                         c = ianaEncoding.charAt(i);
610                         if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') &&
611                             (c < '0' || c > '9') && c != '.' && c != '_' &&
612                             c != '-') {
613                             return false;
614                         }
615                     }
616                     return true;
617                 }
618             }
619         }
620         return false;
621     } // isValidIANAEncoding(String):boolean
622 
623     /**
624      * Returns true if the encoding name is a valid Java encoding.
625      * This method does not verify that there is a decoder available
626      * for this encoding, only that the characters are valid for an
627      * Java encoding name.
628      *
629      * @param javaEncoding The Java encoding name.
630      */
631     public static boolean isValidJavaEncoding(String   javaEncoding) {
632         if (javaEncoding != null) {
633             int length = javaEncoding.length();
634             if (length > 0) {
635                 for (int i = 1; i < length; i++) {
636                     char c = javaEncoding.charAt(i);
637                     if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') &&
638                         (c < '0' || c > '9') && c != '.' && c != '_' &&
639                         c != '-') {
640                         return false;
641                     }
642                 }
643                 return true;
644             }
645         }
646         return false;
647     } // isValidIANAEncoding(String):boolean
648 
649 } // class XMLChar
650
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags