| /**************************************************************************** |
| ** |
| ** 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 qautomaton2cpp.xsl. */ |
| |
| #include "qxsdschematoken_p.h" |
| |
| QT_BEGIN_NAMESPACE |
| |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier2(const QChar *data) |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 105, 100 |
| }; |
| if(memcmp(&data[0], &string, sizeof(QChar) * 2) == 0) |
| |
| |
| return Id; |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier3(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| if (data[1].unicode() == 108) |
| |
| |
| { |
| |
| if (data[2].unicode() == 108) |
| |
| |
| return All; |
| |
| } |
| |
| else if (data[1].unicode() == 110) |
| |
| |
| { |
| |
| if (data[2].unicode() == 121) |
| |
| |
| return Any; |
| |
| } |
| |
| |
| } |
| |
| else 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() == 114) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 102 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0) |
| |
| |
| return Ref; |
| |
| } |
| |
| 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; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier4(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 98) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 115, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) |
| |
| |
| return Base; |
| |
| } |
| |
| else if (data[0].unicode() == 102) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 114, 109 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) |
| |
| |
| return Form; |
| |
| } |
| |
| else if (data[0].unicode() == 108) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 105, 115, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0) |
| |
| |
| return List; |
| |
| } |
| |
| 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() == 116) |
| |
| |
| { |
| if (data[1].unicode() == 101) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 115, 116 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0) |
| |
| |
| return Test; |
| |
| } |
| |
| else if (data[1].unicode() == 121) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 112, 101 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0) |
| |
| |
| return Type; |
| |
| } |
| |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier5(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 98) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 108, 111, 99, 107 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Block; |
| |
| } |
| |
| else if (data[0].unicode() == 102) |
| |
| |
| { |
| if (data[1].unicode() == 105) |
| |
| |
| { |
| if (data[2].unicode() == 101) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 108, 100 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 2) == 0) |
| |
| |
| return Field; |
| |
| } |
| |
| else if (data[2].unicode() == 110) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 108 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 2) == 0) |
| |
| |
| return Final; |
| |
| } |
| |
| else if (data[2].unicode() == 120) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 100 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 2) == 0) |
| |
| |
| return Fixed; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 103) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 114, 111, 117, 112 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Group; |
| |
| } |
| |
| else if (data[0].unicode() == 109) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 105, 120, 101, 100 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Mixed; |
| |
| } |
| |
| else if (data[0].unicode() == 114) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 102, 101, 114 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Refer; |
| |
| } |
| |
| else if (data[0].unicode() == 117) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Union; |
| |
| } |
| |
| else if (data[0].unicode() == 118) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 108, 117, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Value; |
| |
| } |
| |
| else if (data[0].unicode() == 120) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 112, 97, 116, 104 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Xpath; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier6(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 115, 115, 101, 114, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Assert; |
| |
| } |
| |
| else if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 104, 111, 105, 99, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Choice; |
| |
| } |
| |
| else if (data[0].unicode() == 105) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 109, 112, 111, 114, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Import; |
| |
| } |
| |
| else if (data[0].unicode() == 107) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 121, 114, 101, 102 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Keyref; |
| |
| } |
| |
| else if (data[0].unicode() == 108) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 110, 103, 116, 104 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Length; |
| |
| } |
| |
| else if (data[0].unicode() == 112) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 117, 98, 108, 105, 99 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Public; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| if (data[1].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 104, 101, 109, 97 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Schema; |
| |
| } |
| |
| else if (data[1].unicode() == 111) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 117, 114, 99, 101 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Source; |
| |
| } |
| |
| else if (data[1].unicode() == 121) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 115, 116, 101, 109 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return System; |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 117) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 105, 113, 117, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Unique; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier7(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 112, 112, 105, 110, 102, 111 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Appinfo; |
| |
| } |
| |
| else if (data[0].unicode() == 100) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 102, 97, 117, 108, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Default; |
| |
| } |
| |
| 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() == 112) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 116, 116, 101, 114, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Pattern; |
| |
| } |
| |
| else if (data[0].unicode() == 114) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 112, 108, 97, 99, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Replace; |
| |
| } |
| |
| 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; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier8(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 98, 115, 116, 114, 97, 99, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Abstract; |
| |
| } |
| |
| else if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 108, 108, 97, 112, 115, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Collapse; |
| |
| } |
| |
| else if (data[0].unicode() == 105) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 116, 101, 109, 84, 121, 112, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return ItemType; |
| |
| } |
| |
| else if (data[0].unicode() == 110) |
| |
| |
| { |
| if (data[1].unicode() == 105) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 108, 108, 97, 98, 108, 101 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0) |
| |
| |
| return Nillable; |
| |
| } |
| |
| else if (data[1].unicode() == 111) |
| |
| |
| { |
| if (data[2].unicode() == 116) |
| |
| |
| { |
| if (data[3].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[4], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return Notation; |
| |
| } |
| |
| else if (data[3].unicode() == 81) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 78, 97, 109, 101 |
| }; |
| if(memcmp(&data[4], &string, sizeof(QChar) * 4) == 0) |
| |
| |
| return NotQName; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| 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, 101, 115, 101, 114, 118, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Preserve; |
| |
| } |
| |
| else if (data[0].unicode() == 114) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 100, 101, 102, 105, 110, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Redefine; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| if (data[1].unicode() == 101) |
| |
| |
| { |
| if (data[2].unicode() == 108) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 99, 116, 111, 114 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Selector; |
| |
| } |
| |
| else if (data[2].unicode() == 113) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 117, 101, 110, 99, 101 |
| }; |
| if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return Sequence; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 120) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 109, 108, 58, 108, 97, 110, 103 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return XmlLanguage; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier9(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| if (data[1].unicode() == 115) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 115, 101, 114, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Assertion; |
| |
| } |
| |
| else if (data[1].unicode() == 116) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 116, 114, 105, 98, 117, 116, 101 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0) |
| |
| |
| return Attribute; |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 101) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 120, 116, 101, 110, 115, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return Extension; |
| |
| } |
| |
| else if (data[0].unicode() == 109) |
| |
| |
| { |
| if (data[1].unicode() == 97) |
| |
| |
| { |
| if (data[2].unicode() == 120) |
| |
| |
| { |
| if (data[3].unicode() == 76) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 110, 103, 116, 104 |
| }; |
| if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return MaxLength; |
| |
| } |
| |
| else if (data[3].unicode() == 79) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 99, 99, 117, 114, 115 |
| }; |
| if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return MaxOccurs; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| else if (data[1].unicode() == 105) |
| |
| |
| { |
| if (data[2].unicode() == 110) |
| |
| |
| { |
| if (data[3].unicode() == 76) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 110, 103, 116, 104 |
| }; |
| if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return MinLength; |
| |
| } |
| |
| else if (data[3].unicode() == 79) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 99, 99, 117, 114, 115 |
| }; |
| if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0) |
| |
| |
| return MinOccurs; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| 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; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier10(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 110, 111, 116, 97, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0) |
| |
| |
| return Annotation; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 105, 109, 112, 108, 101, 84, 121, 112, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0) |
| |
| |
| return SimpleType; |
| |
| } |
| |
| else if (data[0].unicode() == 119) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 104, 105, 116, 101, 83, 112, 97, 99, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0) |
| |
| |
| return WhiteSpace; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier11(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 108, 116, 101, 114, 110, 97, 116, 105, 118, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0) |
| |
| |
| return Alternative; |
| |
| } |
| |
| else if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 109, 112, 108, 101, 120, 84, 121, 112, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0) |
| |
| |
| return ComplexType; |
| |
| } |
| |
| else if (data[0].unicode() == 101) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 117, 109, 101, 114, 97, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0) |
| |
| |
| return Enumeration; |
| |
| } |
| |
| else if (data[0].unicode() == 109) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 109, 98, 101, 114, 84, 121, 112, 101, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0) |
| |
| |
| return MemberTypes; |
| |
| } |
| |
| else if (data[0].unicode() == 111) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 112, 101, 110, 67, 111, 110, 116, 101, 110, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0) |
| |
| |
| return OpenContent; |
| |
| } |
| |
| else if (data[0].unicode() == 114) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 115, 116, 114, 105, 99, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0) |
| |
| |
| return Restriction; |
| |
| } |
| |
| else if (data[0].unicode() == 116) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 116, 97, 108, 68, 105, 103, 105, 116, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0) |
| |
| |
| return TotalDigits; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier12(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 121, 65, 116, 116, 114, 105, 98, 117, 116, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0) |
| |
| |
| return AnyAttribute; |
| |
| } |
| |
| else if (data[0].unicode() == 98) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 108, 111, 99, 107, 68, 101, 102, 97, 117, 108, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0) |
| |
| |
| return BlockDefault; |
| |
| } |
| |
| else if (data[0].unicode() == 102) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 105, 110, 97, 108, 68, 101, 102, 97, 117, 108, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0) |
| |
| |
| return FinalDefault; |
| |
| } |
| |
| else if (data[0].unicode() == 109) |
| |
| |
| { |
| if (data[1].unicode() == 97) |
| |
| |
| { |
| if (data[2].unicode() == 120) |
| |
| |
| { |
| if (data[3].unicode() == 69) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 120, 99, 108, 117, 115, 105, 118, 101 |
| }; |
| if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return MaxExclusive; |
| |
| } |
| |
| else if (data[3].unicode() == 73) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 99, 108, 117, 115, 105, 118, 101 |
| }; |
| if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return MaxInclusive; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| else if (data[1].unicode() == 105) |
| |
| |
| { |
| if (data[2].unicode() == 110) |
| |
| |
| { |
| if (data[3].unicode() == 69) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 120, 99, 108, 117, 115, 105, 118, 101 |
| }; |
| if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return MinExclusive; |
| |
| } |
| |
| else if (data[3].unicode() == 73) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 110, 99, 108, 117, 115, 105, 118, 101 |
| }; |
| if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0) |
| |
| |
| return MinInclusive; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 110) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0) |
| |
| |
| return NotNamespace; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier13(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 100) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0) |
| |
| |
| return Documentation; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 105, 109, 112, 108, 101, 67, 111, 110, 116, 101, 110, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0) |
| |
| |
| return SimpleContent; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier14(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 97) |
| |
| |
| { |
| if (data[1].unicode() == 112) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 112, 108, 105, 101, 115, 84, 111, 69, 109, 112, 116, 121 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 12) == 0) |
| |
| |
| return AppliesToEmpty; |
| |
| } |
| |
| else if (data[1].unicode() == 116) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 116, 114, 105, 98, 117, 116, 101, 71, 114, 111, 117, 112 |
| }; |
| if(memcmp(&data[2], &string, sizeof(QChar) * 12) == 0) |
| |
| |
| return AttributeGroup; |
| |
| } |
| |
| |
| } |
| |
| else if (data[0].unicode() == 99) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 111, 109, 112, 108, 101, 120, 67, 111, 110, 116, 101, 110, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0) |
| |
| |
| return ComplexContent; |
| |
| } |
| |
| else if (data[0].unicode() == 102) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 114, 97, 99, 116, 105, 111, 110, 68, 105, 103, 105, 116, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0) |
| |
| |
| return FractionDigits; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 99, 104, 101, 109, 97, 76, 111, 99, 97, 116, 105, 111, 110 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0) |
| |
| |
| return SchemaLocation; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier15(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 112) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 114, 111, 99, 101, 115, 115, 67, 111, 110, 116, 101, 110, 116, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0) |
| |
| |
| return ProcessContents; |
| |
| } |
| |
| else if (data[0].unicode() == 116) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 114, 103, 101, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0) |
| |
| |
| return TargetNamespace; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier17(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 100) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 16) == 0) |
| |
| |
| return DefaultAttributes; |
| |
| } |
| |
| else if (data[0].unicode() == 115) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 117, 98, 115, 116, 105, 116, 117, 116, 105, 111, 110, 71, 114, 111, 117, 112 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 16) == 0) |
| |
| |
| return SubstitutionGroup; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier18(const QChar *data) |
| |
| { |
| if (data[0].unicode() == 100) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 101, 102, 97, 117, 108, 116, 79, 112, 101, 110, 67, 111, 110, 116, 101, 110, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0) |
| |
| |
| return DefaultOpenContent; |
| |
| } |
| |
| else if (data[0].unicode() == 101) |
| |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 108, 101, 109, 101, 110, 116, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116 |
| }; |
| if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0) |
| |
| |
| return ElementFormDefault; |
| |
| } |
| |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier20(const QChar *data) |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 97, 116, 116, 114, 105, 98, 117, 116, 101, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116 |
| }; |
| if(memcmp(&data[0], &string, sizeof(QChar) * 20) == 0) |
| |
| |
| return AttributeFormDefault; |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier21(const QChar *data) |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 120, 112, 97, 116, 104, 68, 101, 102, 97, 117, 108, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101 |
| }; |
| if(memcmp(&data[0], &string, sizeof(QChar) * 21) == 0) |
| |
| |
| return XPathDefaultNamespace; |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier22(const QChar *data) |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 100, 101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 65, 112, 112, 108, 121 |
| }; |
| if(memcmp(&data[0], &string, sizeof(QChar) * 22) == 0) |
| |
| |
| return DefaultAttributesApply; |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::classifier32(const QChar *data) |
| |
| { |
| |
| static const unsigned short string[] = |
| { |
| 104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 119, 51, 46, 111, 114, 103, 47, 50, 48, 48, 49, 47, 88, 77, 76, 83, 99, 104, 101, 109, 97 |
| }; |
| if(memcmp(&data[0], &string, sizeof(QChar) * 32) == 0) |
| |
| |
| return XML_NS_SCHEMA_URI; |
| |
| |
| return NoKeyword; |
| } |
| XsdSchemaToken::NodeName XsdSchemaToken::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 32: |
| return classifier32(data); |
| |
| |
| default: |
| return NoKeyword; |
| } |
| } |
| |
| |
| QString XsdSchemaToken::toString(NodeName token) |
| { |
| const unsigned short *data = 0; |
| int length = 0; |
| |
| switch(token) |
| { |
| |
| case Abstract: |
| { |
| static const unsigned short staticallyStoredAbstract[] = |
| { |
| 97, 98, 115, 116, 114, 97, 99, 116, 0 |
| }; |
| data = staticallyStoredAbstract; |
| length = 8; |
| break; |
| } |
| |
| case All: |
| { |
| static const unsigned short staticallyStoredAll[] = |
| { |
| 97, 108, 108, 0 |
| }; |
| data = staticallyStoredAll; |
| length = 3; |
| break; |
| } |
| |
| case Alternative: |
| { |
| static const unsigned short staticallyStoredAlternative[] = |
| { |
| 97, 108, 116, 101, 114, 110, 97, 116, 105, 118, 101, 0 |
| }; |
| data = staticallyStoredAlternative; |
| length = 11; |
| break; |
| } |
| |
| case Annotation: |
| { |
| static const unsigned short staticallyStoredAnnotation[] = |
| { |
| 97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredAnnotation; |
| length = 10; |
| break; |
| } |
| |
| case Any: |
| { |
| static const unsigned short staticallyStoredAny[] = |
| { |
| 97, 110, 121, 0 |
| }; |
| data = staticallyStoredAny; |
| length = 3; |
| break; |
| } |
| |
| case AnyAttribute: |
| { |
| static const unsigned short staticallyStoredAnyAttribute[] = |
| { |
| 97, 110, 121, 65, 116, 116, 114, 105, 98, 117, 116, 101, 0 |
| }; |
| data = staticallyStoredAnyAttribute; |
| length = 12; |
| break; |
| } |
| |
| case Appinfo: |
| { |
| static const unsigned short staticallyStoredAppinfo[] = |
| { |
| 97, 112, 112, 105, 110, 102, 111, 0 |
| }; |
| data = staticallyStoredAppinfo; |
| length = 7; |
| break; |
| } |
| |
| case AppliesToEmpty: |
| { |
| static const unsigned short staticallyStoredAppliesToEmpty[] = |
| { |
| 97, 112, 112, 108, 105, 101, 115, 84, 111, 69, 109, 112, 116, 121, 0 |
| }; |
| data = staticallyStoredAppliesToEmpty; |
| length = 14; |
| break; |
| } |
| |
| case Assert: |
| { |
| static const unsigned short staticallyStoredAssert[] = |
| { |
| 97, 115, 115, 101, 114, 116, 0 |
| }; |
| data = staticallyStoredAssert; |
| length = 6; |
| break; |
| } |
| |
| case Assertion: |
| { |
| static const unsigned short staticallyStoredAssertion[] = |
| { |
| 97, 115, 115, 101, 114, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredAssertion; |
| length = 9; |
| break; |
| } |
| |
| case Attribute: |
| { |
| static const unsigned short staticallyStoredAttribute[] = |
| { |
| 97, 116, 116, 114, 105, 98, 117, 116, 101, 0 |
| }; |
| data = staticallyStoredAttribute; |
| length = 9; |
| break; |
| } |
| |
| case AttributeFormDefault: |
| { |
| static const unsigned short staticallyStoredAttributeFormDefault[] = |
| { |
| 97, 116, 116, 114, 105, 98, 117, 116, 101, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116, 0 |
| }; |
| data = staticallyStoredAttributeFormDefault; |
| length = 20; |
| break; |
| } |
| |
| case AttributeGroup: |
| { |
| static const unsigned short staticallyStoredAttributeGroup[] = |
| { |
| 97, 116, 116, 114, 105, 98, 117, 116, 101, 71, 114, 111, 117, 112, 0 |
| }; |
| data = staticallyStoredAttributeGroup; |
| length = 14; |
| break; |
| } |
| |
| case Base: |
| { |
| static const unsigned short staticallyStoredBase[] = |
| { |
| 98, 97, 115, 101, 0 |
| }; |
| data = staticallyStoredBase; |
| length = 4; |
| break; |
| } |
| |
| case Block: |
| { |
| static const unsigned short staticallyStoredBlock[] = |
| { |
| 98, 108, 111, 99, 107, 0 |
| }; |
| data = staticallyStoredBlock; |
| length = 5; |
| break; |
| } |
| |
| case BlockDefault: |
| { |
| static const unsigned short staticallyStoredBlockDefault[] = |
| { |
| 98, 108, 111, 99, 107, 68, 101, 102, 97, 117, 108, 116, 0 |
| }; |
| data = staticallyStoredBlockDefault; |
| length = 12; |
| break; |
| } |
| |
| case Choice: |
| { |
| static const unsigned short staticallyStoredChoice[] = |
| { |
| 99, 104, 111, 105, 99, 101, 0 |
| }; |
| data = staticallyStoredChoice; |
| length = 6; |
| break; |
| } |
| |
| case Collapse: |
| { |
| static const unsigned short staticallyStoredCollapse[] = |
| { |
| 99, 111, 108, 108, 97, 112, 115, 101, 0 |
| }; |
| data = staticallyStoredCollapse; |
| length = 8; |
| break; |
| } |
| |
| case ComplexContent: |
| { |
| static const unsigned short staticallyStoredComplexContent[] = |
| { |
| 99, 111, 109, 112, 108, 101, 120, 67, 111, 110, 116, 101, 110, 116, 0 |
| }; |
| data = staticallyStoredComplexContent; |
| length = 14; |
| break; |
| } |
| |
| case ComplexType: |
| { |
| static const unsigned short staticallyStoredComplexType[] = |
| { |
| 99, 111, 109, 112, 108, 101, 120, 84, 121, 112, 101, 0 |
| }; |
| data = staticallyStoredComplexType; |
| length = 11; |
| break; |
| } |
| |
| case Default: |
| { |
| static const unsigned short staticallyStoredDefault[] = |
| { |
| 100, 101, 102, 97, 117, 108, 116, 0 |
| }; |
| data = staticallyStoredDefault; |
| length = 7; |
| break; |
| } |
| |
| case DefaultAttributes: |
| { |
| static const unsigned short staticallyStoredDefaultAttributes[] = |
| { |
| 100, 101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 0 |
| }; |
| data = staticallyStoredDefaultAttributes; |
| length = 17; |
| break; |
| } |
| |
| case DefaultAttributesApply: |
| { |
| static const unsigned short staticallyStoredDefaultAttributesApply[] = |
| { |
| 100, 101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 65, 112, 112, 108, 121, 0 |
| }; |
| data = staticallyStoredDefaultAttributesApply; |
| length = 22; |
| break; |
| } |
| |
| case DefaultOpenContent: |
| { |
| static const unsigned short staticallyStoredDefaultOpenContent[] = |
| { |
| 100, 101, 102, 97, 117, 108, 116, 79, 112, 101, 110, 67, 111, 110, 116, 101, 110, 116, 0 |
| }; |
| data = staticallyStoredDefaultOpenContent; |
| length = 18; |
| break; |
| } |
| |
| case Documentation: |
| { |
| static const unsigned short staticallyStoredDocumentation[] = |
| { |
| 100, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredDocumentation; |
| length = 13; |
| break; |
| } |
| |
| case Element: |
| { |
| static const unsigned short staticallyStoredElement[] = |
| { |
| 101, 108, 101, 109, 101, 110, 116, 0 |
| }; |
| data = staticallyStoredElement; |
| length = 7; |
| break; |
| } |
| |
| case ElementFormDefault: |
| { |
| static const unsigned short staticallyStoredElementFormDefault[] = |
| { |
| 101, 108, 101, 109, 101, 110, 116, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116, 0 |
| }; |
| data = staticallyStoredElementFormDefault; |
| length = 18; |
| break; |
| } |
| |
| case Enumeration: |
| { |
| static const unsigned short staticallyStoredEnumeration[] = |
| { |
| 101, 110, 117, 109, 101, 114, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredEnumeration; |
| length = 11; |
| break; |
| } |
| |
| case Extension: |
| { |
| static const unsigned short staticallyStoredExtension[] = |
| { |
| 101, 120, 116, 101, 110, 115, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredExtension; |
| length = 9; |
| break; |
| } |
| |
| case Field: |
| { |
| static const unsigned short staticallyStoredField[] = |
| { |
| 102, 105, 101, 108, 100, 0 |
| }; |
| data = staticallyStoredField; |
| length = 5; |
| break; |
| } |
| |
| case Final: |
| { |
| static const unsigned short staticallyStoredFinal[] = |
| { |
| 102, 105, 110, 97, 108, 0 |
| }; |
| data = staticallyStoredFinal; |
| length = 5; |
| break; |
| } |
| |
| case FinalDefault: |
| { |
| static const unsigned short staticallyStoredFinalDefault[] = |
| { |
| 102, 105, 110, 97, 108, 68, 101, 102, 97, 117, 108, 116, 0 |
| }; |
| data = staticallyStoredFinalDefault; |
| length = 12; |
| break; |
| } |
| |
| case Fixed: |
| { |
| static const unsigned short staticallyStoredFixed[] = |
| { |
| 102, 105, 120, 101, 100, 0 |
| }; |
| data = staticallyStoredFixed; |
| length = 5; |
| break; |
| } |
| |
| case Form: |
| { |
| static const unsigned short staticallyStoredForm[] = |
| { |
| 102, 111, 114, 109, 0 |
| }; |
| data = staticallyStoredForm; |
| length = 4; |
| break; |
| } |
| |
| case FractionDigits: |
| { |
| static const unsigned short staticallyStoredFractionDigits[] = |
| { |
| 102, 114, 97, 99, 116, 105, 111, 110, 68, 105, 103, 105, 116, 115, 0 |
| }; |
| data = staticallyStoredFractionDigits; |
| length = 14; |
| break; |
| } |
| |
| case Group: |
| { |
| static const unsigned short staticallyStoredGroup[] = |
| { |
| 103, 114, 111, 117, 112, 0 |
| }; |
| data = staticallyStoredGroup; |
| length = 5; |
| break; |
| } |
| |
| case Id: |
| { |
| static const unsigned short staticallyStoredId[] = |
| { |
| 105, 100, 0 |
| }; |
| data = staticallyStoredId; |
| length = 2; |
| break; |
| } |
| |
| case Import: |
| { |
| static const unsigned short staticallyStoredImport[] = |
| { |
| 105, 109, 112, 111, 114, 116, 0 |
| }; |
| data = staticallyStoredImport; |
| length = 6; |
| break; |
| } |
| |
| case Include: |
| { |
| static const unsigned short staticallyStoredInclude[] = |
| { |
| 105, 110, 99, 108, 117, 100, 101, 0 |
| }; |
| data = staticallyStoredInclude; |
| length = 7; |
| break; |
| } |
| |
| case ItemType: |
| { |
| static const unsigned short staticallyStoredItemType[] = |
| { |
| 105, 116, 101, 109, 84, 121, 112, 101, 0 |
| }; |
| data = staticallyStoredItemType; |
| length = 8; |
| break; |
| } |
| |
| case Key: |
| { |
| static const unsigned short staticallyStoredKey[] = |
| { |
| 107, 101, 121, 0 |
| }; |
| data = staticallyStoredKey; |
| length = 3; |
| break; |
| } |
| |
| case Keyref: |
| { |
| static const unsigned short staticallyStoredKeyref[] = |
| { |
| 107, 101, 121, 114, 101, 102, 0 |
| }; |
| data = staticallyStoredKeyref; |
| length = 6; |
| break; |
| } |
| |
| case Length: |
| { |
| static const unsigned short staticallyStoredLength[] = |
| { |
| 108, 101, 110, 103, 116, 104, 0 |
| }; |
| data = staticallyStoredLength; |
| length = 6; |
| break; |
| } |
| |
| case List: |
| { |
| static const unsigned short staticallyStoredList[] = |
| { |
| 108, 105, 115, 116, 0 |
| }; |
| data = staticallyStoredList; |
| length = 4; |
| break; |
| } |
| |
| case MaxExclusive: |
| { |
| static const unsigned short staticallyStoredMaxExclusive[] = |
| { |
| 109, 97, 120, 69, 120, 99, 108, 117, 115, 105, 118, 101, 0 |
| }; |
| data = staticallyStoredMaxExclusive; |
| length = 12; |
| break; |
| } |
| |
| case MaxInclusive: |
| { |
| static const unsigned short staticallyStoredMaxInclusive[] = |
| { |
| 109, 97, 120, 73, 110, 99, 108, 117, 115, 105, 118, 101, 0 |
| }; |
| data = staticallyStoredMaxInclusive; |
| length = 12; |
| break; |
| } |
| |
| case MaxLength: |
| { |
| static const unsigned short staticallyStoredMaxLength[] = |
| { |
| 109, 97, 120, 76, 101, 110, 103, 116, 104, 0 |
| }; |
| data = staticallyStoredMaxLength; |
| length = 9; |
| break; |
| } |
| |
| case MaxOccurs: |
| { |
| static const unsigned short staticallyStoredMaxOccurs[] = |
| { |
| 109, 97, 120, 79, 99, 99, 117, 114, 115, 0 |
| }; |
| data = staticallyStoredMaxOccurs; |
| length = 9; |
| break; |
| } |
| |
| case MemberTypes: |
| { |
| static const unsigned short staticallyStoredMemberTypes[] = |
| { |
| 109, 101, 109, 98, 101, 114, 84, 121, 112, 101, 115, 0 |
| }; |
| data = staticallyStoredMemberTypes; |
| length = 11; |
| break; |
| } |
| |
| case MinExclusive: |
| { |
| static const unsigned short staticallyStoredMinExclusive[] = |
| { |
| 109, 105, 110, 69, 120, 99, 108, 117, 115, 105, 118, 101, 0 |
| }; |
| data = staticallyStoredMinExclusive; |
| length = 12; |
| break; |
| } |
| |
| case MinInclusive: |
| { |
| static const unsigned short staticallyStoredMinInclusive[] = |
| { |
| 109, 105, 110, 73, 110, 99, 108, 117, 115, 105, 118, 101, 0 |
| }; |
| data = staticallyStoredMinInclusive; |
| length = 12; |
| break; |
| } |
| |
| case MinLength: |
| { |
| static const unsigned short staticallyStoredMinLength[] = |
| { |
| 109, 105, 110, 76, 101, 110, 103, 116, 104, 0 |
| }; |
| data = staticallyStoredMinLength; |
| length = 9; |
| break; |
| } |
| |
| case MinOccurs: |
| { |
| static const unsigned short staticallyStoredMinOccurs[] = |
| { |
| 109, 105, 110, 79, 99, 99, 117, 114, 115, 0 |
| }; |
| data = staticallyStoredMinOccurs; |
| length = 9; |
| break; |
| } |
| |
| case Mixed: |
| { |
| static const unsigned short staticallyStoredMixed[] = |
| { |
| 109, 105, 120, 101, 100, 0 |
| }; |
| data = staticallyStoredMixed; |
| length = 5; |
| 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 Nillable: |
| { |
| static const unsigned short staticallyStoredNillable[] = |
| { |
| 110, 105, 108, 108, 97, 98, 108, 101, 0 |
| }; |
| data = staticallyStoredNillable; |
| length = 8; |
| break; |
| } |
| |
| case NotNamespace: |
| { |
| static const unsigned short staticallyStoredNotNamespace[] = |
| { |
| 110, 111, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101, 0 |
| }; |
| data = staticallyStoredNotNamespace; |
| length = 12; |
| break; |
| } |
| |
| case NotQName: |
| { |
| static const unsigned short staticallyStoredNotQName[] = |
| { |
| 110, 111, 116, 81, 78, 97, 109, 101, 0 |
| }; |
| data = staticallyStoredNotQName; |
| length = 8; |
| break; |
| } |
| |
| case Notation: |
| { |
| static const unsigned short staticallyStoredNotation[] = |
| { |
| 110, 111, 116, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredNotation; |
| length = 8; |
| break; |
| } |
| |
| case OpenContent: |
| { |
| static const unsigned short staticallyStoredOpenContent[] = |
| { |
| 111, 112, 101, 110, 67, 111, 110, 116, 101, 110, 116, 0 |
| }; |
| data = staticallyStoredOpenContent; |
| length = 11; |
| break; |
| } |
| |
| case Override: |
| { |
| static const unsigned short staticallyStoredOverride[] = |
| { |
| 111, 118, 101, 114, 114, 105, 100, 101, 0 |
| }; |
| data = staticallyStoredOverride; |
| length = 8; |
| break; |
| } |
| |
| case Pattern: |
| { |
| static const unsigned short staticallyStoredPattern[] = |
| { |
| 112, 97, 116, 116, 101, 114, 110, 0 |
| }; |
| data = staticallyStoredPattern; |
| length = 7; |
| break; |
| } |
| |
| case Preserve: |
| { |
| static const unsigned short staticallyStoredPreserve[] = |
| { |
| 112, 114, 101, 115, 101, 114, 118, 101, 0 |
| }; |
| data = staticallyStoredPreserve; |
| length = 8; |
| break; |
| } |
| |
| case ProcessContents: |
| { |
| static const unsigned short staticallyStoredProcessContents[] = |
| { |
| 112, 114, 111, 99, 101, 115, 115, 67, 111, 110, 116, 101, 110, 116, 115, 0 |
| }; |
| data = staticallyStoredProcessContents; |
| length = 15; |
| break; |
| } |
| |
| case Public: |
| { |
| static const unsigned short staticallyStoredPublic[] = |
| { |
| 112, 117, 98, 108, 105, 99, 0 |
| }; |
| data = staticallyStoredPublic; |
| length = 6; |
| break; |
| } |
| |
| case Redefine: |
| { |
| static const unsigned short staticallyStoredRedefine[] = |
| { |
| 114, 101, 100, 101, 102, 105, 110, 101, 0 |
| }; |
| data = staticallyStoredRedefine; |
| length = 8; |
| break; |
| } |
| |
| case Ref: |
| { |
| static const unsigned short staticallyStoredRef[] = |
| { |
| 114, 101, 102, 0 |
| }; |
| data = staticallyStoredRef; |
| length = 3; |
| break; |
| } |
| |
| case Refer: |
| { |
| static const unsigned short staticallyStoredRefer[] = |
| { |
| 114, 101, 102, 101, 114, 0 |
| }; |
| data = staticallyStoredRefer; |
| length = 5; |
| break; |
| } |
| |
| case Replace: |
| { |
| static const unsigned short staticallyStoredReplace[] = |
| { |
| 114, 101, 112, 108, 97, 99, 101, 0 |
| }; |
| data = staticallyStoredReplace; |
| length = 7; |
| break; |
| } |
| |
| case Restriction: |
| { |
| static const unsigned short staticallyStoredRestriction[] = |
| { |
| 114, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredRestriction; |
| length = 11; |
| break; |
| } |
| |
| case Schema: |
| { |
| static const unsigned short staticallyStoredSchema[] = |
| { |
| 115, 99, 104, 101, 109, 97, 0 |
| }; |
| data = staticallyStoredSchema; |
| length = 6; |
| break; |
| } |
| |
| case SchemaLocation: |
| { |
| static const unsigned short staticallyStoredSchemaLocation[] = |
| { |
| 115, 99, 104, 101, 109, 97, 76, 111, 99, 97, 116, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredSchemaLocation; |
| length = 14; |
| break; |
| } |
| |
| case Selector: |
| { |
| static const unsigned short staticallyStoredSelector[] = |
| { |
| 115, 101, 108, 101, 99, 116, 111, 114, 0 |
| }; |
| data = staticallyStoredSelector; |
| length = 8; |
| break; |
| } |
| |
| case Sequence: |
| { |
| static const unsigned short staticallyStoredSequence[] = |
| { |
| 115, 101, 113, 117, 101, 110, 99, 101, 0 |
| }; |
| data = staticallyStoredSequence; |
| length = 8; |
| break; |
| } |
| |
| case SimpleContent: |
| { |
| static const unsigned short staticallyStoredSimpleContent[] = |
| { |
| 115, 105, 109, 112, 108, 101, 67, 111, 110, 116, 101, 110, 116, 0 |
| }; |
| data = staticallyStoredSimpleContent; |
| length = 13; |
| break; |
| } |
| |
| case SimpleType: |
| { |
| static const unsigned short staticallyStoredSimpleType[] = |
| { |
| 115, 105, 109, 112, 108, 101, 84, 121, 112, 101, 0 |
| }; |
| data = staticallyStoredSimpleType; |
| length = 10; |
| break; |
| } |
| |
| case Source: |
| { |
| static const unsigned short staticallyStoredSource[] = |
| { |
| 115, 111, 117, 114, 99, 101, 0 |
| }; |
| data = staticallyStoredSource; |
| length = 6; |
| break; |
| } |
| |
| case SubstitutionGroup: |
| { |
| static const unsigned short staticallyStoredSubstitutionGroup[] = |
| { |
| 115, 117, 98, 115, 116, 105, 116, 117, 116, 105, 111, 110, 71, 114, 111, 117, 112, 0 |
| }; |
| data = staticallyStoredSubstitutionGroup; |
| length = 17; |
| break; |
| } |
| |
| case System: |
| { |
| static const unsigned short staticallyStoredSystem[] = |
| { |
| 115, 121, 115, 116, 101, 109, 0 |
| }; |
| data = staticallyStoredSystem; |
| length = 6; |
| break; |
| } |
| |
| case TargetNamespace: |
| { |
| static const unsigned short staticallyStoredTargetNamespace[] = |
| { |
| 116, 97, 114, 103, 101, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101, 0 |
| }; |
| data = staticallyStoredTargetNamespace; |
| length = 15; |
| break; |
| } |
| |
| case Test: |
| { |
| static const unsigned short staticallyStoredTest[] = |
| { |
| 116, 101, 115, 116, 0 |
| }; |
| data = staticallyStoredTest; |
| length = 4; |
| break; |
| } |
| |
| case TotalDigits: |
| { |
| static const unsigned short staticallyStoredTotalDigits[] = |
| { |
| 116, 111, 116, 97, 108, 68, 105, 103, 105, 116, 115, 0 |
| }; |
| data = staticallyStoredTotalDigits; |
| length = 11; |
| break; |
| } |
| |
| case Type: |
| { |
| static const unsigned short staticallyStoredType[] = |
| { |
| 116, 121, 112, 101, 0 |
| }; |
| data = staticallyStoredType; |
| length = 4; |
| break; |
| } |
| |
| case Union: |
| { |
| static const unsigned short staticallyStoredUnion[] = |
| { |
| 117, 110, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredUnion; |
| length = 5; |
| break; |
| } |
| |
| case Unique: |
| { |
| static const unsigned short staticallyStoredUnique[] = |
| { |
| 117, 110, 105, 113, 117, 101, 0 |
| }; |
| data = staticallyStoredUnique; |
| length = 6; |
| break; |
| } |
| |
| case Use: |
| { |
| static const unsigned short staticallyStoredUse[] = |
| { |
| 117, 115, 101, 0 |
| }; |
| data = staticallyStoredUse; |
| length = 3; |
| break; |
| } |
| |
| case Value: |
| { |
| static const unsigned short staticallyStoredValue[] = |
| { |
| 118, 97, 108, 117, 101, 0 |
| }; |
| data = staticallyStoredValue; |
| length = 5; |
| break; |
| } |
| |
| case Version: |
| { |
| static const unsigned short staticallyStoredVersion[] = |
| { |
| 118, 101, 114, 115, 105, 111, 110, 0 |
| }; |
| data = staticallyStoredVersion; |
| length = 7; |
| break; |
| } |
| |
| case WhiteSpace: |
| { |
| static const unsigned short staticallyStoredWhiteSpace[] = |
| { |
| 119, 104, 105, 116, 101, 83, 112, 97, 99, 101, 0 |
| }; |
| data = staticallyStoredWhiteSpace; |
| length = 10; |
| break; |
| } |
| |
| case XML_NS_SCHEMA_URI: |
| { |
| static const unsigned short staticallyStoredXML_NS_SCHEMA_URI[] = |
| { |
| 104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 119, 51, 46, 111, 114, 103, 47, 50, 48, 48, 49, 47, 88, 77, 76, 83, 99, 104, 101, 109, 97, 0 |
| }; |
| data = staticallyStoredXML_NS_SCHEMA_URI; |
| length = 32; |
| break; |
| } |
| |
| case XPathDefaultNamespace: |
| { |
| static const unsigned short staticallyStoredXPathDefaultNamespace[] = |
| { |
| 120, 112, 97, 116, 104, 68, 101, 102, 97, 117, 108, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101, 0 |
| }; |
| data = staticallyStoredXPathDefaultNamespace; |
| length = 21; |
| break; |
| } |
| |
| case XmlLanguage: |
| { |
| static const unsigned short staticallyStoredXmlLanguage[] = |
| { |
| 120, 109, 108, 58, 108, 97, 110, 103, 0 |
| }; |
| data = staticallyStoredXmlLanguage; |
| length = 8; |
| break; |
| } |
| |
| case Xpath: |
| { |
| static const unsigned short staticallyStoredXpath[] = |
| { |
| 120, 112, 97, 116, 104, 0 |
| }; |
| data = staticallyStoredXpath; |
| length = 5; |
| 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 |
| |