| /**************************************************************************** | |
| ** | |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
| ** All rights reserved. | |
| ** Contact: Nokia Corporation (qt-info@nokia.com) | |
| ** | |
| ** This file is part of the QtXmlPatterns module of the Qt Toolkit. | |
| ** | |
| ** $QT_BEGIN_LICENSE:LGPL$ | |
| ** GNU Lesser General Public License Usage | |
| ** This file may be used under the terms of the GNU Lesser General Public | |
| ** License version 2.1 as published by the Free Software Foundation and | |
| ** appearing in the file LICENSE.LGPL included in the packaging of this | |
| ** file. Please review the following information to ensure the GNU Lesser | |
| ** General Public License version 2.1 requirements will be met: | |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. | |
| ** | |
| ** In addition, as a special exception, Nokia gives you certain additional | |
| ** rights. These rights are described in the Nokia Qt LGPL Exception | |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. | |
| ** | |
| ** GNU General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU General | |
| ** Public License version 3.0 as published by the Free Software Foundation | |
| ** and appearing in the file LICENSE.GPL included in the packaging of this | |
| ** file. Please review the following information to ensure the GNU General | |
| ** Public License version 3.0 requirements will be met: | |
| ** http://www.gnu.org/copyleft/gpl.html. | |
| ** | |
| ** Other Usage | |
| ** Alternatively, this file may be used in accordance with the terms and | |
| ** conditions contained in a signed written agreement between you and Nokia. | |
| ** | |
| ** | |
| ** | |
| ** | |
| ** | |
| ** $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] == 97) | |
| { | |
| if(data[1] == 115) | |
| return As; | |
| } | |
| else if (data[0] == 105) | |
| { | |
| if (data[1] == 100) | |
| { | |
| return Id; | |
| } | |
| else if (data[1] == 102) | |
| { | |
| return If; | |
| } | |
| } | |
| return NoKeyword; | |
| } | |
| XSLTTokenLookup::NodeName XSLTTokenLookup::classifier3(const QChar *data) | |
| { | |
| if (data[0] == 107) | |
| { | |
| static const unsigned short string[] = | |
| { | |
| 101, 121 | |
| }; | |
| if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0) | |
| return Key; | |
| } | |
| else if (data[0] == 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] == 99) | |
| { | |
| static const unsigned short string[] = | |
| { | |
| 111, 112, 121 | |
| }; | |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) | |
| return Copy; | |
| } | |
| else if (data[0] == 104) | |
| { | |
| static const unsigned short string[] = | |
| { | |
| 114, 101, 102 | |
| }; | |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) | |
| return Href; | |
| } | |
| else if (data[0] == 108) | |
| { | |
| static const unsigned short string[] = | |
| { | |
| 97, 110, 103 | |
| }; | |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) | |
| return Lang; | |
| } | |
| else if (data[0] == 109) | |
| { | |
| static const unsigned short string[] = | |
| { | |
| 111, 100, 101 | |
| }; | |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) | |
| return Mode; | |
| } | |
| else if (data[0] == 110) | |
| { | |
| static const unsigned short string[] = | |
| { | |
| 97, 109, 101 | |
| }; | |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) | |
| return Name; | |
| } | |
| else if (data[0] == 115) | |
| { | |
| static const unsigned short string[] = | |
| { | |
| 111, 114, 116 | |
| }; | |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) | |
| return Sort; | |
| } | |
| else if (data[0] == 116) | |
| { | |
| if (data[1] == 101) | |
| { | |
| if (data[2] == 115) | |
| { | |
| if(data[3] == 116) | |
| return Test; | |
| } | |
| else if (data[2] == 120) | |
| { | |
| if(data[3] == 116) | |
| return Text; | |
| } | |
| } | |
| else if (data[1] == 121) | |
| { | |
| static const unsigned short string[] = | |
| { | |
| 112, 101 | |
| }; | |
| if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0) | |
| return Type; | |
| } | |
| } | |
| else if (data[0] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 105) | |
| { | |
| if (data[1] == 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] == 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] == 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] == 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] == 115) | |
| { | |
| if (data[1] == 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] == 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] == 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] == 99) | |
| { | |
| if (data[1] == 111) | |
| { | |
| if (data[2] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 101) | |
| { | |
| if (data[1] == 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] == 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] == 102) | |
| { | |
| if (data[1] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 118) | |
| { | |
| if (data[1] == 97) | |
| { | |
| if (data[2] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 116) | |
| { | |
| if (data[1] == 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] == 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] == 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] == 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] == 115) | |
| { | |
| if (data[1] == 116) | |
| { | |
| if (data[2] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 100) | |
| { | |
| if (data[1] == 111) | |
| { | |
| if (data[2] == 99) | |
| { | |
| if (data[3] == 116) | |
| { | |
| if (data[4] == 121) | |
| { | |
| if (data[5] == 112) | |
| { | |
| if (data[6] == 101) | |
| { | |
| if (data[7] == 45) | |
| { | |
| if (data[8] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 117) | |
| { | |
| if (data[1] == 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] == 115) | |
| { | |
| if (data[2] == 101) | |
| { | |
| if (data[3] == 45) | |
| { | |
| if (data[4] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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] == 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 | |