Qt 4.8
Public Types | Static Public Functions | Static Private Functions | List of all members
QPatternist::XSLTTokenLookup Class Reference

#include <qxslttokenlookup_p.h>

Inheritance diagram for QPatternist::XSLTTokenLookup:
QPatternist::MaintainingReader< XSLTTokenLookup > QPatternist::XSLTTokenizer

Public Types

enum  NodeName {
  NoKeyword, AnalyzeString, ApplyTemplates, As,
  Attribute, AttributeSet, ByteOrderMark, CallTemplate,
  CaseOrder, CdataSectionElements, Choose, Collation,
  Comment, Copy, CopyNamespaces, CopyOf,
  DataType, DefaultCollation, DefaultValidation, DoctypePublic,
  DoctypeSystem, Document, Element, Elements,
  Encoding, EscapeUriAttributes, ExcludeResultPrefixes, ExtensionElementPrefixes,
  Flags, ForEach, Format, Function,
  Href, Id, If, Import,
  ImportSchema, Include, IncludeContentType, Indent,
  InheritNamespaces, InputTypeAnnotations, Key, Lang,
  Match, MatchingSubstring, MediaType, Message,
  Method, Mode, Name, Namespace,
  NonMatchingSubstring, NormalizationForm, OmitXmlDeclaration, Order,
  Otherwise, Output, OutputVersion, Override,
  Param, PerformSort, PreserveSpace, Priority,
  ProcessingInstruction, Regex, Required, ResultDocument,
  SchemaLocation, Select, Separator, Sequence,
  Sort, Stable, Standalone, StripSpace,
  Stylesheet, Template, Terminate, Test,
  Text, Transform, Tunnel, Type,
  UndeclarePrefixes, Use, UseAttributeSets, UseCharacterMaps,
  UseWhen, Validation, ValueOf, Variable,
  Version, When, WithParam, XpathDefaultNamespace
}
 

Static Public Functions

static QString toString (NodeName token)
 
static NodeName toToken (const QString &value)
 
static NodeName toToken (const QStringRef &value)
 
static NodeName toToken (const QChar *data, int length)
 

Static Private Functions

static NodeName classifier10 (const QChar *data)
 
static NodeName classifier11 (const QChar *data)
 
static NodeName classifier12 (const QChar *data)
 
static NodeName classifier13 (const QChar *data)
 
static NodeName classifier14 (const QChar *data)
 
static NodeName classifier15 (const QChar *data)
 
static NodeName classifier17 (const QChar *data)
 
static NodeName classifier18 (const QChar *data)
 
static NodeName classifier2 (const QChar *data)
 
static NodeName classifier20 (const QChar *data)
 
static NodeName classifier21 (const QChar *data)
 
static NodeName classifier22 (const QChar *data)
 
static NodeName classifier23 (const QChar *data)
 
static NodeName classifier26 (const QChar *data)
 
static NodeName classifier3 (const QChar *data)
 
static NodeName classifier4 (const QChar *data)
 
static NodeName classifier5 (const QChar *data)
 
static NodeName classifier6 (const QChar *data)
 
static NodeName classifier7 (const QChar *data)
 
static NodeName classifier8 (const QChar *data)
 
static NodeName classifier9 (const QChar *data)
 

Detailed Description

Definition at line 64 of file qxslttokenlookup_p.h.

Enumerations

◆ NodeName

