← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/xmlpatterns/schema/qxsdschematoken.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/xmlpatterns/schema/qxsdschematoken.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
 
4
** All rights reserved.
 
5
** Contact: Nokia Corporation (qt-info@nokia.com)
 
6
**
 
7
** This file is part of the QtXmlPatterns module of the Qt Toolkit.
 
8
**
 
9
** $QT_BEGIN_LICENSE:LGPL$
 
10
** No Commercial Usage
 
11
** This file contains pre-release code and may not be distributed.
 
12
** You may use this file in accordance with the terms and conditions
 
13
** contained in the Technology Preview License Agreement accompanying
 
14
** this package.
 
15
**
 
16
** GNU Lesser General Public License Usage
 
17
** Alternatively, this file may be used under the terms of the GNU Lesser
 
18
** General Public License version 2.1 as published by the Free Software
 
19
** Foundation and appearing in the file LICENSE.LGPL included in the
 
20
** packaging of this file.  Please review the following information to
 
21
** ensure the GNU Lesser General Public License version 2.1 requirements
 
22
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
23
**
 
24
** In addition, as a special exception, Nokia gives you certain additional
 
25
** rights.  These rights are described in the Nokia Qt LGPL Exception
 
26
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
27
**
 
28
** If you have questions regarding the use of this file, please contact
 
29
** Nokia at qt-info@nokia.com.
 
30
**
 
31
**
 
32
**
 
33
**
 
34
**
 
35
**
 
36
**
 
37
**
 
38
** $QT_END_LICENSE$
 
39
**
 
40
****************************************************************************/
 
41
 
 
42
/* NOTE: This file is AUTO GENERATED by qautomaton2cpp.xsl. */
 
43
 
 
44
#include "qxsdschematoken_p.h"
 
45
 
 
46
QT_BEGIN_NAMESPACE
 
47
 
 
48
XsdSchemaToken::NodeName XsdSchemaToken::classifier2(const QChar *data)
 
49
 
 
50
        {
 
51
            
 
52
                            static const unsigned short string[] =
 
53
                            {
 
54
                                105, 100
 
55
                            };
 
56
                            if(memcmp(&data[0], &string, sizeof(QChar) * 2) == 0)
 
57
                        
 
58
 
 
59
                return Id;
 
60
            
 
61
 
 
62
            return NoKeyword;
 
63
        }
 
64
    XsdSchemaToken::NodeName XsdSchemaToken::classifier3(const QChar *data)
 
65
 
 
66
        {
 
67
            if (data[0] == 97)
 
68
 
 
69
 
 
70
                    {
 
71
                    if (data[1] == 108)
 
72
 
 
73
 
 
74
                    {
 
75
                    
 
76
                            if(data[2] == 108)
 
77
                        
 
78
 
 
79
                return All;
 
80
            
 
81
                    }
 
82
 
 
83
                else if (data[1] == 110)
 
84
 
 
85
 
 
86
                    {
 
87
                    
 
88
                            if(data[2] == 121)
 
89
                        
 
90
 
 
91
                return Any;
 
92
            
 
93
                    }
 
94
 
 
95
                
 
96
                    }
 
97
 
 
98
                else if (data[0] == 107)
 
99
 
 
100
 
 
101
                    {
 
102
                    
 
103
                            static const unsigned short string[] =
 
104
                            {
 
105
                                101, 121
 
106
                            };
 
107
                            if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
 
108
                        
 
109
 
 
110
                return Key;
 
111
            
 
112
                    }
 
113
 
 
114
                else if (data[0] == 114)
 
115
 
 
116
 
 
117
                    {
 
118
                    
 
119
                            static const unsigned short string[] =
 
120
                            {
 
121
                                101, 102
 
122
                            };
 
123
                            if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
 
124
                        
 
125
 
 
126
                return Ref;
 
127
            
 
128
                    }
 
129
 
 
130
                else if (data[0] == 117)
 
131
 
 
132
 
 
133
                    {
 
134
                    
 
135
                            static const unsigned short string[] =
 
136
                            {
 
137
                                115, 101
 
138
                            };
 
139
                            if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
 
140
                        
 
141
 
 
142
                return Use;
 
143
            
 
144
                    }
 
145
 
 
146
                
 
147
 
 
148
            return NoKeyword;
 
149
        }
 
150
    XsdSchemaToken::NodeName XsdSchemaToken::classifier4(const QChar *data)
 
151
 
 
152
        {
 
153
            if (data[0] == 98)
 
154
 
 
155
 
 
156
                    {
 
157
                    
 
158
                            static const unsigned short string[] =
 
159
                            {
 
160
                                97, 115, 101
 
161
                            };
 
162
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 
163
                        
 
164
 
 
165
                return Base;
 
166
            
 
167
                    }
 
168
 
 
169
                else if (data[0] == 102)
 
170
 
 
171
 
 
172
                    {
 
173
                    
 
174
                            static const unsigned short string[] =
 
175
                            {
 
176
                                111, 114, 109
 
177
                            };
 
178
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 
179
                        
 
180
 
 
181
                return Form;
 
182
            
 
183
                    }
 
184
 
 
185
                else if (data[0] == 108)
 
186
 
 
187
 
 
188
                    {
 
189
                    
 
190
                            static const unsigned short string[] =
 
191
                            {
 
192
                                105, 115, 116
 
193
                            };
 
194
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 
195
                        
 
196
 
 
197
                return List;
 
198
            
 
199
                    }
 
200
 
 
201
                else if (data[0] == 109)
 
202
 
 
203
 
 
204
                    {
 
205
                    
 
206
                            static const unsigned short string[] =
 
207
                            {
 
208
                                111, 100, 101
 
209
                            };
 
210
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 
211
                        
 
212
 
 
213
                return Mode;
 
214
            
 
215
                    }
 
216
 
 
217
                else if (data[0] == 110)
 
218
 
 
219
 
 
220
                    {
 
221
                    
 
222
                            static const unsigned short string[] =
 
223
                            {
 
224
                                97, 109, 101
 
225
                            };
 
226
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 
227
                        
 
228
 
 
229
                return Name;
 
230
            
 
231
                    }
 
232
 
 
233
                else if (data[0] == 116)
 
234
 
 
235
 
 
236
                    {
 
237
                    if (data[1] == 101)
 
238
 
 
239
 
 
240
                    {
 
241
                    
 
242
                            static const unsigned short string[] =
 
243
                            {
 
244
                                115, 116
 
245
                            };
 
246
                            if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0)
 
247
                        
 
248
 
 
249
                return Test;
 
250
            
 
251
                    }
 
252
 
 
253
                else if (data[1] == 121)
 
254
 
 
255
 
 
256
                    {
 
257
                    
 
258
                            static const unsigned short string[] =
 
259
                            {
 
260
                                112, 101
 
261
                            };
 
262
                            if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0)
 
263
                        
 
264
 
 
265
                return Type;
 
266
            
 
267
                    }
 
268
 
 
269
                
 
270
                    }
 
271
 
 
272
                
 
273
 
 
274
            return NoKeyword;
 
275
        }
 
276
    XsdSchemaToken::NodeName XsdSchemaToken::classifier5(const QChar *data)
 
277
 
 
278
        {
 
279
            if (data[0] == 98)
 
280
 
 
281
 
 
282
                    {
 
283
                    
 
284
                            static const unsigned short string[] =
 
285
                            {
 
286
                                108, 111, 99, 107
 
287
                            };
 
288
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 
289
                        
 
290
 
 
291
                return Block;
 
292
            
 
293
                    }
 
294
 
 
295
                else if (data[0] == 102)
 
296
 
 
297
 
 
298
                    {
 
299
                    if (data[1] == 105)
 
300
 
 
301
 
 
302
                    {
 
303
                    if (data[2] == 101)
 
304
 
 
305
 
 
306
                    {
 
307
                    
 
308
                            static const unsigned short string[] =
 
309
                            {
 
310
                                108, 100
 
311
                            };
 
312
                            if(memcmp(&data[3], &string, sizeof(QChar) * 2) == 0)
 
313
                        
 
314
 
 
315
                return Field;
 
316
            
 
317
                    }
 
318
 
 
319
                else if (data[2] == 110)
 
320
 
 
321
 
 
322
                    {
 
323
                    
 
324
                            static const unsigned short string[] =
 
325
                            {
 
326
                                97, 108
 
327
                            };
 
328
                            if(memcmp(&data[3], &string, sizeof(QChar) * 2) == 0)
 
329
                        
 
330
 
 
331
                return Final;
 
332
            
 
333
                    }
 
334
 
 
335
                else if (data[2] == 120)
 
336
 
 
337
 
 
338
                    {
 
339
                    
 
340
                            static const unsigned short string[] =
 
341
                            {
 
342
                                101, 100
 
343
                            };
 
344
                            if(memcmp(&data[3], &string, sizeof(QChar) * 2) == 0)
 
345
                        
 
346
 
 
347
                return Fixed;
 
348
            
 
349
                    }
 
350
 
 
351
                
 
352
                    }
 
353
 
 
354
                
 
355
                    }
 
356
 
 
357
                else if (data[0] == 103)
 
358
 
 
359
 
 
360
                    {
 
361
                    
 
362
                            static const unsigned short string[] =
 
363
                            {
 
364
                                114, 111, 117, 112
 
365
                            };
 
366
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 
367
                        
 
368
 
 
369
                return Group;
 
370
            
 
371
                    }
 
372
 
 
373
                else if (data[0] == 109)
 
374
 
 
375
 
 
376
                    {
 
377
                    
 
378
                            static const unsigned short string[] =
 
379
                            {
 
380
                                105, 120, 101, 100
 
381
                            };
 
382
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 
383
                        
 
384
 
 
385
                return Mixed;
 
386
            
 
387
                    }
 
388
 
 
389
                else if (data[0] == 114)
 
390
 
 
391
 
 
392
                    {
 
393
                    
 
394
                            static const unsigned short string[] =
 
395
                            {
 
396
                                101, 102, 101, 114
 
397
                            };
 
398
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 
399
                        
 
400
 
 
401
                return Refer;
 
402
            
 
403
                    }
 
404
 
 
405
                else if (data[0] == 117)
 
406
 
 
407
 
 
408
                    {
 
409
                    
 
410
                            static const unsigned short string[] =
 
411
                            {
 
412
                                110, 105, 111, 110
 
413
                            };
 
414
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 
415
                        
 
416
 
 
417
                return Union;
 
418
            
 
419
                    }
 
420
 
 
421
                else if (data[0] == 118)
 
422
 
 
423
 
 
424
                    {
 
425
                    
 
426
                            static const unsigned short string[] =
 
427
                            {
 
428
                                97, 108, 117, 101
 
429
                            };
 
430
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 
431
                        
 
432
 
 
433
                return Value;
 
434
            
 
435
                    }
 
436
 
 
437
                else if (data[0] == 120)
 
438
 
 
439
 
 
440
                    {
 
441
                    
 
442
                            static const unsigned short string[] =
 
443
                            {
 
444
                                112, 97, 116, 104
 
445
                            };
 
446
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 
447
                        
 
448
 
 
449
                return Xpath;
 
450
            
 
451
                    }
 
452
 
 
453
                
 
454
 
 
455
            return NoKeyword;
 
456
        }
 
