| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtXmlPatterns module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| /* NOTE: This file is AUTO GENERATED by qtokenautomaton2cpp.xsl. */ |
| |
| #include "qxslttokenlookup_p.h" |
| |
| QT_BEGIN_NAMESPACE |
| |
| using namespace QPatternist; |
| |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier2(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| if (data[1].unicode() == 115) |
| |
| |
| return As; |
| |
| } |
| |
| else if (data[0].unicode() == 105) |
| |
| |
| { |
| if (data[1].unicode() == 100) |
| |
| |
| { |
| |
| |
| return Id; |
| |
| } |
| |
| else if (data[1].unicode() == 102) |
| |
| |
| { |
| |
| |
| return If; |
| |
| } |
| |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier3(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 107) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 121 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0) |
| |
| |
| return Key; |
| |
| } |
| |
| else if (data[0].unicode() == 117) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 115, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0) |
| |
| |
| return Use; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier4(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 112, 121 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) |
| |
| |
| return Copy; |
| |
| } |
| |
| else if (data[0].unicode() == 104) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 114, 101, 102 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) |
| |
| |
| return Href; |
| |
| } |
| |
| else if (data[0].unicode() == 108) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 110, 103 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) |
| |
| |
| return Lang; |
| |
| } |
| |
| else if (data[0].unicode() == 109) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 100, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) |
| |
| |
| return Mode; |
| |
| } |
| |
| else if (data[0].unicode() == 110) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 109, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) |
| |
| |
| return Name; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 114, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) |
| |
| |
| return Sort; |
| |
| } |
| |
| else if (data[0].unicode() == 116) |
| |
| |
| { |
| if (data[1].unicode() == 101) |
| |
| |
| { |
| if (data[2].unicode() == 115) |
| |
| |
| { |
| |
| if (data[3].unicode() == 116) |
| |
| |
| return Test; |
| |
| } |
| |
| else if (data[2].unicode() == 120) |
| |
| |
| { |
| |
| if (data[3].unicode() == 116) |
| |
| |
| return Text; |
| |
| } |
| |
| |
| } |
| |
| else if (data[1].unicode() == 121) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 112, 101 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0) |
| |
| |
| return Type; |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 119) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 104, 101, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) |
| |
| |
| return When; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier5(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 102) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 108, 97, 103, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Flags; |
| |
| } |
| |
| else if (data[0].unicode() == 109) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 116, 99, 104 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Match; |
| |
| } |
| |
| else if (data[0].unicode() == 111) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 114, 100, 101, 114 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Order; |
| |
| } |
| |
| else if (data[0].unicode() == 112) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 114, 97, 109 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Param; |
| |
| } |
| |
| else if (data[0].unicode() == 114) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 103, 101, 120 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Regex; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier6(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 104, 111, 111, 115, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Choose; |
| |
| } |
| |
| else if (data[0].unicode() == 102) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 114, 109, 97, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Format; |
| |
| } |
| |
| else if (data[0].unicode() == 105) |
| |
| |
| { |
| if (data[1].unicode() == 109) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 112, 111, 114, 116 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Import; |
| |
| } |
| |
| else if (data[1].unicode() == 110) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 100, 101, 110, 116 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Indent; |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 109) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 116, 104, 111, 100 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Method; |
| |
| } |
| |
| else if (data[0].unicode() == 111) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 117, 116, 112, 117, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Output; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| if (data[1].unicode() == 101) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 108, 101, 99, 116 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Select; |
| |
| } |
| |
| else if (data[1].unicode() == 116) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 98, 108, 101 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Stable; |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 116) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 117, 110, 110, 101, 108 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Tunnel; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier7(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 99) |
| |
| |
| { |
| if (data[1].unicode() == 111) |
| |
| |
| { |
| if (data[2].unicode() == 109) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 109, 101, 110, 116 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Comment; |
| |
| } |
| |
| else if (data[2].unicode() == 112) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 121, 45, 111, 102 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return CopyOf; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 101) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 108, 101, 109, 101, 110, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Element; |
| |
| } |
| |
| else if (data[0].unicode() == 105) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 99, 108, 117, 100, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Include; |
| |
| } |
| |
| else if (data[0].unicode() == 109) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 115, 115, 97, 103, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Message; |
| |
| } |
| |
| else if (data[0].unicode() == 118) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 114, 115, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Version; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier8(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 100) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 99, 117, 109, 101, 110, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Document; |
| |
| } |
| |
| else if (data[0].unicode() == 101) |
| |
| |
| { |
| if (data[1].unicode() == 108) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 109, 101, 110, 116, 115 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Elements; |
| |
| } |
| |
| else if (data[1].unicode() == 110) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 99, 111, 100, 105, 110, 103 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Encoding; |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 102) |
| |
| |
| { |
| if (data[1].unicode() == 111) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 114, 45, 101, 97, 99, 104 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return ForEach; |
| |
| } |
| |
| else if (data[1].unicode() == 117) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 99, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Function; |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 111) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 118, 101, 114, 114, 105, 100, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Override; |
| |
| } |
| |
| else if (data[0].unicode() == 112) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 114, 105, 111, 114, 105, 116, 121 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Priority; |
| |
| } |
| |
| else if (data[0].unicode() == 114) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 113, 117, 105, 114, 101, 100 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Required; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 113, 117, 101, 110, 99, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Sequence; |
| |
| } |
| |
| else if (data[0].unicode() == 116) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 109, 112, 108, 97, 116, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Template; |
| |
| } |
| |
| else if (data[0].unicode() == 117) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 115, 101, 45, 119, 104, 101, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return UseWhen; |
| |
| } |
| |
| else if (data[0].unicode() == 118) |
| |
| |
| { |
| if (data[1].unicode() == 97) |
| |
| |
| { |
| if (data[2].unicode() == 108) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 117, 101, 45, 111, 102 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return ValueOf; |
| |
| } |
| |
| else if (data[2].unicode() == 114) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 105, 97, 98, 108, 101 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Variable; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier9(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 116, 116, 114, 105, 98, 117, 116, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return Attribute; |
| |
| } |
| |
| else if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 108, 108, 97, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return Collation; |
| |
| } |
| |
| else if (data[0].unicode() == 100) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 116, 97, 45, 116, 121, 112, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return DataType; |
| |
| } |
| |
| else if (data[0].unicode() == 110) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 109, 101, 115, 112, 97, 99, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return Namespace; |
| |
| } |
| |
| else if (data[0].unicode() == 111) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 116, 104, 101, 114, 119, 105, 115, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return Otherwise; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 112, 97, 114, 97, 116, 111, 114 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return Separator; |
| |
| } |
| |
| else if (data[0].unicode() == 116) |
| |
| |
| { |
| if (data[1].unicode() == 101) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 114, 109, 105, 110, 97, 116, 101 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Terminate; |
| |
| } |
| |
| else if (data[1].unicode() == 114) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 110, 115, 102, 111, 114, 109 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Transform; |
| |
| } |
| |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier10(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 115, 101, 45, 111, 114, 100, 101, 114 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0) |
| |
| |
| return CaseOrder; |
| |
| } |
| |
| else if (data[0].unicode() == 109) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 100, 105, 97, 45, 116, 121, 112, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0) |
| |
| |
| return MediaType; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| if (data[1].unicode() == 116) |
| |
| |
| { |
| if (data[2].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 100, 97, 108, 111, 110, 101 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Standalone; |
| |
| } |
| |
| else if (data[2].unicode() == 121) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 108, 101, 115, 104, 101, 101, 116 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Stylesheet; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 118) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 108, 105, 100, 97, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0) |
| |
| |
| return Validation; |
| |
| } |
| |
| else if (data[0].unicode() == 119) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 105, 116, 104, 45, 112, 97, 114, 97, 109 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0) |
| |
| |
| return WithParam; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier11(const QChar *data) |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 115, 116, 114, 105, 112, 45, 115, 112, 97, 99, 101 |
| }; |
| if(memcmp(&data[0], &string, sizeof(QChar) * 11) == 0) |
| |
| |
| return StripSpace; |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier12(const QChar *data) |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 112, 101, 114, 102, 111, 114, 109, 45, 115, 111, 114, 116 |
| }; |
| if(memcmp(&data[0], &string, sizeof(QChar) * 12) == 0) |
| |
| |
| return PerformSort; |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier13(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0) |
| |
| |
| return AttributeSet; |
| |
| } |
| |
| else if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 108, 108, 45, 116, 101, 109, 112, 108, 97, 116, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0) |
| |
| |
| return CallTemplate; |
| |
| } |
| |
| else if (data[0].unicode() == 105) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 109, 112, 111, 114, 116, 45, 115, 99, 104, 101, 109, 97 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0) |
| |
| |
| return ImportSchema; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier14(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 97, 108, 121, 122, 101, 45, 115, 116, 114, 105, 110, 103 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0) |
| |
| |
| return AnalyzeString; |
| |
| } |
| |
| else if (data[0].unicode() == 100) |
| |
| |
| { |
| if (data[1].unicode() == 111) |
| |
| |
| { |
| if (data[2].unicode() == 99) |
| |
| |
| { |
| if (data[3].unicode() == 116) |
| |
| |
| { |
| if (data[4].unicode() == 121) |
| |
| |
| { |
| if (data[5].unicode() == 112) |
| |
| |
| { |
| if (data[6].unicode() == 101) |
| |
| |
| { |
| if (data[7].unicode() == 45) |
| |
| |
| { |
| if (data[8].unicode() == 112) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 117, 98, 108, 105, 99 |
| }; |
| if(memcmp(&data[9], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return DoctypePublic; |
| |
| } |
| |
| else if (data[8].unicode() == 115) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 121, 115, 116, 101, 109 |
| }; |
| if(memcmp(&data[9], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return DoctypeSystem; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 111) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 117, 116, 112, 117, 116, 45, 118, 101, 114, 115, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0) |
| |
| |
| return OutputVersion; |
| |
| } |
| |
| else if (data[0].unicode() == 112) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 114, 101, 115, 101, 114, 118, 101, 45, 115, 112, 97, 99, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0) |
| |
| |
| return PreserveSpace; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier15(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 112, 112, 108, 121, 45, 116, 101, 109, 112, 108, 97, 116, 101, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0) |
| |
| |
| return ApplyTemplates; |
| |
| } |
| |
| else if (data[0].unicode() == 98) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 121, 116, 101, 45, 111, 114, 100, 101, 114, 45, 109, 97, 114, 107 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0) |
| |
| |
| return ByteOrderMark; |
| |
| } |
| |
| else if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 112, 121, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0) |
| |
| |
| return CopyNamespaces; |
| |
| } |
| |
| else if (data[0].unicode() == 114) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 115, 117, 108, 116, 45, 100, 111, 99, 117, 109, 101, 110, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0) |
| |
| |
| return ResultDocument; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 99, 104, 101, 109, 97, 45, 108, 111, 99, 97, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0) |
| |
| |
| return SchemaLocation; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier17(const QChar *data) |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 100, 101, 102, 97, 117, 108, 116, 45, 99, 111, 108, 108, 97, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[0], &string, sizeof(QChar) * 17) == 0) |
| |
| |
| return DefaultCollation; |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier18(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 100) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 102, 97, 117, 108, 116, 45, 118, 97, 108, 105, 100, 97, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0) |
| |
| |
| return DefaultValidation; |
| |
| } |
| |
| else if (data[0].unicode() == 105) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 104, 101, 114, 105, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0) |
| |
| |
| return InheritNamespaces; |
| |
| } |
| |
| else if (data[0].unicode() == 109) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0) |
| |
| |
| return MatchingSubstring; |
| |
| } |
| |
| else if (data[0].unicode() == 110) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 114, 109, 97, 108, 105, 122, 97, 116, 105, 111, 110, 45, 102, 111, 114, 109 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0) |
| |
| |
| return NormalizationForm; |
| |
| } |
| |
| else if (data[0].unicode() == 117) |
| |
| |
| { |
| if (data[1].unicode() == 110) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 100, 101, 99, 108, 97, 114, 101, 45, 112, 114, 101, 102, 105, 120, 101, 115 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 16) == 0) |
| |
| |
| return UndeclarePrefixes; |
| |
| } |
| |
| else if (data[1].unicode() == 115) |
| |
| |
| { |
| if (data[2].unicode() == 101) |
| |
| |
| { |
| if (data[3].unicode() == 45) |
| |
| |
| { |
| if (data[4].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 115 |
| }; |
| if(memcmp(&data[5], &string, sizeof(QChar) * 13) == 0) |
| |
| |
| return UseAttributeSets; |
| |
| } |
| |
| else if (data[4].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 104, 97, 114, 97, 99, 116, 101, 114, 45, 109, 97, 112, 115 |
| }; |
| if(memcmp(&data[5], &string, sizeof(QChar) * 13) == 0) |
| |
| |
| return UseCharacterMaps; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier20(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 105) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 99, 108, 117, 100, 101, 45, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 19) == 0) |
| |
| |
| return IncludeContentType; |
| |
| } |
| |
| else if (data[0].unicode() == 111) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 109, 105, 116, 45, 120, 109, 108, 45, 100, 101, 99, 108, 97, 114, 97, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 19) == 0) |
| |
| |
| return OmitXmlDeclaration; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier21(const QChar *data) |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 115, 99, 97, 112, 101, 45, 117, 114, 105, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 115 |
| }; |
| if(memcmp(&data[0], &string, sizeof(QChar) * 21) == 0) |
| |
| |
| return EscapeUriAttributes; |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier22(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 100, 97, 116, 97, 45, 115, 101, 99, 116, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0) |
| |
| |
| return CdataSectionElements; |
| |
| } |
| |
| else if (data[0].unicode() == 105) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 112, 117, 116, 45, 116, 121, 112, 101, 45, 97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0) |
| |
| |
| return InputTypeAnnotations; |
| |
| } |
| |
| else if (data[0].unicode() == 110) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 110, 45, 109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0) |
| |
| |
| return NonMatchingSubstring; |
| |
| } |
| |
| else if (data[0].unicode() == 112) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 114, 111, 99, 101, 115, 115, 105, 110, 103, 45, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0) |
| |
| |
| return ProcessingInstruction; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier23(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 101) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 120, 99, 108, 117, 100, 101, 45, 114, 101, 115, 117, 108, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 22) == 0) |
| |
| |
| return ExcludeResultPrefixes; |
| |
| } |
| |
| else if (data[0].unicode() == 120) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 112, 97, 116, 104, 45, 100, 101, 102, 97, 117, 108, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 22) == 0) |
| |
| |
| return XpathDefaultNamespace; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier26(const QChar *data) |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 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 |
| }; |
| if(memcmp(&data[0], &string, sizeof(QChar) * 26) == 0) |
| |
| |
| return ExtensionElementPrefixes; |
| |
| |
| return NoKeyword; |
| } |
| XSLTTokenLookup::NodeName XSLTTokenLookup::toToken(const QChar *data, int length) |
| { |
| switch(length) |
| { |
| |
| case 2: |
| return classifier2(data); |
| |
| |
| case 3: |
| return classifier3(data); |
| |
| |
| case 4: |
| return classifier4(data); |
| |
| |
| case 5: |
| return classifier5(data); |
| |
| |
| case 6: |
| return classifier6(data); |
| |
| |
| case 7: |
| return classifier7(data); |
| |
| |
| case 8: |
| return classifier8(data); |
| |
| |
| case 9: |
| return classifier9(data); |
| |
| |
| case 10: |
| return classifier10(data); |
| |
| |
| case 11: |
| return classifier11(data); |
| |
| |
| case 12: |
| return classifier12(data); |
| |
| |
| case 13: |
| return classifier13(data); |
| |
| |
| case 14: |
| return classifier14(data); |
| |
| |
| case 15: |
| return classifier15(data); |
| |
| |
| case 17: |
| return classifier17(data); |
| |
| |
| case 18: |
| return classifier18(data); |
| |
| |
| case 20: |
| return classifier20(data); |
| |
| |
| case 21: |
| return classifier21(data); |
| |
| |
| case 22: |
| return classifier22(data); |
| |
| |
| case 23: |
| return classifier23(data); |
| |
| |
| case 26: |
| return classifier26(data); |
| |
| |
| default: |
| return NoKeyword; |
| } |
| } |
| |
| |
| QString XSLTTokenLookup::toString(NodeName token) |
| { |
| const unsigned short *data = 0; |
| int length = 0; |
| |
| switch(token) |
| { |
| |
| case AnalyzeString: |
| { |
| static const unsigned short staticallyStoredAnalyzeString[] = |
| { |
| 97, 110, 97, 108, 121, 122, 101, 45, 115, 116, 114, 105, 110, 103, 0 |
| }; |
| data = staticallyStoredAnalyzeString; |
| length = 14; |
| break; |
| } |
| |
| case ApplyTemplates: |
| { |
| static const unsigned short staticallyStoredApplyTemplates[] = |
| { |
| 97, 112, 112, 108, 121, 45, 116, 101, 109, 112, 108, 97, 116, 101, 115, 0 |
| }; |
| data = staticallyStoredApplyTemplates; |
| length = 15; |
| break; |
| } |
| |
| case As: |
| { |
| static const unsigned short staticallyStoredAs[] = |
| { |
| 97, 115, 0 |
| }; |
| data = staticallyStoredAs; |
| length = 2; |
| break; |
| } |
| |
| case Attribute: |
| { |
| static const unsigned short staticallyStoredAttribute[] = |
| { |
| 97, 116, 116, 114, 105, 98, 117, 116, 101, 0 |
| }; |
| data = staticallyStoredAttribute; |
| length = 9; |
| break; |
| } |
| |
| case AttributeSet: |
| { |
| static const unsigned short staticallyStoredAttributeSet[] = |
| { |
| 97, 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 0 |
| }; |
| data = staticallyStoredAttributeSet; |
| length = 13; |
| break; |
| } |
| |
| case ByteOrderMark: |
| { |
| static const unsigned short staticallyStoredByteOrderMark[] = |
| { |
| 98, 121, 116, 101, 45, 111, 114, 100, 101, 114, 45, 109, 97, 114, 107, 0 |
| }; |
| data = staticallyStoredByteOrderMark; |
| length = 15; |
| break; |
| } |
| |
| case CallTemplate: |
| { |
| static const unsigned short staticallyStoredCallTemplate[] = |
| { |
| 99, 97, 108, 108, 45, 116, 101, 109, 112, 108, 97, 116, 101, 0 |
| }; |
| data = staticallyStoredCallTemplate; |
| length = 13; |
| break; |
| } |
| |
| case CaseOrder: |
| { |
| static const unsigned short staticallyStoredCaseOrder[] = |
| { |
| 99, 97, 115, 101, 45, 111, 114, 100, 101, 114, 0 |
| }; |
| data = staticallyStoredCaseOrder; |
| length = 10; |
| break; |
| } |
| |
| case CdataSectionElements: |
| { |
| static const unsigned short staticallyStoredCdataSectionElements[] = |
| { |
| 99, 100, 97, 116, 97, 45, 115, 101, 99, 116, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 115, 0 |
| }; |
| data = staticallyStoredCdataSectionElements; |
| length = 22; |
| break; |
| } |
| |
| case Choose: |
| { |
| static const unsigned short staticallyStoredChoose[] = |
| { |
| 99, 104, 111, 111, 115, 101, 0 |
| }; |
| data = staticallyStoredChoose; |
| length = 6; |
| break; |
| } |
| |
| case Collation: |
| { |
| static const unsigned short staticallyStoredCollation[] = |
| { |
| 99, 111, 108, 108, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredCollation; |
| length = 9; |
| break; |
| } |
| |
| case Comment: |
| { |
| static const unsigned short staticallyStoredComment[] = |
| { |
| 99, 111, 109, 109, 101, 110, 116, 0 |
| }; |
| data = staticallyStoredComment; |
| length = 7; |
| break; |
| } |
| |
| case Copy: |
| { |
| static const unsigned short staticallyStoredCopy[] = |
| { |
| 99, 111, 112, 121, 0 |
| }; |
| data = staticallyStoredCopy; |
| length = 4; |
| break; |
| } |
| |
| case CopyNamespaces: |
| { |
| static const unsigned short staticallyStoredCopyNamespaces[] = |
| { |
| 99, 111, 112, 121, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115, 0 |
| }; |
| data = staticallyStoredCopyNamespaces; |
| length = 15; |
| break; |
| } |
| |
| case CopyOf: |
| { |
| static const unsigned short staticallyStoredCopyOf[] = |
| { |
| 99, 111, 112, 121, 45, 111, 102, 0 |
| }; |
| data = staticallyStoredCopyOf; |
| length = 7; |
| break; |
| } |
| |
| case DataType: |
| { |
| static const unsigned short staticallyStoredDataType[] = |
| { |
| 100, 97, 116, 97, 45, 116, 121, 112, 101, 0 |
| }; |
| data = staticallyStoredDataType; |
| length = 9; |
| break; |
| } |
| |
| case DefaultCollation: |
| { |
| static const unsigned short staticallyStoredDefaultCollation[] = |
| { |
| 100, 101, 102, 97, 117, 108, 116, 45, 99, 111, 108, 108, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredDefaultCollation; |
| length = 17; |
| break; |
| } |
| |
| case DefaultValidation: |
| { |
| static const unsigned short staticallyStoredDefaultValidation[] = |
| { |
| 100, 101, 102, 97, 117, 108, 116, 45, 118, 97, 108, 105, 100, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredDefaultValidation; |
| length = 18; |
| break; |
| } |
| |
| case DoctypePublic: |
| { |
| static const unsigned short staticallyStoredDoctypePublic[] = |
| { |
| 100, 111, 99, 116, 121, 112, 101, 45, 112, 117, 98, 108, 105, 99, 0 |
| }; |
| data = staticallyStoredDoctypePublic; |
| length = 14; |
| break; |
| } |
| |
| case DoctypeSystem: |
| { |
| static const unsigned short staticallyStoredDoctypeSystem[] = |
| { |
| 100, 111, 99, 116, 121, 112, 101, 45, 115, 121, 115, 116, 101, 109, 0 |
| }; |
| data = staticallyStoredDoctypeSystem; |
| length = 14; |
| break; |
| } |
| |
| case Document: |
| { |
| static const unsigned short staticallyStoredDocument[] = |
| { |
| 100, 111, 99, 117, 109, 101, 110, 116, 0 |
| }; |
| data = staticallyStoredDocument; |
| length = 8; |
| break; |
| } |
| |
| case Element: |
| { |
| static const unsigned short staticallyStoredElement[] = |
| { |
| 101, 108, 101, 109, 101, 110, 116, 0 |
| }; |
| data = staticallyStoredElement; |
| length = 7; |
| break; |
| } |
| |
| case Elements: |
| { |
| static const unsigned short staticallyStoredElements[] = |
| { |
| 101, 108, 101, 109, 101, 110, 116, 115, 0 |
| }; |
| data = staticallyStoredElements; |
| length = 8; |
| break; |
| } |
| |
| case Encoding: |
| { |
| static const unsigned short staticallyStoredEncoding[] = |
| { |
| 101, 110, 99, 111, 100, 105, 110, 103, 0 |
| }; |
| data = staticallyStoredEncoding; |
| length = 8; |
| break; |
| } |
| |
| case EscapeUriAttributes: |
| { |
| static const unsigned short staticallyStoredEscapeUriAttributes[] = |
| { |
| 101, 115, 99, 97, 112, 101, 45, 117, 114, 105, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 115, 0 |
| }; |
| data = staticallyStoredEscapeUriAttributes; |
| length = 21; |
| break; |
| } |
| |
| case ExcludeResultPrefixes: |
| { |
| static const unsigned short staticallyStoredExcludeResultPrefixes[] = |
| { |
| 101, 120, 99, 108, 117, 100, 101, 45, 114, 101, 115, 117, 108, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0 |
| }; |
| data = staticallyStoredExcludeResultPrefixes; |
| length = 23; |
| break; |
| } |
| |
| case ExtensionElementPrefixes: |
| { |
| static const unsigned short staticallyStoredExtensionElementPrefixes[] = |
| { |
| 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 |
| }; |
| data = staticallyStoredExtensionElementPrefixes; |
| length = 26; |
| break; |
| } |
| |
| case Flags: |
| { |
| static const unsigned short staticallyStoredFlags[] = |
| { |
| 102, 108, 97, 103, 115, 0 |
| }; |
| data = staticallyStoredFlags; |
| length = 5; |
| break; |
| } |
| |
| case ForEach: |
| { |
| static const unsigned short staticallyStoredForEach[] = |
| { |
| 102, 111, 114, 45, 101, 97, 99, 104, 0 |
| }; |
| data = staticallyStoredForEach; |
| length = 8; |
| break; |
| } |
| |
| case Format: |
| { |
| static const unsigned short staticallyStoredFormat[] = |
| { |
| 102, 111, 114, 109, 97, 116, 0 |
| }; |
| data = staticallyStoredFormat; |
| length = 6; |
| break; |
| } |
| |
| case Function: |
| { |
| static const unsigned short staticallyStoredFunction[] = |
| { |
| 102, 117, 110, 99, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredFunction; |
| length = 8; |
| break; |
| } |
| |
| case Href: |
| { |
| static const unsigned short staticallyStoredHref[] = |
| { |
| 104, 114, 101, 102, 0 |
| }; |
| data = staticallyStoredHref; |
| length = 4; |
| break; |
| } |
| |
| case Id: |
| { |
| static const unsigned short staticallyStoredId[] = |
| { |
| 105, 100, 0 |
| }; |
| data = staticallyStoredId; |
| length = 2; |
| break; |
| } |
| |
| case If: |
| { |
| static const unsigned short staticallyStoredIf[] = |
| { |
| 105, 102, 0 |
| }; |
| data = staticallyStoredIf; |
| length = 2; |
| break; |
| } |
| |
| case Import: |
| { |
| static const unsigned short staticallyStoredImport[] = |
| { |
| 105, 109, 112, 111, 114, 116, 0 |
| }; |
| data = staticallyStoredImport; |
| length = 6; |
| break; |
| } |
| |
| case ImportSchema: |
| { |
| static const unsigned short staticallyStoredImportSchema[] = |
| { |
| 105, 109, 112, 111, 114, 116, 45, 115, 99, 104, 101, 109, 97, 0 |
| }; |
| data = staticallyStoredImportSchema; |
| length = 13; |
| break; |
| } |
| |
| case Include: |
| { |
| static const unsigned short staticallyStoredInclude[] = |
| { |
| 105, 110, 99, 108, 117, 100, 101, 0 |
| }; |
| data = staticallyStoredInclude; |
| length = 7; |
| break; |
| } |
| |
| case IncludeContentType: |
| { |
| static const unsigned short staticallyStoredIncludeContentType[] = |
| { |
| 105, 110, 99, 108, 117, 100, 101, 45, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 0 |
| }; |
| data = staticallyStoredIncludeContentType; |
| length = 20; |
| break; |
| } |
| |
| case Indent: |
| { |
| static const unsigned short staticallyStoredIndent[] = |
| { |
| 105, 110, 100, 101, 110, 116, 0 |
| }; |
| data = staticallyStoredIndent; |
| length = 6; |
| break; |
| } |
| |
| case InheritNamespaces: |
| { |
| static const unsigned short staticallyStoredInheritNamespaces[] = |
| { |
| 105, 110, 104, 101, 114, 105, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115, 0 |
| }; |
| data = staticallyStoredInheritNamespaces; |
| length = 18; |
| break; |
| } |
| |
| case InputTypeAnnotations: |
| { |
| static const unsigned short staticallyStoredInputTypeAnnotations[] = |
| { |
| 105, 110, 112, 117, 116, 45, 116, 121, 112, 101, 45, 97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 115, 0 |
| }; |
| data = staticallyStoredInputTypeAnnotations; |
| length = 22; |
| break; |
| } |
| |
| case Key: |
| { |
| static const unsigned short staticallyStoredKey[] = |
| { |
| 107, 101, 121, 0 |
| }; |
| data = staticallyStoredKey; |
| length = 3; |
| break; |
| } |
| |
| case Lang: |
| { |
| static const unsigned short staticallyStoredLang[] = |
| { |
| 108, 97, 110, 103, 0 |
| }; |
| data = staticallyStoredLang; |
| length = 4; |
| break; |
| } |
| |
| case Match: |
| { |
| static const unsigned short staticallyStoredMatch[] = |
| { |
| 109, 97, 116, 99, 104, 0 |
| }; |
| data = staticallyStoredMatch; |
| length = 5; |
| break; |
| } |
| |
| case MatchingSubstring: |
| { |
| static const unsigned short staticallyStoredMatchingSubstring[] = |
| { |
| 109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103, 0 |
| }; |
| data = staticallyStoredMatchingSubstring; |
| length = 18; |
| break; |
| } |
| |
| case MediaType: |
| { |
| static const unsigned short staticallyStoredMediaType[] = |
| { |
| 109, 101, 100, 105, 97, 45, 116, 121, 112, 101, 0 |
| }; |
| data = staticallyStoredMediaType; |
| length = 10; |
| break; |
| } |
| |
| case Message: |
| { |
| static const unsigned short staticallyStoredMessage[] = |
| { |
| 109, 101, 115, 115, 97, 103, 101, 0 |
| }; |
| data = staticallyStoredMessage; |
| length = 7; |
| break; |
| } |
| |
| case Method: |
| { |
| static const unsigned short staticallyStoredMethod[] = |
| { |
| 109, 101, 116, 104, 111, 100, 0 |
| }; |
| data = staticallyStoredMethod; |
| length = 6; |
| break; |
| } |
| |
| case Mode: |
| { |
| static const unsigned short staticallyStoredMode[] = |
| { |
| 109, 111, 100, 101, 0 |
| }; |
| data = staticallyStoredMode; |
| length = 4; |
| break; |
| } |
| |
| case Name: |
| { |
| static const unsigned short staticallyStoredName[] = |
| { |
| 110, 97, 109, 101, 0 |
| }; |
| data = staticallyStoredName; |
| length = 4; |
| break; |
| } |
| |
| case Namespace: |
| { |
| static const unsigned short staticallyStoredNamespace[] = |
| { |
| 110, 97, 109, 101, 115, 112, 97, 99, 101, 0 |
| }; |
| data = staticallyStoredNamespace; |
| length = 9; |
| break; |
| } |
| |
| case NonMatchingSubstring: |
| { |
| static const unsigned short staticallyStoredNonMatchingSubstring[] = |
| { |
| 110, 111, 110, 45, 109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103, 0 |
| }; |
| data = staticallyStoredNonMatchingSubstring; |
| length = 22; |
| break; |
| } |
| |
| case NormalizationForm: |
| { |
| static const unsigned short staticallyStoredNormalizationForm[] = |
| { |
| 110, 111, 114, 109, 97, 108, 105, 122, 97, 116, 105, 111, 110, 45, 102, 111, 114, 109, 0 |
| }; |
| data = staticallyStoredNormalizationForm; |
| length = 18; |
| break; |
| } |
| |
| case OmitXmlDeclaration: |
| { |
| static const unsigned short staticallyStoredOmitXmlDeclaration[] = |
| { |
| 111, 109, 105, 116, 45, 120, 109, 108, 45, 100, 101, 99, 108, 97, 114, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredOmitXmlDeclaration; |
| length = 20; |
| break; |
| } |
| |
| case Order: |
| { |
| static const unsigned short staticallyStoredOrder[] = |
| { |
| 111, 114, 100, 101, 114, 0 |
| }; |
| data = staticallyStoredOrder; |
| length = 5; |
| break; |
| } |
| |
| case Otherwise: |
| { |
| static const unsigned short staticallyStoredOtherwise[] = |
| { |
| 111, 116, 104, 101, 114, 119, 105, 115, 101, 0 |
| }; |
| data = staticallyStoredOtherwise; |
| length = 9; |
| break; |
| } |
| |
| case Output: |
| { |
| static const unsigned short staticallyStoredOutput[] = |
| { |
| 111, 117, 116, 112, 117, 116, 0 |
| }; |
| data = staticallyStoredOutput; |
| length = 6; |
| break; |
| } |
| |
| case OutputVersion: |
| { |
| static const unsigned short staticallyStoredOutputVersion[] = |
| { |
| 111, 117, 116, 112, 117, 116, 45, 118, 101, 114, 115, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredOutputVersion; |
| length = 14; |
| break; |
| } |
| |
| case Override: |
| { |
| static const unsigned short staticallyStoredOverride[] = |
| { |
| 111, 118, 101, 114, 114, 105, 100, 101, 0 |
| }; |
| data = staticallyStoredOverride; |
| length = 8; |
| break; |
| } |
| |
| case Param: |
| { |
| static const unsigned short staticallyStoredParam[] = |
| { |
| 112, 97, 114, 97, 109, 0 |
| }; |
| data = staticallyStoredParam; |
| length = 5; |
| break; |
| } |
| |
| case PerformSort: |
| { |
| static const unsigned short staticallyStoredPerformSort[] = |
| { |
| 112, 101, 114, 102, 111, 114, 109, 45, 115, 111, 114, 116, 0 |
| }; |
| data = staticallyStoredPerformSort; |
| length = 12; |
| break; |
| } |
| |
| case PreserveSpace: |
| { |
| static const unsigned short staticallyStoredPreserveSpace[] = |
| { |
| 112, 114, 101, 115, 101, 114, 118, 101, 45, 115, 112, 97, 99, 101, 0 |
| }; |
| data = staticallyStoredPreserveSpace; |
| length = 14; |
| break; |
| } |
| |
| case Priority: |
| { |
| static const unsigned short staticallyStoredPriority[] = |
| { |
| 112, 114, 105, 111, 114, 105, 116, 121, 0 |
| }; |
| data = staticallyStoredPriority; |
| length = 8; |
| break; |
| } |
| |
| case ProcessingInstruction: |
| { |
| static const unsigned short staticallyStoredProcessingInstruction[] = |
| { |
| 112, 114, 111, 99, 101, 115, 115, 105, 110, 103, 45, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredProcessingInstruction; |
| length = 22; |
| break; |
| } |
| |
| case Regex: |
| { |
| static const unsigned short staticallyStoredRegex[] = |
| { |
| 114, 101, 103, 101, 120, 0 |
| }; |
| data = staticallyStoredRegex; |
| length = 5; |
| break; |
| } |
| |
| case Required: |
| { |
| static const unsigned short staticallyStoredRequired[] = |
| { |
| 114, 101, 113, 117, 105, 114, 101, 100, 0 |
| }; |
| data = staticallyStoredRequired; |
| length = 8; |
| break; |
| } |
| |
| case ResultDocument: |
| { |
| static const unsigned short staticallyStoredResultDocument[] = |
| { |
| 114, 101, 115, 117, 108, 116, 45, 100, 111, 99, 117, 109, 101, 110, 116, 0 |
| }; |
| data = staticallyStoredResultDocument; |
| length = 15; |
| break; |
| } |
| |
| case SchemaLocation: |
| { |
| static const unsigned short staticallyStoredSchemaLocation[] = |
| { |
| 115, 99, 104, 101, 109, 97, 45, 108, 111, 99, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredSchemaLocation; |
| length = 15; |
| break; |
| } |
| |
| case Select: |
| { |
| static const unsigned short staticallyStoredSelect[] = |
| { |
| 115, 101, 108, 101, 99, 116, 0 |
| }; |
| data = staticallyStoredSelect; |
| length = 6; |
| break; |
| } |
| |
| case Separator: |
| { |
| static const unsigned short staticallyStoredSeparator[] = |
| { |
| 115, 101, 112, 97, 114, 97, 116, 111, 114, 0 |
| }; |
| data = staticallyStoredSeparator; |
| length = 9; |
| break; |
| } |
| |
| case Sequence: |
| { |
| static const unsigned short staticallyStoredSequence[] = |
| { |
| 115, 101, 113, 117, 101, 110, 99, 101, 0 |
| }; |
| data = staticallyStoredSequence; |
| length = 8; |
| break; |
| } |
| |
| case Sort: |
| { |
| static const unsigned short staticallyStoredSort[] = |
| { |
| 115, 111, 114, 116, 0 |
| }; |
| data = staticallyStoredSort; |
| length = 4; |
| break; |
| } |
| |
| case Stable: |
| { |
| static const unsigned short staticallyStoredStable[] = |
| { |
| 115, 116, 97, 98, 108, 101, 0 |
| }; |
| data = staticallyStoredStable; |
| length = 6; |
| break; |
| } |
| |
| case Standalone: |
| { |
| static const unsigned short staticallyStoredStandalone[] = |
| { |
| 115, 116, 97, 110, 100, 97, 108, 111, 110, 101, 0 |
| }; |
| data = staticallyStoredStandalone; |
| length = 10; |
| break; |
| } |
| |
| case StripSpace: |
| { |
| static const unsigned short staticallyStoredStripSpace[] = |
| { |
| 115, 116, 114, 105, 112, 45, 115, 112, 97, 99, 101, 0 |
| }; |
| data = staticallyStoredStripSpace; |
| length = 11; |
| break; |
| } |
| |
| case Stylesheet: |
| { |
| static const unsigned short staticallyStoredStylesheet[] = |
| { |
| 115, 116, 121, 108, 101, 115, 104, 101, 101, 116, 0 |
| }; |
| data = staticallyStoredStylesheet; |
| length = 10; |
| break; |
| } |
| |
| case Template: |
| { |
| static const unsigned short staticallyStoredTemplate[] = |
| { |
| 116, 101, 109, 112, 108, 97, 116, 101, 0 |
| }; |
| data = staticallyStoredTemplate; |
| length = 8; |
| break; |
| } |
| |
| case Terminate: |
| { |
| static const unsigned short staticallyStoredTerminate[] = |
| { |
| 116, 101, 114, 109, 105, 110, 97, 116, 101, 0 |
| }; |
| data = staticallyStoredTerminate; |
| length = 9; |
| break; |
| } |
| |
| case Test: |
| { |
| static const unsigned short staticallyStoredTest[] = |
| { |
| 116, 101, 115, 116, 0 |
| }; |
| data = staticallyStoredTest; |
| length = 4; |
| break; |
| } |
| |
| case Text: |
| { |
| static const unsigned short staticallyStoredText[] = |
| { |
| 116, 101, 120, 116, 0 |
| }; |
| data = staticallyStoredText; |
| length = 4; |
| break; |
| } |
| |
| case Transform: |
| { |
| static const unsigned short staticallyStoredTransform[] = |
| { |
| 116, 114, 97, 110, 115, 102, 111, 114, 109, 0 |
| }; |
| data = staticallyStoredTransform; |
| length = 9; |
| break; |
| } |
| |
| case Tunnel: |
| { |
| static const unsigned short staticallyStoredTunnel[] = |
| { |
| 116, 117, 110, 110, 101, 108, 0 |
| }; |
| data = staticallyStoredTunnel; |
| length = 6; |
| break; |
| } |
| |
| case Type: |
| { |
| static const unsigned short staticallyStoredType[] = |
| { |
| 116, 121, 112, 101, 0 |
| }; |
| data = staticallyStoredType; |
| length = 4; |
| break; |
| } |
| |
| case UndeclarePrefixes: |
| { |
| static const unsigned short staticallyStoredUndeclarePrefixes[] = |
| { |
| 117, 110, 100, 101, 99, 108, 97, 114, 101, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0 |
| }; |
| data = staticallyStoredUndeclarePrefixes; |
| length = 18; |
| break; |
| } |
| |
| case Use: |
| { |
| static const unsigned short staticallyStoredUse[] = |
| { |
| 117, 115, 101, 0 |
| }; |
| data = staticallyStoredUse; |
| length = 3; |
| break; |
| } |
| |
| case UseAttributeSets: |
| { |
| static const unsigned short staticallyStoredUseAttributeSets[] = |
| { |
| 117, 115, 101, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 115, 0 |
| }; |
| data = staticallyStoredUseAttributeSets; |
| length = 18; |
| break; |
| } |
| |
| case UseCharacterMaps: |
| { |
| static const unsigned short staticallyStoredUseCharacterMaps[] = |
| { |
| 117, 115, 101, 45, 99, 104, 97, 114, 97, 99, 116, 101, 114, 45, 109, 97, 112, 115, 0 |
| }; |
| data = staticallyStoredUseCharacterMaps; |
| length = 18; |
| break; |
| } |
| |
| case UseWhen: |
| { |
| static const unsigned short staticallyStoredUseWhen[] = |
| { |
| 117, 115, 101, 45, 119, 104, 101, 110, 0 |
| }; |
| data = staticallyStoredUseWhen; |
| length = 8; |
| break; |
| } |
| |
| case Validation: |
| { |
| static const unsigned short staticallyStoredValidation[] = |
| { |
| 118, 97, 108, 105, 100, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredValidation; |
| length = 10; |
| break; |
| } |
| |
| case ValueOf: |
| { |
| static const unsigned short staticallyStoredValueOf[] = |
| { |
| 118, 97, 108, 117, 101, 45, 111, 102, 0 |
| }; |
| data = staticallyStoredValueOf; |
| length = 8; |
| break; |
| } |
| |
| case Variable: |
| { |
| static const unsigned short staticallyStoredVariable[] = |
| { |
| 118, 97, 114, 105, 97, 98, 108, 101, 0 |
| }; |
| data = staticallyStoredVariable; |
| length = 8; |
| break; |
| } |
| |
| case Version: |
| { |
| static const unsigned short staticallyStoredVersion[] = |
| { |
| 118, 101, 114, 115, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredVersion; |
| length = 7; |
| break; |
| } |
| |
| case When: |
| { |
| static const unsigned short staticallyStoredWhen[] = |
| { |
| 119, 104, 101, 110, 0 |
| }; |
| data = staticallyStoredWhen; |
| length = 4; |
| break; |
| } |
| |
| case WithParam: |
| { |
| static const unsigned short staticallyStoredWithParam[] = |
| { |
| 119, 105, 116, 104, 45, 112, 97, 114, 97, 109, 0 |
| }; |
| data = staticallyStoredWithParam; |
| length = 10; |
| break; |
| } |
| |
| case XpathDefaultNamespace: |
| { |
| static const unsigned short staticallyStoredXpathDefaultNamespace[] = |
| { |
| 120, 112, 97, 116, 104, 45, 100, 101, 102, 97, 117, 108, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 0 |
| }; |
| data = staticallyStoredXpathDefaultNamespace; |
| length = 23; |
| break; |
| } |
| |
| default: |
| /* It's either the default token, or an undefined enum |
| * value. We silence a compiler warning, and return the |
| * empty string. */ |
| ; |
| } |
| |
| union |
| { |
| const unsigned short *data; |
| const QChar *asQChar; |
| } converter; |
| converter.data = data; |
| |
| return QString::fromRawData(converter.asQChar, length); |
| } |
| |
| QT_END_NAMESPACE |
| |