Initial import of statemachine branch from the old kinetic repository

1 files changed, 3006 insertions, 0 deletions

diff --git a/src/xmlpatterns/parser/qxslttokenlookup.cpp b/src/xmlpatterns/parser/qxslttokenlookup.cpp
new file mode 100644
index 0000000..9184de7
--- /dev/null
+++ b/src/xmlpatterns/parser/qxslttokenlookup.cpp
@@ -0,0 +1,3006 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, 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.0, 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.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $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
+