457
    XsdSchemaToken::NodeName XsdSchemaToken::classifier6(const QChar *data)
 
458
 
 
459
        {
 
460
            if (data[0] == 97)
 
461
 
 
462
 
 
463
                    {
 
464
                    
 
465
                            static const unsigned short string[] =
 
466
                            {
 
467
                                115, 115, 101, 114, 116
 
468
                            };
 
469
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 
470
                        
 
471
 
 
472
                return Assert;
 
473
            
 
474
                    }
 
475
 
 
476
                else if (data[0] == 99)
 
477
 
 
478
 
 
479
                    {
 
480
                    
 
481
                            static const unsigned short string[] =
 
482
                            {
 
483
                                104, 111, 105, 99, 101
 
484
                            };
 
485
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 
486
                        
 
487
 
 
488
                return Choice;
 
489
            
 
490
                    }
 
491
 
 
492
                else if (data[0] == 105)
 
493
 
 
494
 
 
495
                    {
 
496
                    
 
497
                            static const unsigned short string[] =
 
498
                            {
 
499
                                109, 112, 111, 114, 116
 
500
                            };
 
501
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 
502
                        
 
503
 
 
504
                return Import;
 
505
            
 
506
                    }
 
507
 
 
508
                else if (data[0] == 107)
 
509
 
 
510
 
 
511
                    {
 
512
                    
 
513
                            static const unsigned short string[] =
 
514
                            {
 
515
                                101, 121, 114, 101, 102
 
516
                            };
 
517
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 
518
                        
 
519
 
 
520
                return Keyref;
 
521
            
 
522
                    }
 
523
 
 
524
                else if (data[0] == 108)
 
525
 
 
526
 
 
527
                    {
 
528
                    
 
529
                            static const unsigned short string[] =
 
530
                            {
 
531
                                101, 110, 103, 116, 104
 
532
                            };
 
533
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 
534
                        
 
535
 
 
536
                return Length;
 
537
            
 
538
                    }
 
539
 
 
540
                else if (data[0] == 112)
 
541
 
 
542
 
 
543
                    {
 
544
                    
 
545
                            static const unsigned short string[] =
 
546
                            {
 
547
                                117, 98, 108, 105, 99
 
548
                            };
 
549
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 
550
                        
 
551
 
 
552
                return Public;
 
553
            
 
554
                    }
 
555
 
 
556
                else if (data[0] == 115)
 
557
 
 
558
 
 
559
                    {
 
560
                    if (data[1] == 99)
 
561
 
 
562
 
 
563
                    {
 
564
                    
 
565
                            static const unsigned short string[] =
 
566
                            {
 
567
                                104, 101, 109, 97
 
568
                            };
 
569
                            if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
 
570
                        
 
571
 
 
572
                return Schema;
 
573
            
 
574
                    }
 
575
 
 
576
                else if (data[1] == 111)
 
577
 
 
578
 
 
579
                    {
 
580
                    
 
581
                            static const unsigned short string[] =
 
582
                            {
 
583
                                117, 114, 99, 101
 
584
                            };
 
585
                            if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
 
586
                        
 
587
 
 
588
                return Source;
 
589
            
 
590
                    }
 
591
 
 
592
                else if (data[1] == 121)
 
593
 
 
594
 
 
595
                    {
 
596
                    
 
597
                            static const unsigned short string[] =
 
598
                            {
 
599
                                115, 116, 101, 109
 
600
                            };
 
601
                            if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
 
602
                        
 
603
 
 
604
                return System;
 
605
            
 
606
                    }
 
607
 
 
608
                
 
609
                    }
 
610
 
 
611
                else if (data[0] == 117)
 
612
 
 
613
 
 
614
                    {
 
615
                    
 
616
                            static const unsigned short string[] =
 
617
                            {
 
618
                                110, 105, 113, 117, 101
 
619
                            };
 
620
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 
621
                        
 
622
 
 
623
                return Unique;
 
624
            
 
625
                    }
 
626
 
 
627
                
 
628
 
 
629
            return NoKeyword;
 
630
        }
 
631
    XsdSchemaToken::NodeName XsdSchemaToken::classifier7(const QChar *data)
 
632
 
 
633
        {
 
634
            if (data[0] == 97)
 
635
 
 
636
 
 
637
                    {
 
638
                    
 
639
                            static const unsigned short string[] =
 
640
                            {
 
641
                                112, 112, 105, 110, 102, 111
 
642
                            };
 
643
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 
644
                        
 
645
 
 
646
                return Appinfo;
 
647
            
 
648
                    }
 
649
 
 
650
                else if (data[0] == 100)
 
651
 
 
652
 
 
653
                    {
 
654
                    
 
655
                            static const unsigned short string[] =
 
656
                            {
 
657
                                101, 102, 97, 117, 108, 116
 
658
                            };
 
659
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 
660
                        
 
661
 
 
662
                return Default;
 
663
            
 
664
                    }
 
665
 
 
666
                else if (data[0] == 101)
 
667
 
 
668
 
 
669
                    {
 
670
                    
 
671
                            static const unsigned short string[] =
 
672
                            {
 
673
                                108, 101, 109, 101, 110, 116
 
674
                            };
 
675
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 
676
                        
 
677
 
 
678
                return Element;
 
679
            
 
680
                    }
 
681
 
 
682
                else if (data[0] == 105)
 
683
 
 
684
 
 
685
                    {
 
686
                    
 
687
                            static const unsigned short string[] =
 
688
                            {
 
689
                                110, 99, 108, 117, 100, 101
 
690
                            };
 
691
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 
692
                        
 
693
 
 
694
                return Include;
 
695
            
 
696
                    }
 
697
 
 
698
                else if (data[0] == 112)
 
699
 
 
700
 
 
701
                    {
 
702
                    
 
703
                            static const unsigned short string[] =
 
704
                            {
 
705
                                97, 116, 116, 101, 114, 110
 
706
                            };
 
707
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 
708
                        
 
709
 
 
710
                return Pattern;
 
711
            
 
712
                    }
 
713
 
 
714
                else if (data[0] == 114)
 
715
 
 
716
 
 
717
                    {
 
718
                    
 
719
                            static const unsigned short string[] =
 
720
                            {
 
721
                                101, 112, 108, 97, 99, 101
 
722
                            };
 
723
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 
724
                        
 
725
 
 
726
                return Replace;
 
727
            
 
728
                    }
 
729
 
 
730
                else if (data[0] == 118)
 
731
 
 
732
 
 
733
                    {
 
734
                    
 
735
                            static const unsigned short string[] =
 
736
                            {
 
737
                                101, 114, 115, 105, 111, 110
 
738
                            };
 
739
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 
740
                        
 
741
 
 
742
                return Version;
 
743
            
 
744
                    }
 
745
 
 
746
                
 
747
 
 
748
            return NoKeyword;
 
749
        }
 
750
    XsdSchemaToken::NodeName XsdSchemaToken::classifier8(const QChar *data)
 
751
 
 
752
        {
 
753
            if (data[0] == 97)
 
754
 
 
755
 
 
756
                    {
 
757
                    
 
758
                            static const unsigned short string[] =
 
759
                            {
 
760
                                98, 115, 116, 114, 97, 99, 116
 
761
                            };
 
762
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 
763
                        
 
764
 
 
765
                return Abstract;
 
766
            
 
767
                    }
 
768
 
 
769
                else if (data[0] == 99)
 
770
 
 
771
 
 
772
                    {
 
773
                    
 
774
                            static const unsigned short string[] =
 
775
                            {
 
776
                                111, 108, 108, 97, 112, 115, 101
 
777
                            };
 
778
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 
779
                        
 
780
 
 
781
                return Collapse;
 
782
            
 
783
                    }
 
784
 
 
785
                else if (data[0] == 105)
 
786
 
 
787
 
 
788
                    {
 
789
                    
 
790
                            static const unsigned short string[] =
 
791
                            {
 
792
                                116, 101, 109, 84, 121, 112, 101
 
793
                            };
 
794
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 
795
                        
 
796
 
 
797
                return ItemType;
 
798
            
 
799
                    }
 
800
 
 
801
                else if (data[0] == 110)
 
802
 
 
803
 
 
804
                    {
 
805
                    if (data[1] == 105)
 
806
 
 
807
 
 
808
                    {
 
809
                    
 
810
                            static const unsigned short string[] =
 
811
                            {
 
812
                                108, 108, 97, 98, 108, 101
 
813
                            };
 
814
                            if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
 
815
                        
 
816
 
 
817
                return Nillable;
 
818
            
 
819
                    }
 
820
 
 
821
                else if (data[1] == 111)
 
822
 
 
823
 
 
824
                    {
 
825
                    if (data[2] == 116)
 
826
 
 
827
 
 
828
                    {
 
829
                    if (data[3] == 97)
 
830
 
 
831
 
 
832
                    {
 
833
                    
 
834
                            static const unsigned short string[] =
 
835
                            {
 
836
                                116, 105, 111, 110
 
837
                            };
 
838
                            if(memcmp(&data[4], &string, sizeof(QChar) * 4) == 0)
 
839
                        
 
840
 
 
841
                return Notation;
 
842
            
 
843
                    }
 
844
 
 
845
                else if (data[3] == 81)
 
846
 
 
847
 
 
848
                    {
 
849
                    
 
850
                            static const unsigned short string[] =
 
851
                            {
 
852
                                78, 97, 109, 101
 
853
                            };
 
854
                            if(memcmp(&data[4], &string, sizeof(QChar) * 4) == 0)
 
855
                        
 
856
 
 
857
                return NotQName;
 
858
            
 
859
                    }
 
860
 
 
861
                
 
862
                    }
 
863
 
 
864
                
 
865
                    }
 
866
 
 
867
                
 
868
                    }
 
869
 
 
870
                else if (data[0] == 111)
 
871
 
 
872
 
 
873
                    {
 
874
                    
 
875
                            static const unsigned short string[] =
 
876
                            {
 
877
                                118, 101, 114, 114, 105, 100, 101
 
878
                            };
 
879
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 
880
                        
 
881
 
 
882
                return Override;
 
883
            
 
884
                    }
 
885
 
 
886
                else if (data[0] == 112)
 
887
 
 
888
 
 
889
                    {
 
890
                    
 
891
                            static const unsigned short string[] =
 
892
                            {
 
893
                                114, 101, 115, 101, 114, 118, 101
 
894
                            };
 
895
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 
896
                        
 
897
 
 
898
                return Preserve;
 
899
            
 
900
                    }
 
901
 
 
902
                else if (data[0] == 114)
 
903
 
 
904
 
 
905
                    {
 
906
                    
 
907
                            static const unsigned short string[] =
 
908
                            {
 
909
                                101, 100, 101, 102, 105, 110, 101
 
910
                            };
 
911
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 
912
                        
 
913
 
 
914
                return Redefine;
 
915
            
 
916
                    }
 
917
 
 
918
                else if (data[0] == 115)
 
919
 
 
920
 
 
921
                    {
 
922
                    if (data[1] == 101)
 
923
 
 
924
 
 
925
                    {
 
926
                    if (data[2] == 108)
 
927
 
 
928
 
 
929
                    {
 
930
                    
 
931
                            static const unsigned short string[] =
 
932
                            {
 
933
                                101, 99, 116, 111, 114
 
934
                            };
 
935
                            if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0)
 
936
                        
 
937
 
 
938
                return Selector;
 
939
            
 
940
                    }
 
941
 
 
942
                else if (data[2] == 113)
 
943
 
 
944
 
 
945
                    {
 
946
                    
 
947
                            static const unsigned short string[] =
 
948
                            {
 
949
                                117, 101, 110, 99, 101
 
950
                            };
 
951
                            if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0)
 
952
                        
 
953
 
 
954
                return Sequence;
 
955
            
 
956
                    }
 
957
 
 
958
                
 
959
                    }
 
