Qt 4.8
qxslttokenlookup.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
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 Digia. For licensing terms and
14 ** conditions see http://qt.digia.com/licensing. For further information
15 ** use the contact form at http://qt.digia.com/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 2.1 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 **
25 ** In addition, as a special exception, Digia gives you certain additional
26 ** rights. These rights are described in the Digia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28 **
29 ** GNU General Public License Usage
30 ** Alternatively, this file may be used under the terms of the GNU
31 ** General Public License version 3.0 as published by the Free Software
32 ** Foundation and appearing in the file LICENSE.GPL included in the
33 ** packaging of this file. Please review the following information to
34 ** ensure the GNU General Public License version 3.0 requirements will be
35 ** met: http://www.gnu.org/copyleft/gpl.html.
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41 
42 /* NOTE: This file is AUTO GENERATED by qtokenautomaton2cpp.xsl. */
43 
44 #include "qxslttokenlookup_p.h"
45 
46 QT_BEGIN_NAMESPACE
47 
48 using namespace QPatternist;
49 
50 XSLTTokenLookup::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 
3005 QT_END_NAMESPACE
3006 
QPatternist::XSLTTokenLookup::classifier7
static NodeName classifier7(const QChar *data)
Definition: qxslttokenlookup.cpp:560
QPatternist::XSLTTokenLookup::classifier10
static NodeName classifier10(const QChar *data)
Definition: qxslttokenlookup.cpp:1062
QPatternist::XSLTTokenLookup::classifier13
static NodeName classifier13(const QChar *data)
Definition: qxslttokenlookup.cpp:1211
QT_END_NAMESPACE
#define QT_END_NAMESPACE
This macro expands to.
Definition: qglobal.h:90
QPatternist::XSLTTokenLookup::classifier12
static NodeName classifier12(const QChar *data)
Definition: qxslttokenlookup.cpp:1195
QPatternist::XSLTTokenLookup::classifier11
static NodeName classifier11(const QChar *data)
Definition: qxslttokenlookup.cpp:1179
QPatternist::XSLTTokenLookup::classifier21
static NodeName classifier21(const QChar *data)
Definition: qxslttokenlookup.cpp:1698
QString
The QString class provides a Unicode character string.
Definition: qstring.h:83
QPatternist::XSLTTokenLookup::classifier5
static NodeName classifier5(const QChar *data)
Definition: qxslttokenlookup.cpp:308
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72
QString::fromRawData
static QString fromRawData(const QChar *, int size)
Constructs a QString that uses the first size Unicode characters in the array unicode.
Definition: qstring.cpp:7673
QPatternist::XSLTTokenLookup::classifier17
static NodeName classifier17(const QChar *data)
Definition: qxslttokenlookup.cpp:1496
QT_BEGIN_NAMESPACE
#define QT_BEGIN_NAMESPACE
This macro expands to.
Definition: qglobal.h:89
QPatternist::XSLTTokenLookup::classifier14
static NodeName classifier14(const QChar *data)
Definition: qxslttokenlookup.cpp:1266
QPatternist::XSLTTokenLookup::classifier2
static NodeName classifier2(const QChar *data)
Definition: qxslttokenlookup.cpp:50
QPatternist
The namespace for the internal API of QtXmlPatterns.
Definition: qacceliterators_p.h:62
QPatternist::XSLTTokenLookup::classifier18
static NodeName classifier18(const QChar *data)
Definition: qxslttokenlookup.cpp:1512
data
static const char * data(const QByteArray &arr)
Definition: qdbusmessage.cpp:60
QPatternist::XSLTTokenLookup::classifier3
static NodeName classifier3(const QChar *data)
Definition: qxslttokenlookup.cpp:96
QPatternist::XSLTTokenLookup::classifier6
static NodeName classifier6(const QChar *data)
Definition: qxslttokenlookup.cpp:395
QPatternist::XSLTTokenLookup::classifier15
static NodeName classifier15(const QChar *data)
Definition: qxslttokenlookup.cpp:1409
QPatternist::XSLTTokenLookup::classifier23
static NodeName classifier23(const QChar *data)
Definition: qxslttokenlookup.cpp:1785
QPatternist::XSLTTokenLookup::classifier4
static NodeName classifier4(const QChar *data)
Definition: qxslttokenlookup.cpp:135
qxslttokenlookup_p.h
QPatternist::XSLTTokenLookup::classifier9
static NodeName classifier9(const QChar *data)
Definition: qxslttokenlookup.cpp:920
QPatternist::XSLTTokenLookup::toString
static QString toString(NodeName token)
Definition: qxslttokenlookup.cpp:1935
QPatternist::XSLTTokenLookup::classifier22
static NodeName classifier22(const QChar *data)
Definition: qxslttokenlookup.cpp:1714
QPatternist::XSLTTokenLookup::classifier8
static NodeName classifier8(const QChar *data)
Definition: qxslttokenlookup.cpp:677
QPatternist::XSLTTokenLookup::classifier26
static NodeName classifier26(const QChar *data)
Definition: qxslttokenlookup.cpp:1824
QPatternist::XSLTTokenLookup::classifier20
static NodeName classifier20(const QChar *data)
Definition: qxslttokenlookup.cpp:1659
QPatternist::XSLTTokenLookup::toToken
static NodeName toToken(const QString &value)
Definition: qxslttokenlookup_p.h:199
Qt 4.8 Source Code Browser