source: trunk/src/xmlpatterns/parser/qxslttokenlookup.cpp@ 1036

Last change on this file since 1036 was 846, checked in by Dmitry A. Kuminov, 14 years ago

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