960
 
 
961
                
 
962
                    }
 
963
 
 
964
                else if (data[0] == 120)
 
965
 
 
966
 
 
967
                    {
 
968
                    
 
969
                            static const unsigned short string[] =
 
970
                            {
 
971
                                109, 108, 58, 108, 97, 110, 103
 
972
                            };
 
973
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 
974
                        
 
975
 
 
976
                return XmlLanguage;
 
977
            
 
978
                    }
 
979
 
 
980
                
 
981
 
 
982
            return NoKeyword;
 
983
        }
 
984
    XsdSchemaToken::NodeName XsdSchemaToken::classifier9(const QChar *data)
 
985
 
 
986
        {
 
987
            if (data[0] == 97)
 
988
 
 
989
 
 
990
                    {
 
991
                    if (data[1] == 115)
 
992
 
 
993
 
 
994
                    {
 
995
                    
 
996
                            static const unsigned short string[] =
 
997
                            {
 
998
                                115, 101, 114, 116, 105, 111, 110
 
999
                            };
 
1000
                            if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0)
 
1001
                        
 
1002
 
 
1003
                return Assertion;
 
1004
            
 
1005
                    }
 
1006
 
 
1007
                else if (data[1] == 116)
 
1008
 
 
1009
 
 
1010
                    {
 
1011
                    
 
1012
                            static const unsigned short string[] =
 
1013
                            {
 
1014
                                116, 114, 105, 98, 117, 116, 101
 
1015
                            };
 
1016
                            if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0)
 
1017
                        
 
1018
 
 
1019
                return Attribute;
 
1020
            
 
1021
                    }
 
1022
 
 
1023
                
 
1024
                    }
 
1025
 
 
1026
                else if (data[0] == 101)
 
1027
 
 
1028
 
 
1029
                    {
 
1030
                    
 
1031
                            static const unsigned short string[] =
 
1032
                            {
 
1033
                                120, 116, 101, 110, 115, 105, 111, 110
 
1034
                            };
 
1035
                            if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
 
1036
                        
 
1037
 
 
1038
                return Extension;
 
1039
            
 
1040
                    }
 
1041
 
 
1042
                else if (data[0] == 109)
 
1043
 
 
1044
 
 
1045
                    {
 
1046
                    if (data[1] == 97)
 
1047
 
 
1048
 
 
1049
                    {
 
1050
                    if (data[2] == 120)
 
1051
 
 
1052
 
 
1053
                    {
 
1054
                    if (data[3] == 76)
 
1055
 
 
1056
 
 
1057
                    {
 
1058
                    
 
1059
                            static const unsigned short string[] =
 
1060
                            {
 
1061
                                101, 110, 103, 116, 104
 
1062
                            };
 
1063
                            if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0)
 
1064
                        
 
1065
 
 
1066
                return MaxLength;
 
1067
            
 
1068
                    }
 
1069
 
 
1070
                else if (data[3] == 79)
 
1071
 
 
1072
 
 
1073
                    {
 
1074
                    
 
1075
                            static const unsigned short string[] =
 
1076
                            {
 
1077
                                99, 99, 117, 114, 115
 
1078
                            };
 
1079
                            if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0)
 
1080
                        
 
1081
 
 
1082
                return MaxOccurs;
 
1083
            
 
1084
                    }
 
1085
 
 
1086
                
 
1087
                    }
 
1088
 
 
1089
                
 
1090
                    }
 
1091
 
 
1092
                else if (data[1] == 105)
 
1093
 
 
1094
 
 
1095
                    {
 
1096
                    if (data[2] == 110)
 
1097
 
 
1098
 
 
1099
                    {
 
1100
                    if (data[3] == 76)
 
1101
 
 
1102
 
 
1103
                    {
 
1104
                    
 
1105
                            static const unsigned short string[] =
 
1106
                            {
 
1107
                                101, 110, 103, 116, 104
 
1108
                            };
 
1109
                            if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0)
 
1110
                        
 
1111
 
 
1112
                return MinLength;
 
1113
            
 
1114
                    }
 
1115
 
 
1116
                else if (data[3] == 79)
 
1117
 
 
1118
 
 
1119
                    {
 
1120
                    
 
1121
                            static const unsigned short string[] =
 
1122
                            {
 
1123
                                99, 99, 117, 114, 115
 
1124
                            };
 
1125
                            if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0)
 
1126
                        
 
1127
 
 
1128
                return MinOccurs;
 
1129
            
 
1130
                    }
 
1131
 
 
1132
                
 
1133
                    }
 
1134
 
 
1135
                
 
1136
                    }
 
1137
 
 
1138
                
 
1139
                    }
 
1140
 
 
1141
                else if (data[0] == 110)
 
1142
 
 
1143
 
 
1144
                    {
 
1145
                    
 
1146
                            static const unsigned short string[] =
 
1147
                            {
 
1148
                                97, 109, 101, 115, 112, 97, 99, 101
 
1149
                            };
 
1150
                            if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
 
1151
                        
 
1152
 
 
1153
                return Namespace;
 
1154
            
 
1155
                    }
 
1156
 
 
1157
                
 
1158
 
 
1159
            return NoKeyword;
 
1160
        }
 
1161
    XsdSchemaToken::NodeName XsdSchemaToken::classifier10(const QChar *data)
 
1162
 
 
1163
        {
 
1164
            if (data[0] == 97)
 
1165
 
 
1166
 
 
1167
                    {
 
1168
                    
 
1169
                            static const unsigned short string[] =
 
1170
                            {
 
1171
                                110, 110, 111, 116, 97, 116, 105, 111, 110
 
1172
                            };
 
1173
                            if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
 
1174
                        
 
1175
 
 
1176
                return Annotation;
 
1177
            
 
1178
                    }
 
1179
 
 
1180
                else if (data[0] == 115)
 
1181
 
 
1182
 
 
1183
                    {
 
1184
                    
 
1185
                            static const unsigned short string[] =
 
1186
                            {
 
1187
                                105, 109, 112, 108, 101, 84, 121, 112, 101
 
1188
                            };
 
1189
                            if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
 
1190
                        
 
1191
 
 
1192
                return SimpleType;
 
1193
            
 
1194
                    }
 
1195
 
 
1196
                else if (data[0] == 119)
 
1197
 
 
1198
 
 
1199
                    {
 
1200
                    
 
1201
                            static const unsigned short string[] =
 
1202
                            {
 
1203
                                104, 105, 116, 101, 83, 112, 97, 99, 101
 
1204
                            };
 
1205
                            if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
 
1206
                        
 
1207
 
 
1208
                return WhiteSpace;
 
1209
            
 
1210
                    }
 
1211
 
 
1212
                
 
1213
 
 
1214
            return NoKeyword;
 
1215
        }
 
1216
    XsdSchemaToken::NodeName XsdSchemaToken::classifier11(const QChar *data)
 
1217
 
 
1218
        {
 
1219
            if (data[0] == 97)
 
1220
 
 
1221
 
 
1222
                    {
 
1223
                    
 
1224
                            static const unsigned short string[] =
 
1225
                            {
 
1226
                                108, 116, 101, 114, 110, 97, 116, 105, 118, 101
 
1227
                            };
 
1228
                            if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
 
1229
                        
 
1230
 
 
1231
                return Alternative;
 
1232
            
 
1233
                    }
 
1234
 
 
1235
                else if (data[0] == 99)
 
1236
 
 
1237
 
 
1238
                    {
 
1239
                    
 
1240
                            static const unsigned short string[] =
 
1241
                            {
 
1242
                                111, 109, 112, 108, 101, 120, 84, 121, 112, 101
 
1243
                            };
 
1244
                            if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
 
1245
                        
 
1246
 
 
1247
                return ComplexType;
 
1248
            
 
1249
                    }
 
1250
 
 
1251
                else if (data[0] == 101)
 
1252
 
 
1253
 
 
1254
                    {
 
1255
                    
 
1256
                            static const unsigned short string[] =
 
1257
                            {
 
1258
                                110, 117, 109, 101, 114, 97, 116, 105, 111, 110
 
1259
                            };
 
1260
                            if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
 
1261
                        
 
1262
 
 
1263
                return Enumeration;
 
1264
            
 
1265
                    }
 
1266
 
 
1267
                else if (data[0] == 109)
 
1268
 
 
1269
 
 
1270
                    {
 
1271
                    
 
1272
                            static const unsigned short string[] =
 
1273
                            {
 
1274
                                101, 109, 98, 101, 114, 84, 121, 112, 101, 115
 
1275
                            };
 
1276
                            if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
 
1277
                        
 
1278
 
 
1279
                return MemberTypes;
 
1280
            
 
1281
                    }
 
1282
 
 
1283
                else if (data[0] == 111)
 
1284
 
 
1285
 
 
1286
                    {
 
1287
                    
 
1288
                            static const unsigned short string[] =
 
1289
                            {
 
1290
                                112, 101, 110, 67, 111, 110, 116, 101, 110, 116
 
1291
                            };
 
1292
                            if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
 
1293
                        
 
1294
 
 
1295
                return OpenContent;
 
1296
            
 
1297
                    }
 
1298
 
 
1299
                else if (data[0] == 114)
 
1300
 
 
1301
 
 
1302
                    {
 
1303
                    
 
1304
                            static const unsigned short string[] =
 
1305
                            {
 
1306
                                101, 115, 116, 114, 105, 99, 116, 105, 111, 110
 
1307
                            };
 
1308
                            if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
 
1309
                        
 
1310
 
 
1311
                return Restriction;
 
1312
            
 
1313
                    }
 
1314
 
 
1315
                else if (data[0] == 116)
 
1316
 
 
1317
 
 
1318
                    {
 
1319
                    
 
1320
                            static const unsigned short string[] =
 
1321
                            {
 
1322
                                111, 116, 97, 108, 68, 105, 103, 105, 116, 115
 
1323
                            };
 
1324
                            if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
 
1325
                        
 
1326
 
 
1327
                return TotalDigits;
 
1328
            
 
1329
                    }
 
1330
 
 
1331
                
 
1332
 
 
1333
            return NoKeyword;
 
1334
        }
 
1335
    XsdSchemaToken::NodeName XsdSchemaToken::classifier12(const QChar *data)
 
1336
 
 
1337
        {
 
1338
            if (data[0] == 97)
 
1339
 
 
1340
 
 
1341
                    {
 
1342
                    
 
1343
                            static const unsigned short string[] =
 
1344
                            {
 
1345
                                110, 121, 65, 116, 116, 114, 105, 98, 117, 116, 101
 
1346
                            };
 
1347
                            if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0)
 
1348
                        
 
1349
 
 
1350
                return AnyAttribute;
 
1351
            
 
1352
                    }
 
1353
 
 
1354
                else if (data[0] == 98)
 
