source: trunk/src/xmlpatterns/schema/qxsdschematoken.cpp

Last change on this file was 561, checked in by Dmitry A. Kuminov, 15 years ago

trunk: Merged in qt 4.6.1 sources.
  • Property svn:eol-style set to native
File size: 95.7 KB
RevLine 
[556]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** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
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** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42/* NOTE: This file is AUTO GENERATED by qautomaton2cpp.xsl. */
43
44#include "qxsdschematoken_p.h"
45
46QT_BEGIN_NAMESPACE
47
48XsdSchemaToken::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
2980QT_END_NAMESPACE
2981
Note: See TracBrowser for help on using the repository browser.