enum QPatternist::XSLTTokenLookup::NodeName
Enumerator
NoKeyword 
AnalyzeString 
ApplyTemplates 
As 
Attribute 
AttributeSet 
ByteOrderMark 
CallTemplate 
CaseOrder 
CdataSectionElements 
Choose 
Collation 
Comment 
Copy 
CopyNamespaces 
CopyOf 
DataType 
DefaultCollation 
DefaultValidation 
DoctypePublic 
DoctypeSystem 
Document 
Element 
Elements 
Encoding 
EscapeUriAttributes 
ExcludeResultPrefixes 
ExtensionElementPrefixes 
Flags 
ForEach 
Format 
Function 
Href 
Id 
If 
Import 
ImportSchema 
Include 
IncludeContentType 
Indent 
InheritNamespaces 
InputTypeAnnotations 
Key 
Lang 
Match 
MatchingSubstring 
MediaType 
Message 
Method 
Mode 
Name 
Namespace 
NonMatchingSubstring 
NormalizationForm 
OmitXmlDeclaration 
Order 
Otherwise 
Output 
OutputVersion 
Override 
Param 
PerformSort 
PreserveSpace 
Priority 
ProcessingInstruction 
Regex 
Required 
ResultDocument 
SchemaLocation 
Select 
Separator 
Sequence 
Sort 
Stable 
Standalone 
StripSpace 
Stylesheet 
Template 
Terminate 
Test 
Text 
Transform 
Tunnel 
Type 
UndeclarePrefixes 
Use 
UseAttributeSets 
UseCharacterMaps 
UseWhen 
Validation 
ValueOf 
Variable 
Version 
When 
WithParam 
XpathDefaultNamespace 

Definition at line 67 of file qxslttokenlookup_p.h.

69  {
70  NoKeyword,
71  AnalyzeString,
72  ApplyTemplates,
73  As,
74  Attribute,
75  AttributeSet,
76  ByteOrderMark,
77  CallTemplate,
78  CaseOrder,
79  CdataSectionElements,
80  Choose,
81  Collation,
82  Comment,
83  Copy,
84  CopyNamespaces,
85  CopyOf,
86  DataType,
87  DefaultCollation,
88  DefaultValidation,
89  DoctypePublic,
90  DoctypeSystem,
91  Document,
92  Element,
93  Elements,
94  Encoding,
95  EscapeUriAttributes,
96  ExcludeResultPrefixes,
97  ExtensionElementPrefixes,
98  Flags,
99  ForEach,
100  Format,
101  Function,
102  Href,
103  Id,
104  If,
105  Import,
106  ImportSchema,
107  Include,
108  IncludeContentType,
109  Indent,
110  InheritNamespaces,
111  InputTypeAnnotations,
112  Key,
113  Lang,
114  Match,
115  MatchingSubstring,
116  MediaType,
117  Message,
118  Method,
119  Mode,
120  Name,
121  Namespace,
122  NonMatchingSubstring,
123  NormalizationForm,
124  OmitXmlDeclaration,
125  Order,
126  Otherwise,
127  Output,
128  OutputVersion,
129  Override,
130  Param,
131  PerformSort,
132  PreserveSpace,
133  Priority,
134  ProcessingInstruction,
135  Regex,
136  Required,
137  ResultDocument,
138  SchemaLocation,
139  Select,
140  Separator,
141  Sequence,
142  Sort,
143  Stable,
144  Standalone,
145  StripSpace,
146  Stylesheet,
147  Template,
148  Terminate,
149  Test,
150  Text,
151  Transform,
152  Tunnel,
153  Type,
154  UndeclarePrefixes,
155  Use,
156  UseAttributeSets,
157  UseCharacterMaps,
158  UseWhen,
159  Validation,
160  ValueOf,
161  Variable,
162  Version,
163  When,
164  WithParam,
165  XpathDefaultNamespace
166  };

Functions

◆ classifier10()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier10 ( const QChar *  data)
inlinestaticprivate

Definition at line 1062 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier11()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier11 ( const QChar *  data)
inlinestaticprivate

Definition at line 1179 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier12()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier12 ( const QChar *  data)
inlinestaticprivate

Definition at line 1195 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier13()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier13 ( const QChar *  data)
inlinestaticprivate

Definition at line 1211 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier14()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier14 ( const QChar *  data)
inlinestaticprivate

Definition at line 1266 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier15()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier15 ( const QChar *  data)
inlinestaticprivate

Definition at line 1409 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier17()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier17 ( const QChar *  data)
inlinestaticprivate

Definition at line 1496 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier18()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier18 ( const QChar *  data)
inlinestaticprivate

Definition at line 1512 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier2()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier2 ( const QChar *  data)
inlinestaticprivate

Definition at line 50 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }

◆ classifier20()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier20 ( const QChar *  data)
inlinestaticprivate