1355
 
 
1356
 
 
1357
                    {
 
1358
                    
 
1359
                            static const unsigned short string[] =
 
1360
                            {
 
1361
                                108, 111, 99, 107, 68, 101, 102, 97, 117, 108, 116
 
1362
                            };
 
1363
                            if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0)
 
1364
                        
 
1365
 
 
1366
                return BlockDefault;
 
1367
            
 
1368
                    }
 
1369
 
 
1370
                else if (data[0] == 102)
 
1371
 
 
1372
 
 
1373
                    {
 
1374
                    
 
1375
                            static const unsigned short string[] =
 
1376
                            {
 
1377
                                105, 110, 97, 108, 68, 101, 102, 97, 117, 108, 116
 
1378
                            };
 
1379
                            if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0)
 
1380
                        
 
1381
 
 
1382
                return FinalDefault;
 
1383
            
 
1384
                    }
 
1385
 
 
1386
                else if (data[0] == 109)
 
1387
 
 
1388
 
 
1389
                    {
 
1390
                    if (data[1] == 97)
 
1391
 
 
1392
 
 
1393
                    {
 
1394
                    if (data[2] == 120)
 
1395
 
 
1396
 
 
1397
                    {
 
1398
                    if (data[3] == 69)
 
1399
 
 
1400
 
 
1401
                    {
 
1402
                    
 
1403
                            static const unsigned short string[] =
 
1404
                            {
 
1405
                                120, 99, 108, 117, 115, 105, 118, 101
 
1406
                            };
 
1407
                            if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0)
 
1408
                        
 
1409
 
 
1410
                return MaxExclusive;
 
1411
            
 
1412
                    }
 
1413
 
 
1414
                else if (data[3] == 73)
 
1415
 
 
1416
 
 
1417
                    {
 
1418
                    
 
1419
                            static const unsigned short string[] =
 
1420
                            {
 
1421
                                110, 99, 108, 117, 115, 105, 118, 101
 
1422
                            };
 
1423
                            if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0)
 
1424
                        
 
1425
 
 
1426
                return MaxInclusive;
 
1427
            
 
1428
                    }
 
1429
 
 
1430
                
 
1431
                    }
 
1432
 
 
1433
                
 
1434
                    }
 
1435
 
 
1436
                else if (data[1] == 105)
 
1437
 
 
1438
 
 
1439
                    {
 
1440
                    if (data[2] == 110)
 
1441
 
 
1442
 
 
1443
                    {
 
1444
                    if (data[3] == 69)
 
1445
 
 
1446
 
 
1447
                    {
 
1448
                    
 
1449
                            static const unsigned short string[] =
 
1450
                            {
 
1451
                                120, 99, 108, 117, 115, 105, 118, 101
 
1452
                            };
 
1453
                            if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0)
 
1454
                        
 
1455
 
 
1456
                return MinExclusive;
 
1457
            
 
1458
                    }
 
1459
 
 
1460
                else if (data[3] == 73)
 
1461
 
 
1462
 
 
1463
                    {
 
1464
                    
 
1465
                            static const unsigned short string[] =
 
1466
                            {
 
1467
                                110, 99, 108, 117, 115, 105, 118, 101
 
1468
                            };
 
1469
                            if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0)
 
1470
                        
 
1471
 
 
1472
                return MinInclusive;
 
1473
            
 
1474
                    }
 
1475
 
 
1476
                
 
1477
                    }
 
1478
 
 
1479
                
 
1480
                    }
 
1481
 
 
1482
                
 
1483
                    }
 
1484
 
 
1485
                else if (data[0] == 110)
 
1486
 
 
1487
 
 
1488
                    {
 
1489
                    
 
1490
                            static const unsigned short string[] =
 
1491
                            {
 
1492
                                111, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101
 
1493
                            };
 
1494
                            if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0)
 
1495
                        
 
1496
 
 
1497
                return NotNamespace;
 
1498
            
 
1499
                    }
 
1500
 
 
1501
                
 
1502
 
 
1503
            return NoKeyword;
 
1504
        }
 
1505
    XsdSchemaToken::NodeName XsdSchemaToken::classifier13(const QChar *data)
 
1506
 
 
1507
        {
 
1508
            if (data[0] == 100)
 
1509
 
 
1510
 
 
1511
                    {
 
1512
                    
 
1513
                            static const unsigned short string[] =
 
1514
                            {
 
1515
                                111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110
 
1516
                            };
 
1517
                            if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
 
1518
                        
 
1519
 
 
1520
                return Documentation;
 
1521
            
 
1522
                    }
 
1523
 
 
1524
                else if (data[0] == 115)
 
1525
 
 
1526
 
 
1527
                    {
 
1528
                    
 
1529
                            static const unsigned short string[] =
 
1530
                            {
 
1531
                                105, 109, 112, 108, 101, 67, 111, 110, 116, 101, 110, 116
 
1532
                            };
 
1533
                            if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
 
1534
                        
 
1535
 
 
1536
                return SimpleContent;
 
1537
            
 
1538
                    }
 
1539
 
 
1540
                
 
1541
 
 
1542
            return NoKeyword;
 
1543
        }
 
1544
    XsdSchemaToken::NodeName XsdSchemaToken::classifier14(const QChar *data)
 
1545
 
 
1546
        {
 
1547
            if (data[0] == 97)
 
1548
 
 
1549
 
 
1550
                    {
 
1551
                    if (data[1] == 112)
 
1552
 
 
1553
 
 
1554
                    {
 
1555
                    
 
1556
                            static const unsigned short string[] =
 
1557
                            {
 
1558
                                112, 108, 105, 101, 115, 84, 111, 69, 109, 112, 116, 121
 
1559
                            };
 
1560
                            if(memcmp(&data[2], &string, sizeof(QChar) * 12) == 0)
 
1561
                        
 
1562
 
 
1563
                return AppliesToEmpty;
 
1564
            
 
1565
                    }
 
1566
 
 
1567
                else if (data[1] == 116)
 
1568
 
 
1569
 
 
1570
                    {
 
1571
                    
 
1572
                            static const unsigned short string[] =
 
1573
                            {
 
1574
                                116, 114, 105, 98, 117, 116, 101, 71, 114, 111, 117, 112
 
1575
                            };
 
1576
                            if(memcmp(&data[2], &string, sizeof(QChar) * 12) == 0)
 
1577
                        
 
1578
 
 
1579
                return AttributeGroup;
 
1580
            
 
1581
                    }
 
1582
 
 
1583
                
 
1584
                    }
 
1585
 
 
1586
                else if (data[0] == 99)
 
1587
 
 
1588
 
 
1589
                    {
 
1590
                    
 
1591
                            static const unsigned short string[] =
 
1592
                            {
 
1593
                                111, 109, 112, 108, 101, 120, 67, 111, 110, 116, 101, 110, 116
 
1594
                            };
 
1595
                            if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
 
1596
                        
 
1597
 
 
1598
                return ComplexContent;
 
1599
            
 
1600
                    }
 
1601
 
 
1602
                else if (data[0] == 102)
 
1603
 
 
1604
 
 
1605
                    {
 
1606
                    
 
1607
                            static const unsigned short string[] =
 
1608
                            {
 
1609
                                114, 97, 99, 116, 105, 111, 110, 68, 105, 103, 105, 116, 115
 
1610
                            };
 
1611
                            if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
 
1612
                        
 
1613
 
 
1614
                return FractionDigits;
 
1615
            
 
1616
                    }
 
1617
 
 
1618
                else if (data[0] == 115)
 
1619
 
 
1620
 
 
1621
                    {
 
1622
                    
 
1623
                            static const unsigned short string[] =
 
1624
                            {
 
1625
                                99, 104, 101, 109, 97, 76, 111, 99, 97, 116, 105, 111, 110
 
1626
                            };
 
1627
                            if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
 
1628
                        
 
1629
 
 
1630
                return SchemaLocation;
 
1631
            
 
1632
                    }
 
1633
 
 
1634
                
 
1635
 
 
1636
            return NoKeyword;
 
1637
        }
 
1638
    XsdSchemaToken::NodeName XsdSchemaToken::classifier15(const QChar *data)
 
1639
 
 
1640
        {
 
1641
            if (data[0] == 112)
 
1642
 
 
1643
 
 
1644
                    {
 
1645
                    
 
1646
                            static const unsigned short string[] =
 
1647
                            {
 
1648
                                114, 111, 99, 101, 115, 115, 67, 111, 110, 116, 101, 110, 116, 115
 
1649
                            };
 
1650
                            if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
 
1651
                        
 
1652
 
 
1653
                return ProcessContents;
 
1654
            
 
1655
                    }
 
1656
 
 
1657
                else if (data[0] == 116)
 
1658
 
 
1659
 
 
1660
                    {
 
1661
                    
 
1662
                            static const unsigned short string[] =
 
1663
                            {
 
1664
                                97, 114, 103, 101, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101
 
1665
                            };
 
1666
                            if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
 
1667
                        
 
1668
 
 
1669
                return TargetNamespace;
 
1670
            
 
1671
                    }
 
1672
 
 
1673
                
 
1674
 
 
1675
            return NoKeyword;
 
1676
        }
 
1677
    XsdSchemaToken::NodeName XsdSchemaToken::classifier17(const QChar *data)
 
1678
 
 
1679
        {
 
1680
            if (data[0] == 100)
 
1681
 
 
1682
 
 
1683
                    {
 
1684
                    
 
1685
                            static const unsigned short string[] =
 
1686
                            {
 
1687
                                101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115
 
1688
                            };
 
1689
                            if(memcmp(&data[1], &string, sizeof(QChar) * 16) == 0)
 
1690
                        
 
1691
 
 
1692
                return DefaultAttributes;
 
1693
            
 
1694
                    }
 
1695
 
 
1696
                else if (data[0] == 115)
 
1697
 
 
1698
 
 
1699
                    {
 
1700
                    
 
1701
                            static const unsigned short string[] =
 
1702
                            {
 
1703
                                117, 98, 115, 116, 105, 116, 117, 116, 105, 111, 110, 71, 114, 111, 117, 112
 
1704
                            };
 
1705
                            if(memcmp(&data[1], &string, sizeof(QChar) * 16) == 0)
 
1706
                        
 
1707
 
 
1708
                return SubstitutionGroup;
 
1709
            
 
1710
                    }
 
1711
 
 
1712
                
 
1713
 
 
1714
            return NoKeyword;
 
1715
        }
 
1716
    XsdSchemaToken::NodeName XsdSchemaToken::classifier18(const QChar *data)
 
1717
 
 
1718
        {
 
1719
            if (data[0] == 100)
 
1720
 
 
1721
 
 
1722
                    {
 
1723
                    
 
1724
                            static const unsigned short string[] =
 
1725
                            {
 
1726
                                101, 102, 97, 117, 108, 116, 79, 112, 101, 110, 67, 111, 110, 116, 101, 110, 116
 
1727
                            };
 
1728
                            if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
 
1729
                        
 
1730
 
 
1731
                return DefaultOpenContent;
 
1732
            
 
1733
                    }
 
1734
 
 
1735
                else if (data[0] == 101)
 
1736
 
 
1737
 
 
1738
                    {
 
1739
                    
 
1740
                            static const unsigned short string[] =
 
1741
                            {
 
1742
                                108, 101, 109, 101, 110, 116, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116
 
1743
                            };
 
1744
                            if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
 
1745
                        
 
1746
 
 
1747
                return ElementFormDefault;
 
1748
            
 
1749
                    }
 
1750
 
 
1751
                
 
1752
 
 
1753
            return NoKeyword;
 
1754
        }
 
