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

source code of qtxmlpatterns/src/xmlpatterns/schema/qxsdschematoken.cpp