Definition at line 1659 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier21()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier21 ( const QChar *  data)
inlinestaticprivate

Definition at line 1698 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier22()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier22 ( const QChar *  data)
inlinestaticprivate

Definition at line 1714 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier23()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier23 ( const QChar *  data)
inlinestaticprivate

Definition at line 1785 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier26()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier26 ( const QChar *  data)
inlinestaticprivate

Definition at line 1824 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier3()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier3 ( const QChar *  data)
inlinestaticprivate

Definition at line 96 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier4()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier4 ( const QChar *  data)
inlinestaticprivate

Definition at line 135 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier5()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier5 ( const QChar *  data)
inlinestaticprivate

Definition at line 308 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier6()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier6 ( const QChar *  data)
inlinestaticprivate

Definition at line 395 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier7()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier7 ( const QChar *  data)
inlinestaticprivate

Definition at line 560 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier8()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier8 ( const QChar *  data)
inlinestaticprivate

Definition at line 677 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier9()

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier9 ( const QChar *  data)
inlinestaticprivate

Definition at line 920 of file qxslttokenlookup.cpp.

Referenced by toToken().

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  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ toString()

QString XSLTTokenLookup::toString ( NodeName  token)
static

Definition at line 1935 of file qxslttokenlookup.cpp.

Referenced by QPatternist::XSLTTokenizer::insideSequenceConstructor(), QPatternist::XSLTTokenizer::insideStylesheetModule(), QPatternist::XSLTTokenizer::queueSelectOrSequenceConstructor(), QPatternist::XSLTTokenizer::queueSorting(), and QPatternist::XSLTTokenizer::skipBodyOfParam().

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  }
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
data
static const char * data(const QByteArray &arr)
Definition: qdbusmessage.cpp:60

◆ toToken() [1/3]

XSLTTokenLookup::NodeName QPatternist::XSLTTokenLookup::toToken ( const QString &  value)
inlinestatic

Definition at line 199 of file qxslttokenlookup_p.h.

Referenced by QPatternist::XSLTTokenizer::handleStandardAttributes(), and toToken().

200  {
201  return toToken(value.constData(), value.length());
202  }
QString::length
int length() const
Returns the number of characters in this string.
Definition: qstring.h:696
QPatternist::XSLTTokenLookup::toToken
static NodeName toToken(const QString &value)
Definition: qxslttokenlookup_p.h:199
QString::constData
const QChar * constData() const
Returns a pointer to the data stored in the QString.
Definition: qstring.h:712

◆ toToken() [2/3]

XSLTTokenLookup::NodeName QPatternist::XSLTTokenLookup::toToken ( const QStringRef &  value)
inlinestatic

Definition at line 204 of file qxslttokenlookup_p.h.

205  {
206  return toToken(value.constData(), value.length());
207  }
QStringRef::length
int length() const
Returns the number of characters referred to by the string reference.
Definition: qstring.h:1116
QStringRef::constData
const QChar * constData() const
Same as unicode().
Definition: qstring.h:1159
QPatternist::XSLTTokenLookup::toToken
static NodeName toToken(const QString &value)
Definition: qxslttokenlookup_p.h:199

◆ toToken() [3/3]

XSLTTokenLookup::NodeName XSLTTokenLookup::toToken ( const QChar *  data,
int  length 
)
static

Definition at line 1840 of file qxslttokenlookup.cpp.

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  }
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
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
QPatternist::XSLTTokenLookup::classifier5
static NodeName classifier5(const QChar *data)
Definition: qxslttokenlookup.cpp:308
QPatternist::XSLTTokenLookup::classifier17
static NodeName classifier17(const QChar *data)
Definition: qxslttokenlookup.cpp:1496
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::XSLTTokenLookup::classifier18
static NodeName classifier18(const QChar *data)
Definition: qxslttokenlookup.cpp:1512
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
QPatternist::XSLTTokenLookup::classifier9
static NodeName classifier9(const QChar *data)
Definition: qxslttokenlookup.cpp:920
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
The documentation for this class was generated from the following files:
Qt 4.8 Source Code Browser