1755
    XsdSchemaToken::NodeName XsdSchemaToken::classifier20(const QChar *data)
 
1756
 
 
1757
        {
 
1758
            
 
1759
                            static const unsigned short string[] =
 
1760
                            {
 
1761
                                97, 116, 116, 114, 105, 98, 117, 116, 101, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116
 
1762
                            };
 
1763
                            if(memcmp(&data[0], &string, sizeof(QChar) * 20) == 0)
 
1764
                        
 
1765
 
 
1766
                return AttributeFormDefault;
 
1767
            
 
1768
 
 
1769
            return NoKeyword;
 
1770
        }
 
1771
    XsdSchemaToken::NodeName XsdSchemaToken::classifier21(const QChar *data)
 
1772
 
 
1773
        {
 
1774
            
 
1775
                            static const unsigned short string[] =
 
1776
                            {
 
1777
                                120, 112, 97, 116, 104, 68, 101, 102, 97, 117, 108, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101
 
1778
                            };
 
1779
                            if(memcmp(&data[0], &string, sizeof(QChar) * 21) == 0)
 
1780
                        
 
1781
 
 
1782
                return XPathDefaultNamespace;
 
1783
            
 
1784
 
 
1785
            return NoKeyword;
 
1786
        }
 
1787
    XsdSchemaToken::NodeName XsdSchemaToken::classifier22(const QChar *data)
 
1788
 
 
1789
        {
 
1790
            
 
1791
                            static const unsigned short string[] =
 
1792
                            {
 
1793
                                100, 101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 65, 112, 112, 108, 121
 
1794
                            };
 
1795
                            if(memcmp(&data[0], &string, sizeof(QChar) * 22) == 0)
 
1796
                        
 
1797
 
 
1798
                return DefaultAttributesApply;
 
1799
            
 
1800
 
 
1801
            return NoKeyword;
 
1802
        }
 
1803
    XsdSchemaToken::NodeName XsdSchemaToken::classifier32(const QChar *data)
 
1804
 
 
1805
        {
 
1806
            
 
1807
                            static const unsigned short string[] =
 
1808
                            {
 
1809
                                104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 119, 51, 46, 111, 114, 103, 47, 50, 48, 48, 49, 47, 88, 77, 76, 83, 99, 104, 101, 109, 97
 
1810
                            };
 
1811
                            if(memcmp(&data[0], &string, sizeof(QChar) * 32) == 0)
 
1812
                        
 
1813
 
 
1814
                return XML_NS_SCHEMA_URI;
 
1815
            
 
1816
 
 
1817
            return NoKeyword;
 
1818
        }
 
1819
    XsdSchemaToken::NodeName XsdSchemaToken::toToken(const QChar *data, int length)
 
1820
            {
 
1821
                switch(length)
 
1822
                {
 
1823
                    
 
1824
                        case 2:
 
1825
                            return classifier2(data);
 
1826
 
 
1827
                    
 
1828
                        case 3:
 
1829
                            return classifier3(data);
 
1830
 
 
1831
                    
 
1832
                        case 4:
 
1833
                            return classifier4(data);
 
1834
 
 
1835
                    
 
1836
                        case 5:
 
1837
                            return classifier5(data);
 
1838
 
 
1839
                    
 
1840
                        case 6:
 
1841
                            return classifier6(data);
 
1842
 
 
1843
                    
 
1844
                        case 7:
 
1845
                            return classifier7(data);
 
1846
 
 
1847
                    
 
1848
                        case 8:
 
1849
                            return classifier8(data);
 
1850
 
 
1851
                    
 
1852
                        case 9:
 
1853
                            return classifier9(data);
 
1854
 
 
1855
                    
 
1856
                        case 10:
 
1857
                            return classifier10(data);
 
1858
 
 
1859
                    
 
1860
                        case 11:
 
1861
                            return classifier11(data);
 
1862
 
 
1863
                    
 
1864
                        case 12:
 
1865
                            return classifier12(data);
 
1866
 
 
1867
                    
 
1868
                        case 13:
 
1869
                            return classifier13(data);
 
1870
 
 
1871
                    
 
1872
                        case 14:
 
1873
                            return classifier14(data);
 
1874
 
 
1875
                    
 
1876
                        case 15:
 
1877
                            return classifier15(data);
 
1878
 
 
1879
                    
 
1880
                        case 17:
 
1881
                            return classifier17(data);
 
1882
 
 
1883
                    
 
1884
                        case 18:
 
1885
                            return classifier18(data);
 
1886
 
 
1887
                    
 
1888
                        case 20:
 
1889
                            return classifier20(data);
 
1890
 
 
1891
                    
 
1892
                        case 21:
 
1893
                            return classifier21(data);
 
1894
 
 
1895
                    
 
1896
                        case 22:
 
1897
                            return classifier22(data);
 
1898
 
 
1899
                    
 
1900
                        case 32:
 
1901
                            return classifier32(data);
 
1902
 
 
1903
                    
 
1904
                        default:
 
1905
                            return NoKeyword;
 
1906
                }
 
1907
            }
 
1908
 
 
1909
            
 
1910
                QString XsdSchemaToken::toString(NodeName token)
 
