Xerces-C++ 3.2.5

XMLChar.hpp
Go to the documentation of this file.
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/*
19 * $Id$
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_XMLCHAR_HPP)
23#define XERCESC_INCLUDE_GUARD_XMLCHAR_HPP
24
25#include <xercesc/util/XMLUniDefs.hpp>
26
27 XERCES_CPP_NAMESPACE_BEGIN
28
29// ---------------------------------------------------------------------------
30// This file defines Char and utility that conforms to XML 1.0 and XML 1.1
31// ---------------------------------------------------------------------------
32// Masks for the fgCharCharsTable1_0 array
33 const XMLByte gNCNameCharMask = 0x1;
34 const XMLByte gFirstNameCharMask = 0x2;
35 const XMLByte gNameCharMask = 0x4;
36 const XMLByte gPlainContentCharMask = 0x8;
37 const XMLByte gSpecialStartTagCharMask = 0x10;
38 const XMLByte gControlCharMask = 0x20;
39 const XMLByte gXMLCharMask = 0x40;
40 const XMLByte gWhitespaceCharMask = 0x80;
41
42// ---------------------------------------------------------------------------
43// This class is for XML 1.0
44// ---------------------------------------------------------------------------
45 class XMLUTIL_EXPORT XMLChar1_0
46{
47 public:
48 // -----------------------------------------------------------------------
49 // Public, static methods, check the string
50 // -----------------------------------------------------------------------
51 static bool isAllSpaces
52 (
53 const XMLCh* const toCheck
54 , const XMLSize_t count
55 );
56
57 static bool containsWhiteSpace
58 (
59 const XMLCh* const toCheck
60 , const XMLSize_t count
61 );
62
63 static bool isValidNmtoken
64 (
65 const XMLCh* const toCheck
66 , const XMLSize_t count
67 );
68
69 static bool isValidName
70 (
71 const XMLCh* const toCheck
72 , const XMLSize_t count
73 );
74
75 static bool isValidName
76 (
77 const XMLCh* const toCheck
78 );
79
80 static bool isValidNCName
81 (
82 const XMLCh* const toCheck
83 , const XMLSize_t count
84 );
85
86 static bool isValidQName
87 (
88 const XMLCh* const toCheck
89 , const XMLSize_t count
90 );
91
92 // -----------------------------------------------------------------------
93 // Public, static methods, check the XMLCh
94 // surrogate pair is assumed if second parameter is not null
95 // -----------------------------------------------------------------------
96 static bool isXMLLetter(const XMLCh toCheck, const XMLCh toCheck2 = 0);
97 static bool isFirstNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
98 static bool isNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
99 static bool isPlainContentChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
100 static bool isSpecialStartTagChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
101 static bool isXMLChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
102 static bool isWhitespace(const XMLCh toCheck);
103 static bool isWhitespace(const XMLCh toCheck, const XMLCh toCheck2);
104 static bool isControlChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
105
106 static bool isPublicIdChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
107 static bool isFirstNCNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
108 static bool isNCNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
109
110 // -----------------------------------------------------------------------
111 // Special Non-conformant Public, static methods
112 // -----------------------------------------------------------------------
116 static bool isNELRecognized();
117
121 static void enableNELWS();
122
123 private:
124 // -----------------------------------------------------------------------
125 // Unimplemented constructors and operators
126 // -----------------------------------------------------------------------
127 XMLChar1_0();
128
129 // -----------------------------------------------------------------------
130 // Static data members
131 //
132 // fgCharCharsTable1_0
133 // The character characteristics table. Bits in each byte, represent
134 // the characteristics of each character. It is generated via some
135 // code and then hard coded into the cpp file for speed.
136 //
137 // fNEL
138 // Flag to represents whether NEL and LSEP newline recognition is enabled
139 // or disabled
140 // -----------------------------------------------------------------------
141 static XMLByte fgCharCharsTable1_0[0x10000];
142 static bool enableNEL;
143
144 friend class XMLReader;
145};
146
147
148// ---------------------------------------------------------------------------
149// XMLReader: Public, static methods
150// ---------------------------------------------------------------------------
151 inline bool XMLChar1_0::isXMLLetter(const XMLCh toCheck, const XMLCh toCheck2)
152{
153 // An XML letter is a FirstNameChar minus ':' and '_'.
154 if (!toCheck2) {
155 return (((fgCharCharsTable1_0[toCheck] & gFirstNameCharMask) != 0)
156 && (toCheck != chColon) && (toCheck != chUnderscore));
157 }
158 return false;
159}
160
161 inline bool XMLChar1_0::isFirstNameChar(const XMLCh toCheck, const XMLCh toCheck2)
162{
163 if (!toCheck2)
164 return ((fgCharCharsTable1_0[toCheck] & gFirstNameCharMask) != 0);
165 else {
166 if ((toCheck >= 0xD800) && (toCheck <= 0xDB7F))
167 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
168 return true;
169 }
170 return false;
171}
172
173 inline bool XMLChar1_0::isFirstNCNameChar(const XMLCh toCheck, const XMLCh toCheck2)
174{
175 if (!toCheck2) {
176 return (((fgCharCharsTable1_0[toCheck] & gFirstNameCharMask) != 0) && (toCheck != chColon));
177 }
178 else {
179 if ((toCheck >= 0xD800) && (toCheck <= 0xDB7F))
180 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
181 return true;
182 }
183 return false;
184}
185
186 inline bool XMLChar1_0::isNameChar(const XMLCh toCheck, const XMLCh toCheck2)
187{
188 if (!toCheck2)
189 return ((fgCharCharsTable1_0[toCheck] & gNameCharMask) != 0);
190 else {
191 if ((toCheck >= 0xD800) && (toCheck <= 0xDB7F))
192 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
193 return true;
194 }
195 return false;
196}
197
198 inline bool XMLChar1_0::isNCNameChar(const XMLCh toCheck, const XMLCh toCheck2)
199{
200 if (!toCheck2)
201 return ((fgCharCharsTable1_0[toCheck] & gNCNameCharMask) != 0);
202 else {
203 if ((toCheck >= 0xD800) && (toCheck <= 0xDB7F))
204 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
205 return true;
206 }
207 return false;
208}
209
210 inline bool XMLChar1_0::isPlainContentChar(const XMLCh toCheck, const XMLCh toCheck2)
211{
212 if (!toCheck2)
213 return ((fgCharCharsTable1_0[toCheck] & gPlainContentCharMask) != 0);
214 else {
215 if ((toCheck >= 0xD800) && (toCheck <= 0xDBFF))
216 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
217 return true;
218 }
219 return false;
220}
221
222
223 inline bool XMLChar1_0::isSpecialStartTagChar(const XMLCh toCheck, const XMLCh toCheck2)
224{
225 if (!toCheck2)
226 return ((fgCharCharsTable1_0[toCheck] & gSpecialStartTagCharMask) != 0);
227 return false;
228}
229
230 inline bool XMLChar1_0::isXMLChar(const XMLCh toCheck, const XMLCh toCheck2)
231{
232 if (!toCheck2)
233 return ((fgCharCharsTable1_0[toCheck] & gXMLCharMask) != 0);
234 else {
235 if ((toCheck >= 0xD800) && (toCheck <= 0xDBFF))
236 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
237 return true;
238 }
239 return false;
240}
241
242 inline bool XMLChar1_0::isWhitespace(const XMLCh toCheck)
243{
244 return ((fgCharCharsTable1_0[toCheck] & gWhitespaceCharMask) != 0);
245}
246
247 inline bool XMLChar1_0::isWhitespace(const XMLCh toCheck, const XMLCh toCheck2)
248{
249 if (!toCheck2)
250 return ((fgCharCharsTable1_0[toCheck] & gWhitespaceCharMask) != 0);
251 return false;
252}
253
254 inline bool XMLChar1_0::isControlChar(const XMLCh toCheck, const XMLCh toCheck2)
255{
256 if (!toCheck2)
257 return ((fgCharCharsTable1_0[toCheck] & gControlCharMask) != 0);
258 return false;
259}
260
261 inline bool XMLChar1_0::isNELRecognized() {
262
263 return enableNEL;
264}
265
266
267// ---------------------------------------------------------------------------
268// This class is for XML 1.1
269// ---------------------------------------------------------------------------
270 class XMLUTIL_EXPORT XMLChar1_1
271{
272 public:
273 // -----------------------------------------------------------------------
274 // Public, static methods, check the string
275 // -----------------------------------------------------------------------
276 static bool isAllSpaces
277 (
278 const XMLCh* const toCheck
279 , const XMLSize_t count
280 );
281
282 static bool containsWhiteSpace
283 (
284 const XMLCh* const toCheck
285 , const XMLSize_t count
286 );
287
288 static bool isValidNmtoken
289 (
290 const XMLCh* const toCheck
291 , const XMLSize_t count
292 );
293
294 static bool isValidName
295 (
296 const XMLCh* const toCheck
297 , const XMLSize_t count
298 );
299
300 static bool isValidName
301 (
302 const XMLCh* const toCheck
303 );
304
305 static bool isValidNCName
306 (
307 const XMLCh* const toCheck
308 , const XMLSize_t count
309 );
310
311 static bool isValidQName
312 (
313 const XMLCh* const toCheck
314 , const XMLSize_t count
315 );
316
317 // -----------------------------------------------------------------------
318 // Public, static methods, check the XMLCh
319 // -----------------------------------------------------------------------
320 static bool isXMLLetter(const XMLCh toCheck, const XMLCh toCheck2 = 0);
321 static bool isFirstNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
322 static bool isNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
323 static bool isPlainContentChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
324 static bool isSpecialStartTagChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
325 static bool isXMLChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
326 static bool isWhitespace(const XMLCh toCheck, const XMLCh toCheck2 = 0);
327 static bool isControlChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
328
329 static bool isPublicIdChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
330 static bool isFirstNCNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
331 static bool isNCNameChar(const XMLCh toCheck, const XMLCh toCheck2 = 0);
332
333 private:
334 // -----------------------------------------------------------------------
335 // Unimplemented constructors and operators
336 // -----------------------------------------------------------------------
337 XMLChar1_1();
338
339 // -----------------------------------------------------------------------
340 // Static data members
341 //
342 // fgCharCharsTable1_1
343 // The character characteristics table. Bits in each byte, represent
344 // the characteristics of each character. It is generated via some
345 // code and then hard coded into the cpp file for speed.
346 //
347 // -----------------------------------------------------------------------
348 static XMLByte fgCharCharsTable1_1[0x10000];
349
350 friend class XMLReader;
351};
352
353
354// ---------------------------------------------------------------------------
355// XMLReader: Public, static methods
356// ---------------------------------------------------------------------------
357 inline bool XMLChar1_1::isXMLLetter(const XMLCh toCheck, const XMLCh toCheck2)
358{
360 return XMLChar1_0::isXMLLetter(toCheck, toCheck2);
361}
362
363 inline bool XMLChar1_1::isFirstNameChar(const XMLCh toCheck, const XMLCh toCheck2)
364{
365 if (!toCheck2)
366 return ((fgCharCharsTable1_1[toCheck] & gFirstNameCharMask) != 0);
367 else {
368 if ((toCheck >= 0xD800) && (toCheck <= 0xDB7F))
369 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
370 return true;
371 }
372 return false;
373}
374
375 inline bool XMLChar1_1::isFirstNCNameChar(const XMLCh toCheck, const XMLCh toCheck2)
376{
377 if (!toCheck2) {
378 return (((fgCharCharsTable1_1[toCheck] & gFirstNameCharMask) != 0) && (toCheck != chColon));
379 }
380 else {
381 if ((toCheck >= 0xD800) && (toCheck <= 0xDB7F))
382 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
383 return true;
384 }
385 return false;
386}
387
388 inline bool XMLChar1_1::isNameChar(const XMLCh toCheck, const XMLCh toCheck2)
389{
390 if (!toCheck2)
391 return ((fgCharCharsTable1_1[toCheck] & gNameCharMask) != 0);
392 else {
393 if ((toCheck >= 0xD800) && (toCheck <= 0xDB7F))
394 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
395 return true;
396 }
397 return false;
398}
399
400 inline bool XMLChar1_1::isNCNameChar(const XMLCh toCheck, const XMLCh toCheck2)
401{
402 if (!toCheck2)
403 return ((fgCharCharsTable1_1[toCheck] & gNCNameCharMask) != 0);
404 else {
405 if ((toCheck >= 0xD800) && (toCheck <= 0xDB7F))
406 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
407 return true;
408 }
409 return false;
410}
411
412 inline bool XMLChar1_1::isPlainContentChar(const XMLCh toCheck, const XMLCh toCheck2)
413{
414 if (!toCheck2)
415 return ((fgCharCharsTable1_1[toCheck] & gPlainContentCharMask) != 0);
416 else {
417 if ((toCheck >= 0xD800) && (toCheck <= 0xDBFF))
418 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
419 return true;
420 }
421 return false;
422}
423
424
425 inline bool XMLChar1_1::isSpecialStartTagChar(const XMLCh toCheck, const XMLCh toCheck2)
426{
427 if (!toCheck2)
428 return ((fgCharCharsTable1_1[toCheck] & gSpecialStartTagCharMask) != 0);
429 return false;
430}
431
432 inline bool XMLChar1_1::isXMLChar(const XMLCh toCheck, const XMLCh toCheck2)
433{
434 if (!toCheck2)
435 return ((fgCharCharsTable1_1[toCheck] & gXMLCharMask) != 0);
436 else {
437 if ((toCheck >= 0xD800) && (toCheck <= 0xDBFF))
438 if ((toCheck2 >= 0xDC00) && (toCheck2 <= 0xDFFF))
439 return true;
440 }
441 return false;
442}
443
444 inline bool XMLChar1_1::isWhitespace(const XMLCh toCheck, const XMLCh toCheck2)
445{
446 if (!toCheck2)
447 return ((fgCharCharsTable1_1[toCheck] & gWhitespaceCharMask) != 0);
448 return false;
449}
450
451 inline bool XMLChar1_1::isControlChar(const XMLCh toCheck, const XMLCh toCheck2)
452{
453 if (!toCheck2)
454 return ((fgCharCharsTable1_1[toCheck] & gControlCharMask) != 0);
455 return false;
456}
457
458
459 XERCES_CPP_NAMESPACE_END
460
461#endif
gPlainContentCharMask
const XMLByte gPlainContentCharMask
Definition XMLChar.hpp:36
gNameCharMask
const XMLByte gNameCharMask
Definition XMLChar.hpp:35
gXMLCharMask
const XMLByte gXMLCharMask
Definition XMLChar.hpp:39
gNCNameCharMask
XERCES_CPP_NAMESPACE_BEGIN const XMLByte gNCNameCharMask
Definition XMLChar.hpp:33
gSpecialStartTagCharMask
const XMLByte gSpecialStartTagCharMask
Definition XMLChar.hpp:37
gFirstNameCharMask
const XMLByte gFirstNameCharMask
Definition XMLChar.hpp:34
gControlCharMask
const XMLByte gControlCharMask
Definition XMLChar.hpp:38
gWhitespaceCharMask
const XMLByte gWhitespaceCharMask
Definition XMLChar.hpp:40
XMLUniDefs.hpp
chUnderscore
const XMLCh chUnderscore
Definition XMLUniDefs.hpp:76
chColon
const XMLCh chColon
Definition XMLUniDefs.hpp:53
XERCES_CPP_NAMESPACE_BEGIN
#define XERCES_CPP_NAMESPACE_BEGIN
Definition XercesDefs.hpp:112
XMLByte
unsigned char XMLByte
Definition XercesDefs.hpp:65
XMLUTIL_EXPORT
#define XMLUTIL_EXPORT
Definition XercesDefs.hpp:162
XERCES_CPP_NAMESPACE_END
#define XERCES_CPP_NAMESPACE_END
Definition XercesDefs.hpp:113
XMLCh
uint16_t XMLCh
Definition Xerces_autoconf_config.hpp:120
XMLSize_t
size_t XMLSize_t
Definition Xerces_autoconf_config.hpp:112
XMLChar1_0
Definition XMLChar.hpp:46
XMLChar1_0::isValidName
static bool isValidName(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_0::isSpecialStartTagChar
static bool isSpecialStartTagChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:223
XMLChar1_0::isValidQName
static bool isValidQName(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_0::isControlChar
static bool isControlChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:254
XMLChar1_0::isValidName
static bool isValidName(const XMLCh *const toCheck)
XMLChar1_0::isPlainContentChar
static bool isPlainContentChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:210
XMLChar1_0::isNameChar
static bool isNameChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:186
XMLChar1_0::isValidNCName
static bool isValidNCName(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_0::isValidNmtoken
static bool isValidNmtoken(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_0::isXMLLetter
static bool isXMLLetter(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:151
XMLChar1_0::containsWhiteSpace
static bool containsWhiteSpace(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_0::isXMLChar
static bool isXMLChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:230
XMLChar1_0::isNCNameChar
static bool isNCNameChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:198
XMLChar1_0::isWhitespace
static bool isWhitespace(const XMLCh toCheck)
Definition XMLChar.hpp:242
XMLChar1_0::isPublicIdChar
static bool isPublicIdChar(const XMLCh toCheck, const XMLCh toCheck2=0)
XMLChar1_0::isNELRecognized
static bool isNELRecognized()
Return true if NEL (0x85) and LSEP (0x2028) to be treated as white space char.
Definition XMLChar.hpp:261
XMLChar1_0::enableNELWS
static void enableNELWS()
Method to enable NEL (0x85) and LSEP (0x2028) to be treated as white space char.
XMLChar1_0::isAllSpaces
static bool isAllSpaces(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_0::isFirstNameChar
static bool isFirstNameChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:161
XMLChar1_0::isFirstNCNameChar
static bool isFirstNCNameChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:173
XMLChar1_1
Definition XMLChar.hpp:271
XMLChar1_1::isValidQName
static bool isValidQName(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_1::isFirstNameChar
static bool isFirstNameChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:363
XMLChar1_1::isFirstNCNameChar
static bool isFirstNCNameChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:375
XMLChar1_1::isSpecialStartTagChar
static bool isSpecialStartTagChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:425
XMLChar1_1::isAllSpaces
static bool isAllSpaces(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_1::isNCNameChar
static bool isNCNameChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:400
XMLChar1_1::isPublicIdChar
static bool isPublicIdChar(const XMLCh toCheck, const XMLCh toCheck2=0)
XMLChar1_1::isPlainContentChar
static bool isPlainContentChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:412
XMLChar1_1::isWhitespace
static bool isWhitespace(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:444
XMLChar1_1::isXMLChar
static bool isXMLChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:432
XMLChar1_1::containsWhiteSpace
static bool containsWhiteSpace(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_1::isValidNmtoken
static bool isValidNmtoken(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_1::isValidNCName
static bool isValidNCName(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_1::isControlChar
static bool isControlChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:451
XMLChar1_1::isValidName
static bool isValidName(const XMLCh *const toCheck, const XMLSize_t count)
XMLChar1_1::isNameChar
static bool isNameChar(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:388
XMLChar1_1::isXMLLetter
static bool isXMLLetter(const XMLCh toCheck, const XMLCh toCheck2=0)
Definition XMLChar.hpp:357
XMLChar1_1::isValidName
static bool isValidName(const XMLCh *const toCheck)