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
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	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 2) == 0)
123
124
125	return Use;
126
127	}
128
129
130
131	return NoKeyword;
132	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 3) == 0)
296
297
298	return When;
299
300	}
301
302
303
304	return NoKeyword;
305	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 4) == 0)
383
384
385	return Regex;
386
387	}
388
389
390
391	return NoKeyword;
392	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 5) == 0)
548
549
550	return Tunnel;
551
552	}
553
554
555
556	return NoKeyword;
557	}
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(s1: &data[3], s2: &string, n: 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(s1: &data[3], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 6) == 0)
665
666
667	return Version;
668
669	}
670
671
672
673	return NoKeyword;
674	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[3], s2: &string, n: 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(s1: &data[3], s2: &string, n: sizeof(QChar) * 5) == 0)
902
903
904	return Variable;
905
906	}
907
908
909	}
910
911
912	}
913
914
915
916	return NoKeyword;
917	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[2], s2: &string, n: sizeof(QChar) * 7) == 0)
1047
1048
1049	return Transform;
1050
1051	}
1052
1053
1054	}
1055
1056
1057
1058	return NoKeyword;
1059	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[3], s2: &string, n: 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(s1: &data[3], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 9) == 0)
1167
1168
1169	return WithParam;
1170
1171	}
1172
1173
1174
1175	return NoKeyword;
1176	}
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(s1: &data[0], s2: &string, n: sizeof(QChar) * 11) == 0)
1186
1187
1188	return StripSpace;
1189
1190
1191	return NoKeyword;
1192	}
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(s1: &data[0], s2: &string, n: sizeof(QChar) * 12) == 0)
1202
1203
1204	return PerformSort;
1205
1206
1207	return NoKeyword;
1208	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 12) == 0)
1254
1255
1256	return ImportSchema;
1257
1258	}
1259
1260
1261
1262	return NoKeyword;
1263	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[9], s2: &string, n: 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(s1: &data[9], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 13) == 0)
1397
1398
1399	return PreserveSpace;
1400
1401	}
1402
1403
1404
1405	return NoKeyword;
1406	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 14) == 0)
1484
1485
1486	return SchemaLocation;
1487
1488	}
1489
1490
1491
1492	return NoKeyword;
1493	}
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(s1: &data[0], s2: &string, n: sizeof(QChar) * 17) == 0)
1503
1504
1505	return DefaultCollation;
1506
1507
1508	return NoKeyword;
1509	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[2], s2: &string, n: 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(s1: &data[5], s2: &string, n: 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(s1: &data[5], s2: &string, n: 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	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 19) == 0)
1686
1687
1688	return OmitXmlDeclaration;
1689
1690	}
1691
1692
1693
1694	return NoKeyword;
1695	}
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(s1: &data[0], s2: &string, n: sizeof(QChar) * 21) == 0)
1705
1706
1707	return EscapeUriAttributes;
1708
1709
1710	return NoKeyword;
1711	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 21) == 0)
1773
1774
1775	return ProcessingInstruction;
1776
1777	}
1778
1779
1780
1781	return NoKeyword;
1782	}
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(s1: &data[1], s2: &string, n: 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(s1: &data[1], s2: &string, n: sizeof(QChar) * 22) == 0)
1812
1813
1814	return XpathDefaultNamespace;
1815
1816	}
1817
1818
1819
1820	return NoKeyword;
1821	}
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(s1: &data[0], s2: &string, n: sizeof(QChar) * 26) == 0)
1831
1832
1833	return ExtensionElementPrefixes;
1834
1835
1836	return NoKeyword;
1837	}
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
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, size: length);
3001	}
3002
3003	QT_END_NAMESPACE
3004
3005