1911
                {
 
1912
                    const unsigned short *data = 0;
 
1913
                    int length = 0;
 
1914
 
 
1915
                    switch(token)
 
1916
                    {
 
1917
                    
 
1918
                        case Abstract:
 
1919
                        {
 
1920
                            static const unsigned short staticallyStoredAbstract[] =
 
1921
                            {
 
1922
                            97, 98, 115, 116, 114, 97, 99, 116, 0
 
1923
                            };
 
1924
                            data = staticallyStoredAbstract;
 
1925
                            length = 8;
 
1926
                            break;
 
1927
                        }
 
1928
                    
 
1929
                        case All:
 
1930
                        {
 
1931
                            static const unsigned short staticallyStoredAll[] =
 
1932
                            {
 
1933
                            97, 108, 108, 0
 
1934
                            };
 
1935
                            data = staticallyStoredAll;
 
1936
                            length = 3;
 
1937
                            break;
 
1938
                        }
 
1939
                    
 
1940
                        case Alternative:
 
1941
                        {
 
1942
                            static const unsigned short staticallyStoredAlternative[] =
 
1943
                            {
 
1944
                            97, 108, 116, 101, 114, 110, 97, 116, 105, 118, 101, 0
 
1945
                            };
 
1946
                            data = staticallyStoredAlternative;
 
1947
                            length = 11;
 
1948
                            break;
 
1949
                        }
 
1950
                    
 
1951
                        case Annotation:
 
1952
                        {
 
1953
                            static const unsigned short staticallyStoredAnnotation[] =
 
1954
                            {
 
1955
                            97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 0
 
1956
                            };
 
1957
                            data = staticallyStoredAnnotation;
 
1958
                            length = 10;
 
1959
                            break;
 
1960
                        }
 
1961
                    
 
1962
                        case Any:
 
1963
                        {
 
1964
                            static const unsigned short staticallyStoredAny[] =
 
1965
                            {
 
1966
                            97, 110, 121, 0
 
1967
                            };
 
1968
                            data = staticallyStoredAny;
 
1969
                            length = 3;
 
1970
                            break;
 
1971
                        }
 
1972
                    
 
1973
                        case AnyAttribute:
 
1974
                        {
 
1975
                            static const unsigned short staticallyStoredAnyAttribute[] =
 
1976
                            {
 
1977
                            97, 110, 121, 65, 116, 116, 114, 105, 98, 117, 116, 101, 0
 
1978
                            };
 
1979
                            data = staticallyStoredAnyAttribute;
 
1980
                            length = 12;
 
1981
                            break;
 
1982
                        }
 
1983
                    
 
1984
                        case Appinfo:
 
1985
                        {
 
1986
                            static const unsigned short staticallyStoredAppinfo[] =
 
1987
                            {
 
1988
                            97, 112, 112, 105, 110, 102, 111, 0
 
1989
                            };
 
1990
                            data = staticallyStoredAppinfo;
 
1991
                            length = 7;
 
1992
                            break;
 
1993
                        }
 
1994
                    
 
1995
                        case AppliesToEmpty:
 
1996
                        {
 
1997
                            static const unsigned short staticallyStoredAppliesToEmpty[] =
 
1998
                            {
 
1999
                            97, 112, 112, 108, 105, 101, 115, 84, 111, 69, 109, 112, 116, 121, 0
 
2000
                            };
 
2001
                            data = staticallyStoredAppliesToEmpty;
 
2002
                            length = 14;
 
2003
                            break;
 
2004
                        }
 
2005
                    
 
2006
                        case Assert:
 
2007
                        {
 
2008
                            static const unsigned short staticallyStoredAssert[] =
 
2009
                            {
 
2010
                            97, 115, 115, 101, 114, 116, 0
 
2011
                            };
 
2012
                            data = staticallyStoredAssert;
 
2013
                            length = 6;
 
2014
                            break;
 
2015
                        }
 
2016
                    
 
2017
                        case Assertion:
 
2018
                        {
 
2019
                            static const unsigned short staticallyStoredAssertion[] =
 
2020
                            {
 
2021
                            97, 115, 115, 101, 114, 116, 105, 111, 110, 0
 
2022
                            };
 
2023
                            data = staticallyStoredAssertion;
 
2024
                            length = 9;
 
2025
                            break;
 
2026
                        }
 
2027
                    
 
2028
                        case Attribute:
 
2029
                        {
 
2030
                            static const unsigned short staticallyStoredAttribute[] =
 
2031
                            {
 
2032
                            97, 116, 116, 114, 105, 98, 117, 116, 101, 0
 
2033
                            };
 
2034
                            data = staticallyStoredAttribute;
 
2035
                            length = 9;
 
2036
                            break;
 
2037
                        }
 
2038
                    
 
2039
                        case AttributeFormDefault:
 
2040
                        {
 
2041
                            static const unsigned short staticallyStoredAttributeFormDefault[] =
 
2042
                            {
 
2043
                            97, 116, 116, 114, 105, 98, 117, 116, 101, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116, 0
 
2044
                            };
 
2045
                            data = staticallyStoredAttributeFormDefault;
 
2046
                            length = 20;
 
2047
                            break;
 
2048
                        }
 
2049
                    
 
2050
                        case AttributeGroup:
 
2051
                        {
 
2052
                            static const unsigned short staticallyStoredAttributeGroup[] =
 
2053
                            {
 
2054
                            97, 116, 116, 114, 105, 98, 117, 116, 101, 71, 114, 111, 117, 112, 0
 
2055
                            };
 
2056
                            data = staticallyStoredAttributeGroup;
 
2057
                            length = 14;
 
2058
                            break;
 
2059
                        }
 
2060
                    
 
2061
                        case Base:
 
2062
                        {
 
2063
                            static const unsigned short staticallyStoredBase[] =
 
2064
                            {
 
2065
                            98, 97, 115, 101, 0
 
2066
                            };
 
2067
                            data = staticallyStoredBase;
 
2068
                            length = 4;
 
2069
                            break;
 
2070
                        }
 
2071
                    
 
2072
                        case Block:
 
2073
                        {
 
2074
                            static const unsigned short staticallyStoredBlock[] =
 
2075
                            {
 
2076
                            98, 108, 111, 99, 107, 0
 
2077
                            };
 
2078
                            data = staticallyStoredBlock;
 
2079
                            length = 5;
 
2080
                            break;
 
2081
                        }
 
2082
                    
 
2083
                        case BlockDefault:
 
2084
                        {
 
2085
                            static const unsigned short staticallyStoredBlockDefault[] =
 
2086
                            {
 
2087
                            98, 108, 111, 99, 107, 68, 101, 102, 97, 117, 108, 116, 0
 
2088
                            };
 
2089
                            data = staticallyStoredBlockDefault;
 
2090
                            length = 12;
 
2091
                            break;
 
2092
                        }
 
2093
                    
 
2094
                        case Choice:
 
2095
                        {
 
2096
                            static const unsigned short staticallyStoredChoice[] =
 
2097
                            {
 
2098
                            99, 104, 111, 105, 99, 101, 0
 
2099
                            };
 
2100
                            data = staticallyStoredChoice;
 
2101
                            length = 6;
 
2102
                            break;
 
2103
                        }
 
2104
                    
 
2105
                        case Collapse:
 
2106
                        {
 
2107
                            static const unsigned short staticallyStoredCollapse[] =
 
2108
                            {
 
2109
                            99, 111, 108, 108, 97, 112, 115, 101, 0
 
2110
                            };
 
2111
                            data = staticallyStoredCollapse;
 
2112
                            length = 8;
 
2113
                            break;
 
2114
                        }
 
2115
                    
 
2116
                        case ComplexContent:
 
2117
                        {
 
2118
                            static const unsigned short staticallyStoredComplexContent[] =
 
2119
                            {
 
2120
                            99, 111, 109, 112, 108, 101, 120, 67, 111, 110, 116, 101, 110, 116, 0
 
2121
                            };
 
2122
                            data = staticallyStoredComplexContent;
 
2123
                            length = 14;
 
2124
                            break;
 
2125
                        }
 
2126
                    
 
2127
                        case ComplexType:
 
2128
                        {
 
2129
                            static const unsigned short staticallyStoredComplexType[] =
 
2130
                            {
 
2131
                            99, 111, 109, 112, 108, 101, 120, 84, 121, 112, 101, 0
 
2132
                            };
 
2133
                            data = staticallyStoredComplexType;
 
2134
                            length = 11;
 
2135
                            break;
 
2136
                        }
 
2137
                    
 
2138
                        case Default:
 
2139
                        {
 
2140
                            static const unsigned short staticallyStoredDefault[] =
 
2141
                            {
 
2142
                            100, 101, 102, 97, 117, 108, 116, 0
 
2143
                            };
 
2144
                            data = staticallyStoredDefault;
 
2145
                            length = 7;
 
2146
                            break;
 
2147
                        }
 
2148
                    
 
2149
                        case DefaultAttributes:
 
2150
                        {
 
2151
                            static const unsigned short staticallyStoredDefaultAttributes[] =
 
2152
                            {
 
2153
                            100, 101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 0
 
2154
                            };
 
2155
                            data = staticallyStoredDefaultAttributes;
 
2156
                            length = 17;
 
2157
                            break;
 
2158
                        }
 
2159
                    
 
2160
                        case DefaultAttributesApply:
 
2161
                        {
 
2162
                            static const unsigned short staticallyStoredDefaultAttributesApply[] =
 
2163
                            {
 
2164
                            100, 101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 65, 112, 112, 108, 121, 0
 
2165
                            };
 
2166
                            data = staticallyStoredDefaultAttributesApply;
 
2167
                            length = 22;
 
2168
                            break;
 
2169
                        }
 
2170
                    
 
2171
                        case DefaultOpenContent:
 
2172
                        {
 
2173
                            static const unsigned short staticallyStoredDefaultOpenContent[] =
 
2174
                            {
 
2175
                            100, 101, 102, 97, 117, 108, 116, 79, 112, 101, 110, 67, 111, 110, 116, 101, 110, 116, 0
 
2176
                            };
 
2177
                            data = staticallyStoredDefaultOpenContent;
 
2178
                            length = 18;
 
2179
                            break;
 
2180
                        }
 
2181
                    
 
2182
                        case Documentation:
 
2183
                        {
 
2184
                            static const unsigned short staticallyStoredDocumentation[] =
 
2185
                            {
 
2186
                            100, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 0
 
2187
                            };
 
2188
                            data = staticallyStoredDocumentation;
 
2189
                            length = 13;
 
2190
                            break;
 
2191
                        }
 
2192
                    
 
2193
                        case Element:
 
2194
                        {
 
2195
                            static const unsigned short staticallyStoredElement[] =
 
2196
                            {
 
2197
                            101, 108, 101, 109, 101, 110, 116, 0
 
2198
                            };
 
2199
                            data = staticallyStoredElement;
 
2200
                            length = 7;
 
2201
                            break;
 
2202
                        }
 
2203
                    
 
2204
                        case ElementFormDefault:
 
2205
                        {
 
2206
                            static const unsigned short staticallyStoredElementFormDefault[] =
 
2207
                            {
 
2208
                            101, 108, 101, 109, 101, 110, 116, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116, 0
 
2209
                            };
 
2210
                            data = staticallyStoredElementFormDefault;
 
2211
                            length = 18;
 
2212
                            break;
 
2213
                        }
 
2214
                    
 
2215
                        case Enumeration:
 
2216
                        {
 
2217
                            static const unsigned short staticallyStoredEnumeration[] =
 
2218
                            {
 
2219
                            101, 110, 117, 109, 101, 114, 97, 116, 105, 111, 110, 0
 
2220
                            };
 
2221
                            data = staticallyStoredEnumeration;
 
2222
                            length = 11;
 
2223
                            break;
 
2224
                        }
 
2225
                    
 
2226
                        case Extension:
 
2227
                        {
 
2228
                            static const unsigned short staticallyStoredExtension[] =
 
2229
                            {
 
2230
                            101, 120, 116, 101, 110, 115, 105, 111, 110, 0
 
2231
                            };
 
2232
                            data = staticallyStoredExtension;
 
2233
                            length = 9;
 
2234
                            break;
 
2235
                        }
 
2236
                    
 
2237
                        case Field:
 
2238
                        {
 
2239
                            static const unsigned short staticallyStoredField[] =
 
2240
                            {
 
2241
                            102, 105, 101, 108, 100, 0
 
2242
                            };
 
2243
                            data = staticallyStoredField;
 
2244
                            length = 5;
 
2245
                            break;
 
2246
                        }
 
2247
                    
 
2248
                        case Final:
 
2249
                        {
 
2250
                            static const unsigned short staticallyStoredFinal[] =
 
2251
                            {
 
2252
                            102, 105, 110, 97, 108, 0
 
2253
                            };
 
2254
                            data = staticallyStoredFinal;
 
2255
                            length = 5;
 
2256
                            break;
 
2257
                        }
 
2258
                    
 
2259
                        case FinalDefault:
 
2260
                        {
 
2261
                            static const unsigned short staticallyStoredFinalDefault[] =
 
2262
                            {
 
2263
                            102, 105, 110, 97, 108, 68, 101, 102, 97, 117, 108, 116, 0
 
2264
                            };
 
2265
                            data = staticallyStoredFinalDefault;
 
2266
                            length = 12;
 
2267
                            break;
 
2268
                        }
 
2269
                    
 
2270
                        case Fixed:
 
2271
                        {
 
2272
                            static const unsigned short staticallyStoredFixed[] =
 
2273
                            {
 
2274
                            102, 105, 120, 101, 100, 0
 
2275
                            };
 
2276
                            data = staticallyStoredFixed;
 
2277
                            length = 5;
 
2278
                            break;
 
2279
                        }
 
2280
                    
 
2281
                        case Form:
 
2282
                        {
 
2283
                            static const unsigned short staticallyStoredForm[] =
 
2284
                            {
 
2285
                            102, 111, 114, 109, 0
 
2286
                            };
 
2287
                            data = staticallyStoredForm;
 
2288
                            length = 4;
 
2289
                            break;
 
2290
                        }
 
2291
                    
 
2292
                        case FractionDigits:
 
2293
                        {
 
2294
                            static const unsigned short staticallyStoredFractionDigits[] =
 
2295
                            {
 
2296
                            102, 114, 97, 99, 116, 105, 111, 110, 68, 105, 103, 105, 116, 115, 0
 
2297
                            };
 
2298
                            data = staticallyStoredFractionDigits;
 
2299
                            length = 14;
 
2300
                            break;
 
2301
                        }
 
2302
                    
 
2303
                        case Group:
 
2304
                        {
 
2305
                            static const unsigned short staticallyStoredGroup[] =
 
2306
                            {
 
2307
                            103, 114, 111, 117, 112, 0
 
2308
                            };
 
2309
                            data = staticallyStoredGroup;
 
2310
                            length = 5;
 
2311
                            break;
 
2312
                        }
 
2313
                    
 
2314
                        case Id:
 
2315
                        {
 
2316
                            static const unsigned short staticallyStoredId[] =
 
2317
                            {
 
2318
                            105, 100, 0
 
2319
                            };
 
2320
                            data = staticallyStoredId;
 
2321
                            length = 2;
 
2322
                            break;
 
2323
                        }
 
2324
                    
 
2325
                        case Import:
 
2326
                        {
 
2327
                            static const unsigned short staticallyStoredImport[] =
 
2328
                            {
 
2329
                            105, 109, 112, 111, 114, 116, 0
 
2330
                            };
 
2331
                            data = staticallyStoredImport;
 
2332
                            length = 6;
 
2333
                            break;
 
2334
                        }
 
2335
                    
 
2336
                        case Include:
 
2337
                        {
 
2338
                            static const unsigned short staticallyStoredInclude[] =
 
2339
                            {
 
2340
                            105, 110, 99, 108, 117, 100, 101, 0
 
2341
                            };
 
2342
                            data = staticallyStoredInclude;
 
2343
                            length = 7;
 
2344
                            break;
 
2345
                        }
 
2346
                    
 
2347
                        case ItemType:
 
2348
                        {
 
2349
                            static const unsigned short staticallyStoredItemType[] =
 
2350
                            {
 
2351
                            105, 116, 101, 109, 84, 121, 112, 101, 0
 
2352
                            };
 
2353
                            data = staticallyStoredItemType;
 
2354
                            length = 8;
 
2355
                            break;
 
2356
                        }
 
2357
                    
 
2358
                        case Key:
 
2359
                        {
 
2360
                            static const unsigned short staticallyStoredKey[] =
 
2361
                            {
 
2362
                            107, 101, 121, 0
 
2363
                            };
 
2364
                            data = staticallyStoredKey;
 
2365
                            length = 3;
 
2366
                            break;
 
2367
                        }
 
2368
                    
 
2369
                        case Keyref:
 
2370
                        {
 
2371
                            static const unsigned short staticallyStoredKeyref[] =
 
2372
                            {
 
2373
                            107, 101, 121, 114, 101, 102, 0
 
2374
                            };
 
2375
                            data = staticallyStoredKeyref;
 
2376
                            length = 6;
 
2377
                            break;
 
2378
                        }
 
2379
                    
 
2380
                        case Length:
 
2381
                        {
 
2382
                            static const unsigned short staticallyStoredLength[] =
 
2383
                            {
 
2384
                            108, 101, 110, 103, 116, 104, 0
 
2385
                            };
 
2386
                            data = staticallyStoredLength;
 
2387
                            length = 6;
 
2388
                            break;
 
2389
                        }
 
2390
                    
 
2391
                        case List:
 
2392
                        {
 
2393
                            static const unsigned short staticallyStoredList[] =
 
2394
                            {
 
2395
                            108, 105, 115, 116, 0
 
2396
                            };
 
2397
                            data = staticallyStoredList;
 
2398
                            length = 4;
 
2399
                            break;
 
2400
                        }
 
2401
                    
 
2402
                        case MaxExclusive:
 
2403
                        {
 
2404
                            static const unsigned short staticallyStoredMaxExclusive[] =
 
2405
                            {
 
2406
                            109, 97, 120, 69, 120, 99, 108, 117, 115, 105, 118, 101, 0
 
2407
                            };
 
2408
                            data = staticallyStoredMaxExclusive;
 
2409
                            length = 12;
 
2410
                            break;
 
2411
                        }
 
2412
                    
 
2413
                        case MaxInclusive:
 
2414
                        {
 
2415
                            static const unsigned short staticallyStoredMaxInclusive[] =
 
2416
                            {
 
2417
                            109, 97, 120, 73, 110, 99, 108, 117, 115, 105, 118, 101, 0
 
2418
                            };
 
2419
                            data = staticallyStoredMaxInclusive;
 
2420
                            length = 12;
 
2421
                            break;
 
2422
                        }
 
2423
                    
 
2424
                        case MaxLength:
 
2425
                        {
 
2426
                            static const unsigned short staticallyStoredMaxLength[] =
 
2427
                            {
 
2428
                            109, 97, 120, 76, 101, 110, 103, 116, 104, 0
 
2429
                            };
 
2430
                            data = staticallyStoredMaxLength;
 
2431
                            length = 9;
 
2432
                            break;
 
2433
                        }
 
2434
                    
 
2435
                        case MaxOccurs:
 
2436
                        {
 
2437
                            static const unsigned short staticallyStoredMaxOccurs[] =
 
2438
                            {
 
2439
                            109, 97, 120, 79, 99, 99, 117, 114, 115, 0
 
2440
                            };
 
2441
                            data = staticallyStoredMaxOccurs;
 
2442
                            length = 9;
 
2443
                            break;
 
2444
                        }
 
2445
                    
 
2446
                        case MemberTypes:
 
2447
                        {
 
2448
                            static const unsigned short staticallyStoredMemberTypes[] =
 
2449
                            {
 
2450
                            109, 101, 109, 98, 101, 114, 84, 121, 112, 101, 115, 0
 
2451
                            };
 
2452
                            data = staticallyStoredMemberTypes;
 
2453
                            length = 11;
 
2454
                            break;
 
2455
                        }
 
2456
                    
 
2457
                        case MinExclusive:
 
2458
                        {
 
2459
                            static const unsigned short staticallyStoredMinExclusive[] =
 
2460
                            {
 
2461
                            109, 105, 110, 69, 120, 99, 108, 117, 115, 105, 118, 101, 0
 
2462
                            };
 
2463
                            data = staticallyStoredMinExclusive;
 
2464
                            length = 12;
 
2465
                            break;
 
2466
                        }
 
2467
                    
 
2468
                        case MinInclusive:
 
2469
                        {
 
2470
                            static const unsigned short staticallyStoredMinInclusive[] =
 
2471
                            {
 
2472
                            109, 105, 110, 73, 110, 99, 108, 117, 115, 105, 118, 101, 0
 
2473
                            };
 
2474
                            data = staticallyStoredMinInclusive;
 
2475
                            length = 12;
 
2476
                            break;
 
2477
                        }
 
2478
                    
 
2479
                        case MinLength:
 
2480
                        {
 
2481
                            static const unsigned short staticallyStoredMinLength[] =
 
2482
                            {
 
2483
                            109, 105, 110, 76, 101, 110, 103, 116, 104, 0
 
2484
                            };
 
2485
                            data = staticallyStoredMinLength;
 
2486
                            length = 9;
 
2487
                            break;
 
2488
                        }
 
2489
                    
 
2490
                        case MinOccurs:
 
2491
                        {
 
2492
                            static const unsigned short staticallyStoredMinOccurs[] =
 
2493
                            {
 
2494
                            109, 105, 110, 79, 99, 99, 117, 114, 115, 0
 
2495
                            };
 
2496
                            data = staticallyStoredMinOccurs;
 
2497
                            length = 9;
 
2498
                            break;
 
2499
                        }
 
2500
                    
 
2501
                        case Mixed:
 
2502
                        {
 
2503
                            static const unsigned short staticallyStoredMixed[] =
 
2504
                            {
 
2505
                            109, 105, 120, 101, 100, 0
 
2506
                            };
 
2507
                            data = staticallyStoredMixed;
 
2508
                            length = 5;
 
2509
                            break;
 
2510
                        }
 
2511
                    
 
2512
                        case Mode:
 
2513
                        {
 
2514
                            static const unsigned short staticallyStoredMode[] =
 
2515
                            {
 
2516
                            109, 111, 100, 101, 0
 
2517
                            };
 
2518
                            data = staticallyStoredMode;
 
2519
                            length = 4;
 
2520
                            break;
 
2521
                        }
 
2522
                    
 
2523
                        case Name:
 
2524
                        {
 
2525
                            static const unsigned short staticallyStoredName[] =
 
2526
                            {
 
2527
                            110, 97, 109, 101, 0
 
2528
                            };
 
2529
                            data = staticallyStoredName;
 
2530
                            length = 4;
 
2531
                            break;
 
2532
                        }
 
2533
                    
 
2534
                        case Namespace:
 
2535
                        {
 
2536
                            static const unsigned short staticallyStoredNamespace[] =
 
2537
                            {
 
2538
                            110, 97, 109, 101, 115, 112, 97, 99, 101, 0
 
2539
                            };
 
2540
                            data = staticallyStoredNamespace;
 
2541
                            length = 9;
 
2542
                            break;
 
2543
                        }
 
2544
                    
 
2545
                        case Nillable:
 
2546
                        {
 
2547
                            static const unsigned short staticallyStoredNillable[] =
 
2548
                            {
 
2549
                            110, 105, 108, 108, 97, 98, 108, 101, 0
 
2550
                            };
 
2551
                            data = staticallyStoredNillable;
 
2552
                            length = 8;
 
2553
                            break;
 
2554
                        }
 
2555
                    
 
2556
                        case NotNamespace:
 
2557
                        {
 
2558
                            static const unsigned short staticallyStoredNotNamespace[] =
 
2559
                            {
 
2560
                            110, 111, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101, 0
 
2561
                            };
 
2562
                            data = staticallyStoredNotNamespace;
 
2563
                            length = 12;
 
2564
                            break;
 
2565
                        }
 
2566
                    
 
2567
                        case NotQName:
 
2568
                        {
 
2569
                            static const unsigned short staticallyStoredNotQName[] =
 
2570
                            {
 
2571
                            110, 111, 116, 81, 78, 97, 109, 101, 0
 
2572
                            };
 
2573
                            data = staticallyStoredNotQName;
 
2574
                            length = 8;
 
2575
                            break;
 
2576
                        }
 
2577
                    
 
2578
                        case Notation:
 
2579
                        {
 
2580
                            static const unsigned short staticallyStoredNotation[] =
 
2581
                            {
 
2582
                            110, 111, 116, 97, 116, 105, 111, 110, 0
 
2583
                            };
 
2584
                            data = staticallyStoredNotation;
 
2585
                            length = 8;
 
2586
                            break;
 
2587
                        }
 
2588
                    
 
2589
                        case OpenContent:
 
2590
                        {
 
2591
                            static const unsigned short staticallyStoredOpenContent[] =
 
2592
                            {
 
2593
                            111, 112, 101, 110, 67, 111, 110, 116, 101, 110, 116, 0
 
2594
                            };
 
2595
                            data = staticallyStoredOpenContent;
 
2596
                            length = 11;
 
2597
                            break;
 
2598
                        }
 
2599
                    
 
2600
                        case Override:
 
2601
                        {
 
2602
                            static const unsigned short staticallyStoredOverride[] =
 
2603
                            {
 
2604
                            111, 118, 101, 114, 114, 105, 100, 101, 0
 
2605
                            };
 
2606
                            data = staticallyStoredOverride;
 
2607
                            length = 8;
 
2608
                            break;
 
2609
                        }
 
2610
                    
 
2611
                        case Pattern:
 
2612
                        {
 
2613
                            static const unsigned short staticallyStoredPattern[] =
 
2614
                            {
 
2615
                            112, 97, 116, 116, 101, 114, 110, 0
 
2616
                            };
 
2617
                            data = staticallyStoredPattern;
 
2618
                            length = 7;
 
2619
                            break;
 
2620
                        }
 
2621
                    
 
2622
                        case Preserve:
 
2623
                        {
 
2624
                            static const unsigned short staticallyStoredPreserve[] =
 
2625
                            {
 
2626
                            112, 114, 101, 115, 101, 114, 118, 101, 0
 
2627
                            };
 
2628
                            data = staticallyStoredPreserve;
 
2629
                            length = 8;
 
2630
                            break;
 
2631
                        }
 
2632
                    
 
2633
                        case ProcessContents:
 
2634
                        {
 
2635
                            static const unsigned short staticallyStoredProcessContents[] =
 
2636
                            {
 
2637
                            112, 114, 111, 99, 101, 115, 115, 67, 111, 110, 116, 101, 110, 116, 115, 0
 
2638
                            };
 
2639
                            data = staticallyStoredProcessContents;
 
2640
                            length = 15;
 
2641
                            break;
 
2642
                        }
 
2643
                    
 
2644
                        case Public:
 
2645
                        {
 
2646
                            static const unsigned short staticallyStoredPublic[] =
 
2647
                            {
 
2648
                            112, 117, 98, 108, 105, 99, 0
 
2649
                            };
 
2650
                            data = staticallyStoredPublic;
 
2651
                            length = 6;
 
2652
                            break;
 
2653
                        }
 
2654
                    
 
2655
                        case Redefine:
 
2656
                        {
 
2657
                            static const unsigned short staticallyStoredRedefine[] =
 
2658
                            {
 
2659
                            114, 101, 100, 101, 102, 105, 110, 101, 0
 
2660
                            };
 
2661
                            data = staticallyStoredRedefine;
 
2662
                            length = 8;
 
2663
                            break;
 
2664
                        }
 
2665
                    
 
2666
                        case Ref:
 
2667
                        {
 
2668
                            static const unsigned short staticallyStoredRef[] =
 
2669
                            {
 
2670
                            114, 101, 102, 0
 
2671
                            };
 
2672
                            data = staticallyStoredRef;
 
2673
                            length = 3;
 
2674
                            break;
 
2675
                        }
 
2676
                    
 
2677
                        case Refer:
 
2678
                        {
 
2679
                            static const unsigned short staticallyStoredRefer[] =
 
2680
                            {
 
2681
                            114, 101, 102, 101, 114, 0
 
2682
                            };
 
2683
                            data = staticallyStoredRefer;
 
2684
                            length = 5;
 
2685
                            break;
 
2686
                        }
 
2687
                    
 
2688
                        case Replace:
 
2689
                        {
 
2690
                            static const unsigned short staticallyStoredReplace[] =
 
2691
                            {
 
2692
                            114, 101, 112, 108, 97, 99, 101, 0
 
2693
                            };
 
2694
                            data = staticallyStoredReplace;
 
2695
                            length = 7;
 
2696
                            break;
 
2697
                        }
 
2698
                    
 
2699
                        case Restriction:
 
2700
                        {
 
2701
                            static const unsigned short staticallyStoredRestriction[] =
 
2702
                            {
 
2703
                            114, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 0
 
2704
                            };
 
2705
                            data = staticallyStoredRestriction;
 
2706
                            length = 11;
 
2707
                            break;
 
2708
                        }
 
2709
                    
 
2710
                        case Schema:
 
2711
                        {
 
2712
                            static const unsigned short staticallyStoredSchema[] =
 
2713
                            {
 
2714
                            115, 99, 104, 101, 109, 97, 0
 
2715
                            };
 
2716
                            data = staticallyStoredSchema;
 
2717
                            length = 6;
 
2718
                            break;
 
2719
                        }
 
2720
                    
 
2721
                        case SchemaLocation:
 
2722
                        {
 
2723
                            static const unsigned short staticallyStoredSchemaLocation[] =
 
2724
                            {
 
2725
                            115, 99, 104, 101, 109, 97, 76, 111, 99, 97, 116, 105, 111, 110, 0
 
2726
                            };
 
2727
                            data = staticallyStoredSchemaLocation;
 
2728
                            length = 14;
 
2729
                            break;
 
2730
                        }
 
2731
                    
 
2732
                        case Selector:
 
2733
                        {
 
2734
                            static const unsigned short staticallyStoredSelector[] =
 
2735
                            {
 
2736
                            115, 101, 108, 101, 99, 116, 111, 114, 0
 
2737
                            };
 
2738
                            data = staticallyStoredSelector;
 
2739
                            length = 8;
 
2740
                            break;
 
2741
                        }
 
2742
                    
 
2743
                        case Sequence:
 
2744
                        {
 
2745
                            static const unsigned short staticallyStoredSequence[] =
 
2746
                            {
 
2747
                            115, 101, 113, 117, 101, 110, 99, 101, 0
 
2748
                            };
 
2749
                            data = staticallyStoredSequence;
 
2750
                            length = 8;
 
2751
                            break;
 
2752
                        }
 
2753
                    
 
2754
                        case SimpleContent:
 
2755
                        {
 
2756
                            static const unsigned short staticallyStoredSimpleContent[] =
 
2757
                            {
 
2758
                            115, 105, 109, 112, 108, 101, 67, 111, 110, 116, 101, 110, 116, 0
 
2759
                            };
 
2760
                            data = staticallyStoredSimpleContent;
 
2761
                            length = 13;
 
2762
                            break;
 
2763
                        }
 
2764
                    
 
2765
                        case SimpleType:
 
2766
                        {
 
2767
                            static const unsigned short staticallyStoredSimpleType[] =
 
2768
                            {
 
2769
                            115, 105, 109, 112, 108, 101, 84, 121, 112, 101, 0
 
2770
                            };
 
2771
                            data = staticallyStoredSimpleType;
 
2772
                            length = 10;
 
2773
                            break;
 
2774
                        }
 
2775
                    
 
2776
                        case Source:
 
2777
                        {
 
2778
                            static const unsigned short staticallyStoredSource[] =
 
2779
                            {
 
2780
                            115, 111, 117, 114, 99, 101, 0
 
2781
                            };
 
2782
                            data = staticallyStoredSource;
 
2783
                            length = 6;
 
2784
                            break;
 
2785
                        }
 
2786
                    
 
2787
                        case SubstitutionGroup:
 
2788
                        {
 
2789
                            static const unsigned short staticallyStoredSubstitutionGroup[] =
 
2790
                            {
 
2791
                            115, 117, 98, 115, 116, 105, 116, 117, 116, 105, 111, 110, 71, 114, 111, 117, 112, 0
 
2792
                            };
 
2793
                            data = staticallyStoredSubstitutionGroup;
 
2794
                            length = 17;
 
2795
                            break;
 
2796
                        }
 
2797
                    
 
2798
                        case System:
 
2799
                        {
 
2800
                            static const unsigned short staticallyStoredSystem[] =
 
2801
                            {
 
2802
                            115, 121, 115, 116, 101, 109, 0
 
2803
                            };
 
2804
                            data = staticallyStoredSystem;
 
2805
                            length = 6;
 
2806
                            break;
 
2807
                        }
 
2808
                    
 
2809
                        case TargetNamespace:
 
2810
                        {
 
2811
                            static const unsigned short staticallyStoredTargetNamespace[] =
 
2812
                            {
 
2813
                            116, 97, 114, 103, 101, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101, 0
 
2814
                            };
 
2815
                            data = staticallyStoredTargetNamespace;
 
2816
                            length = 15;
 
2817
                            break;
 
2818
                        }
 
2819
                    
 
2820
                        case Test:
 
2821
                        {
 
2822
                            static const unsigned short staticallyStoredTest[] =
 
2823
                            {
 
2824
                            116, 101, 115, 116, 0
 
2825
                            };
 
2826
                            data = staticallyStoredTest;
 
2827
                            length = 4;
 
2828
                            break;
 
2829
                        }
 
2830
                    
 
2831
                        case TotalDigits:
 
2832
                        {
 
2833
                            static const unsigned short staticallyStoredTotalDigits[] =
 
2834
                            {
 
2835
                            116, 111, 116, 97, 108, 68, 105, 103, 105, 116, 115, 0
 
2836
                            };
 
2837
                            data = staticallyStoredTotalDigits;
 
2838
                            length = 11;
 
2839
                            break;
 
2840
                        }
 
2841
                    
 
2842
                        case Type:
 
2843
                        {
 
2844
                            static const unsigned short staticallyStoredType[] =
 
2845
                            {
 
2846
                            116, 121, 112, 101, 0
 
2847
                            };
 
2848
                            data = staticallyStoredType;
 
2849
                            length = 4;
 
2850
                            break;
 
2851
                        }
 
2852
                    
 
2853
                        case Union:
 
2854
                        {
 
2855
                            static const unsigned short staticallyStoredUnion[] =
 
2856
                            {
 
2857
                            117, 110, 105, 111, 110, 0
 
2858
                            };
 
2859
                            data = staticallyStoredUnion;
 
2860
                            length = 5;
 
2861
                            break;
 
2862
                        }
 
2863
                    
 
2864
                        case Unique:
 
2865
                        {
 
2866
                            static const unsigned short staticallyStoredUnique[] =
 
2867
                            {
 
2868
                            117, 110, 105, 113, 117, 101, 0
 
2869
                            };
 
2870
                            data = staticallyStoredUnique;
 
2871
                            length = 6;
 
2872
                            break;
 
2873
                        }
 
2874
                    
 
2875
                        case Use:
 
2876
                        {
 
2877
                            static const unsigned short staticallyStoredUse[] =
 
2878
                            {
 
2879
                            117, 115, 101, 0
 
2880
                            };
 
2881
                            data = staticallyStoredUse;
 
2882
                            length = 3;
 
2883
                            break;
 
2884
                        }
 
2885
                    
 
2886
                        case Value:
 
2887
                        {
 
2888
                            static const unsigned short staticallyStoredValue[] =
 
2889
                            {
 
2890
                            118, 97, 108, 117, 101, 0
 
2891
                            };
 
2892
                            data = staticallyStoredValue;
 
2893
                            length = 5;
 
2894
                            break;
 
2895
                        }
 
2896
                    
 
2897
                        case Version:
 
2898
                        {
 
2899
                            static const unsigned short staticallyStoredVersion[] =
 
2900
                            {
 
2901
                            118, 101, 114, 115, 105, 111, 110, 0
 
2902
                            };
 
2903
                            data = staticallyStoredVersion;
 
2904
                            length = 7;
 
2905
                            break;
 
2906
                        }
 
2907
                    
 
2908
                        case WhiteSpace:
 
2909
                        {
 
2910
                            static const unsigned short staticallyStoredWhiteSpace[] =
 
2911
                            {
 
2912
                            119, 104, 105, 116, 101, 83, 112, 97, 99, 101, 0
 
2913
                            };
 
2914
                            data = staticallyStoredWhiteSpace;
 
2915
                            length = 10;
 
2916
                            break;
 
2917
                        }
 
2918
                    
 
2919
                        case XML_NS_SCHEMA_URI:
 
2920
                        {
 
2921
                            static const unsigned short staticallyStoredXML_NS_SCHEMA_URI[] =
 
2922
                            {
 
2923
                            104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 119, 51, 46, 111, 114, 103, 47, 50, 48, 48, 49, 47, 88, 77, 76, 83, 99, 104, 101, 109, 97, 0
 
2924
                            };
 
2925
                            data = staticallyStoredXML_NS_SCHEMA_URI;
 
2926
                            length = 32;
 
2927
                            break;
 
2928
                        }
 
2929
                    
 
2930
                        case XPathDefaultNamespace:
 
2931
                        {
 
2932
                            static const unsigned short staticallyStoredXPathDefaultNamespace[] =
 
2933
                            {
 
2934
                            120, 112, 97, 116, 104, 68, 101, 102, 97, 117, 108, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101, 0
 
2935
                            };
 
2936
                            data = staticallyStoredXPathDefaultNamespace;
 
2937
                            length = 21;
 
2938
                            break;
 
2939
                        }
 
2940
                    
 
2941
                        case XmlLanguage:
 
2942
                        {
 
2943
                            static const unsigned short staticallyStoredXmlLanguage[] =
 
2944
                            {
 
2945
                            120, 109, 108, 58, 108, 97, 110, 103, 0
 
2946
                            };
 
2947
                            data = staticallyStoredXmlLanguage;
 
2948
                            length = 8;
 
2949
                            break;
 
2950
                        }
 
2951
                    
 
2952
                        case Xpath:
 
2953
                        {
 
2954
                            static const unsigned short staticallyStoredXpath[] =
 
2955
                            {
 
2956
                            120, 112, 97, 116, 104, 0
 
2957
                            };
 
2958
                            data = staticallyStoredXpath;
 
2959
                            length = 5;
 
2960
                            break;
 
2961
                        }
 
2962
                    
 
2963
                        default:
 
2964
                            /* It's either the default token, or an undefined enum
 
2965
                             * value. We silence a compiler warning, and return the
 
2966
                             * empty string. */
 
2967
                            ;
 
2968
                    }
 
2969
 
 
2970
                    union
 
2971
                    {
 
2972
                        const unsigned short *data;
 
2973
                        const QChar *asQChar;
 
2974
                    } converter;
 
2975
                    converter.data = data;
 
2976
 
 
2977
                    return QString::fromRawData(converter.asQChar, length);
 
2978
                }
 
2979
            
 
2980
QT_END_NAMESPACE
 
2981