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