src/xmlpatterns/parser/qxslttokenlookup.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 /* NOTE: This file is AUTO GENERATED by qtokenautomaton2cpp.xsl. */
  43
  44 #include "qxslttokenlookup_p.h"
  45
  46 QT_BEGIN_NAMESPACE
  47
  48 using namespace QPatternist;
  49
  50 XSLTTokenLookup::NodeName XSLTTokenLookup::classifier2(const QChar *data)
  51
  52         {
  53             if (data[0] == 97)
  54
  55
  56                     {
  57
  58                             if(data[1] == 115)
  59
  60
  61                 return As;
  62
  63                     }
  64
  65                 else if (data[0] == 105)
  66
  67
  68                     {
  69                     if (data[1] == 100)
  70
  71
  72                     {
  73
  74
  75                 return Id;
  76
  77                     }
  78
  79                 else if (data[1] == 102)
  80
  81
  82                     {
  83
  84
  85                 return If;
  86
  87                     }
  88
  89
  90                     }
  91
  92
  93
  94             return NoKeyword;
  95         }
  96     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier3(const QChar *data)
  97
  98         {
  99             if (data[0] == 107)
 100
 101
 102                     {
 103
 104                             static const unsigned short string[] =
 105                             {
 106                                 101, 121
 107                             };
 108                             if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
 109
 110
 111                 return Key;
 112
 113                     }
 114
 115                 else if (data[0] == 117)
 116
 117
 118                     {
 119
 120                             static const unsigned short string[] =
 121                             {
 122                                 115, 101
 123                             };
 124                             if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
 125
 126
 127                 return Use;
 128
 129                     }
 130
 131
 132
 133             return NoKeyword;
 134         }
 135     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier4(const QChar *data)
 136
 137         {
 138             if (data[0] == 99)
 139
 140
 141                     {
 142
 143                             static const unsigned short string[] =
 144                             {
 145                                 111, 112, 121
 146                             };
 147                             if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 148
 149
 150                 return Copy;
 151
 152                     }
 153
 154                 else if (data[0] == 104)
 155
 156
 157                     {
 158
 159                             static const unsigned short string[] =
 160                             {
 161                                 114, 101, 102
 162                             };
 163                             if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 164
 165
 166                 return Href;
 167
 168                     }
 169
 170                 else if (data[0] == 108)
 171
 172
 173                     {
 174
 175                             static const unsigned short string[] =
 176                             {
 177                                 97, 110, 103
 178                             };
 179                             if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 180
 181
 182                 return Lang;
 183
 184                     }
 185
 186                 else if (data[0] == 109)
 187
 188
 189                     {
 190
 191                             static const unsigned short string[] =
 192                             {
 193                                 111, 100, 101
 194                             };
 195                             if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 196
 197
 198                 return Mode;
 199
 200                     }
 201
 202                 else if (data[0] == 110)
 203
 204
 205                     {
 206
 207                             static const unsigned short string[] =
 208                             {
 209                                 97, 109, 101
 210                             };
 211                             if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 212
 213
 214                 return Name;
 215
 216                     }
 217
 218                 else if (data[0] == 115)
 219
 220
 221                     {
 222
 223                             static const unsigned short string[] =
 224                             {
 225                                 111, 114, 116
 226                             };
 227                             if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 228
 229
 230                 return Sort;
 231
 232                     }
 233
 234                 else if (data[0] == 116)
 235
 236
 237                     {
 238                     if (data[1] == 101)
 239
 240
 241                     {
 242                     if (data[2] == 115)
 243
 244
 245                     {
 246
 247                             if(data[3] == 116)
 248
 249
 250                 return Test;
 251
 252                     }
 253
 254                 else if (data[2] == 120)
 255
 256
 257                     {
 258
 259                             if(data[3] == 116)
 260
 261
 262                 return Text;
 263
 264                     }
 265
 266
 267                     }
 268
 269                 else if (data[1] == 121)
 270
 271
 272                     {
 273
 274                             static const unsigned short string[] =
 275                             {
 276                                 112, 101
 277                             };
 278                             if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0)
 279
 280
 281                 return Type;
 282
 283                     }
 284
 285
 286                     }
 287
 288                 else if (data[0] == 119)
 289
 290
 291                     {
 292
 293                             static const unsigned short string[] =
 294                             {
 295                                 104, 101, 110
 296                             };
 297                             if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
 298
 299
 300                 return When;
 301
 302                     }
 303
 304
 305
 306             return NoKeyword;
 307         }
 308     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier5(const QChar *data)
 309
 310         {
 311             if (data[0] == 102)
 312
 313
 314                     {
 315
 316                             static const unsigned short string[] =
 317                             {
 318                                 108, 97, 103, 115
 319                             };
 320                             if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 321
 322
 323                 return Flags;
 324
 325                     }
 326
 327                 else if (data[0] == 109)
 328
 329
 330                     {
 331
 332                             static const unsigned short string[] =
 333                             {
 334                                 97, 116, 99, 104
 335                             };
 336                             if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 337
 338
 339                 return Match;
 340
 341                     }
 342
 343                 else if (data[0] == 111)
 344
 345
 346                     {
 347
 348                             static const unsigned short string[] =
 349                             {
 350                                 114, 100, 101, 114
 351                             };
 352                             if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 353
 354
 355                 return Order;
 356
 357                     }
 358
 359                 else if (data[0] == 112)
 360
 361
 362                     {
 363
 364                             static const unsigned short string[] =
 365                             {
 366                                 97, 114, 97, 109
 367                             };
 368                             if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 369
 370
 371                 return Param;
 372
 373                     }
 374
 375                 else if (data[0] == 114)
 376
 377
 378                     {
 379
 380                             static const unsigned short string[] =
 381                             {
 382                                 101, 103, 101, 120
 383                             };
 384                             if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
 385
 386
 387                 return Regex;
 388
 389                     }
 390
 391
 392
 393             return NoKeyword;
 394         }
 395     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier6(const QChar *data)
 396
 397         {
 398             if (data[0] == 99)
 399
 400
 401                     {
 402
 403                             static const unsigned short string[] =
 404                             {
 405                                 104, 111, 111, 115, 101
 406                             };
 407                             if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 408
 409
 410                 return Choose;
 411
 412                     }
 413
 414                 else if (data[0] == 102)
 415
 416
 417                     {
 418
 419                             static const unsigned short string[] =
 420                             {
 421                                 111, 114, 109, 97, 116
 422                             };
 423                             if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 424
 425
 426                 return Format;
 427
 428                     }
 429
 430                 else if (data[0] == 105)
 431
 432
 433                     {
 434                     if (data[1] == 109)
 435
 436
 437                     {
 438
 439                             static const unsigned short string[] =
 440                             {
 441                                 112, 111, 114, 116
 442                             };
 443                             if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
 444
 445
 446                 return Import;
 447
 448                     }
 449
 450                 else if (data[1] == 110)
 451
 452
 453                     {
 454
 455                             static const unsigned short string[] =
 456                             {
 457                                 100, 101, 110, 116
 458                             };
 459                             if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
 460
 461
 462                 return Indent;
 463
 464                     }
 465
 466
 467                     }
 468
 469                 else if (data[0] == 109)
 470
 471
 472                     {
 473
 474                             static const unsigned short string[] =
 475                             {
 476                                 101, 116, 104, 111, 100
 477                             };
 478                             if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 479
 480
 481                 return Method;
 482
 483                     }
 484
 485                 else if (data[0] == 111)
 486
 487
 488                     {
 489
 490                             static const unsigned short string[] =
 491                             {
 492                                 117, 116, 112, 117, 116
 493                             };
 494                             if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 495
 496
 497                 return Output;
 498
 499                     }
 500
 501                 else if (data[0] == 115)
 502
 503
 504                     {
 505                     if (data[1] == 101)
 506
 507
 508                     {
 509
 510                             static const unsigned short string[] =
 511                             {
 512                                 108, 101, 99, 116
 513                             };
 514                             if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
 515
 516
 517                 return Select;
 518
 519                     }
 520
 521                 else if (data[1] == 116)
 522
 523
 524                     {
 525
 526                             static const unsigned short string[] =
 527                             {
 528                                 97, 98, 108, 101
 529                             };
 530                             if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
 531
 532
 533                 return Stable;
 534
 535                     }
 536
 537
 538                     }
 539
 540                 else if (data[0] == 116)
 541
 542
 543                     {
 544
 545                             static const unsigned short string[] =
 546                             {
 547                                 117, 110, 110, 101, 108
 548                             };
 549                             if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
 550
 551
 552                 return Tunnel;
 553
 554                     }
 555
 556
 557
 558             return NoKeyword;
 559         }
 560     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier7(const QChar *data)
 561
 562         {
 563             if (data[0] == 99)
 564
 565
 566                     {
 567                     if (data[1] == 111)
 568
 569
 570                     {
 571                     if (data[2] == 109)
 572
 573
 574                     {
 575
 576                             static const unsigned short string[] =
 577                             {
 578                                 109, 101, 110, 116
 579                             };
 580                             if(memcmp(&data[3], &string, sizeof(QChar) * 4) == 0)
 581
 582
 583                 return Comment;
 584
 585                     }
 586
 587                 else if (data[2] == 112)
 588
 589
 590                     {
 591
 592                             static const unsigned short string[] =
 593                             {
 594                                 121, 45, 111, 102
 595                             };
 596                             if(memcmp(&data[3], &string, sizeof(QChar) * 4) == 0)
 597
 598
 599                 return CopyOf;
 600
 601                     }
 602
 603
 604                     }
 605
 606
 607                     }
 608
 609                 else if (data[0] == 101)
 610
 611
 612                     {
 613
 614                             static const unsigned short string[] =
 615                             {
 616                                 108, 101, 109, 101, 110, 116
 617                             };
 618                             if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 619
 620
 621                 return Element;
 622
 623                     }
 624
 625                 else if (data[0] == 105)
 626
 627
 628                     {
 629
 630                             static const unsigned short string[] =
 631                             {
 632                                 110, 99, 108, 117, 100, 101
 633                             };
 634                             if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 635
 636
 637                 return Include;
 638
 639                     }
 640
 641                 else if (data[0] == 109)
 642
 643
 644                     {
 645
 646                             static const unsigned short string[] =
 647                             {
 648                                 101, 115, 115, 97, 103, 101
 649                             };
 650                             if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 651
 652
 653                 return Message;
 654
 655                     }
 656
 657                 else if (data[0] == 118)
 658
 659
 660                     {
 661
 662                             static const unsigned short string[] =
 663                             {
 664                                 101, 114, 115, 105, 111, 110
 665                             };
 666                             if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
 667
 668
 669                 return Version;
 670
 671                     }
 672
 673
 674
 675             return NoKeyword;
 676         }
 677     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier8(const QChar *data)
 678
 679         {
 680             if (data[0] == 100)
 681
 682
 683                     {
 684
 685                             static const unsigned short string[] =
 686                             {
 687                                 111, 99, 117, 109, 101, 110, 116
 688                             };
 689                             if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 690
 691
 692                 return Document;
 693
 694                     }
 695
 696                 else if (data[0] == 101)
 697
 698
 699                     {
 700                     if (data[1] == 108)
 701
 702
 703                     {
 704
 705                             static const unsigned short string[] =
 706                             {
 707                                 101, 109, 101, 110, 116, 115
 708                             };
 709                             if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
 710
 711
 712                 return Elements;
 713
 714                     }
 715
 716                 else if (data[1] == 110)
 717
 718
 719                     {
 720
 721                             static const unsigned short string[] =
 722                             {
 723                                 99, 111, 100, 105, 110, 103
 724                             };
 725                             if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
 726
 727
 728                 return Encoding;
 729
 730                     }
 731
 732
 733                     }
 734
 735                 else if (data[0] == 102)
 736
 737
 738                     {
 739                     if (data[1] == 111)
 740
 741
 742                     {
 743
 744                             static const unsigned short string[] =
 745                             {
 746                                 114, 45, 101, 97, 99, 104
 747                             };
 748                             if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
 749
 750
 751                 return ForEach;
 752
 753                     }
 754
 755                 else if (data[1] == 117)
 756
 757
 758                     {
 759
 760                             static const unsigned short string[] =
 761                             {
 762                                 110, 99, 116, 105, 111, 110
 763                             };
 764                             if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
 765
 766
 767                 return Function;
 768
 769                     }
 770
 771
 772                     }
 773
 774                 else if (data[0] == 111)
 775
 776
 777                     {
 778
 779                             static const unsigned short string[] =
 780                             {
 781                                 118, 101, 114, 114, 105, 100, 101
 782                             };
 783                             if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 784
 785
 786                 return Override;
 787
 788                     }
 789
 790                 else if (data[0] == 112)
 791
 792
 793                     {
 794
 795                             static const unsigned short string[] =
 796                             {
 797                                 114, 105, 111, 114, 105, 116, 121
 798                             };
 799                             if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 800
 801
 802                 return Priority;
 803
 804                     }
 805
 806                 else if (data[0] == 114)
 807
 808
 809                     {
 810
 811                             static const unsigned short string[] =
 812                             {
 813                                 101, 113, 117, 105, 114, 101, 100
 814                             };
 815                             if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 816
 817
 818                 return Required;
 819
 820                     }
 821
 822                 else if (data[0] == 115)
 823
 824
 825                     {
 826
 827                             static const unsigned short string[] =
 828                             {
 829                                 101, 113, 117, 101, 110, 99, 101
 830                             };
 831                             if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 832
 833
 834                 return Sequence;
 835
 836                     }
 837
 838                 else if (data[0] == 116)
 839
 840
 841                     {
 842
 843                             static const unsigned short string[] =
 844                             {
 845                                 101, 109, 112, 108, 97, 116, 101
 846                             };
 847                             if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 848
 849
 850                 return Template;
 851
 852                     }
 853
 854                 else if (data[0] == 117)
 855
 856
 857                     {
 858
 859                             static const unsigned short string[] =
 860                             {
 861                                 115, 101, 45, 119, 104, 101, 110
 862                             };
 863                             if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
 864
 865
 866                 return UseWhen;
 867
 868                     }
 869
 870                 else if (data[0] == 118)
 871
 872
 873                     {
 874                     if (data[1] == 97)
 875
 876
 877                     {
 878                     if (data[2] == 108)
 879
 880
 881                     {
 882
 883                             static const unsigned short string[] =
 884                             {
 885                                 117, 101, 45, 111, 102
 886                             };
 887                             if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0)
 888
 889
 890                 return ValueOf;
 891
 892                     }
 893
 894                 else if (data[2] == 114)
 895
 896
 897                     {
 898
 899                             static const unsigned short string[] =
 900                             {
 901                                 105, 97, 98, 108, 101
 902                             };
 903                             if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0)
 904
 905
 906                 return Variable;
 907
 908                     }
 909
 910
 911                     }
 912
 913
 914                     }
 915
 916
 917
 918             return NoKeyword;
 919         }
 920     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier9(const QChar *data)
 921
 922         {
 923             if (data[0] == 97)
 924
 925
 926                     {
 927
 928                             static const unsigned short string[] =
 929                             {
 930                                 116, 116, 114, 105, 98, 117, 116, 101
 931                             };
 932                             if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
 933
 934
 935                 return Attribute;
 936
 937                     }
 938
 939                 else if (data[0] == 99)
 940
 941
 942                     {
 943
 944                             static const unsigned short string[] =
 945                             {
 946                                 111, 108, 108, 97, 116, 105, 111, 110
 947                             };
 948                             if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
 949
 950
 951                 return Collation;
 952
 953                     }
 954
 955                 else if (data[0] == 100)
 956
 957
 958                     {
 959
 960                             static const unsigned short string[] =
 961                             {
 962                                 97, 116, 97, 45, 116, 121, 112, 101
 963                             };
 964                             if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
 965
 966
 967                 return DataType;
 968
 969                     }
 970
 971                 else if (data[0] == 110)
 972
 973
 974                     {
 975
 976                             static const unsigned short string[] =
 977                             {
 978                                 97, 109, 101, 115, 112, 97, 99, 101
 979                             };
 980                             if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
 981
 982
 983                 return Namespace;
 984
 985                     }
 986
 987                 else if (data[0] == 111)
 988
 989
 990                     {
 991
 992                             static const unsigned short string[] =
 993                             {
 994                                 116, 104, 101, 114, 119, 105, 115, 101
 995                             };
 996                             if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
 997
 998
 999                 return Otherwise;
1000
1001                     }
1002
1003                 else if (data[0] == 115)
1004
1005
1006                     {
1007
1008                             static const unsigned short string[] =
1009                             {
1010                                 101, 112, 97, 114, 97, 116, 111, 114
1011                             };
1012                             if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
1013
1014
1015                 return Separator;
1016
1017                     }
1018
1019                 else if (data[0] == 116)
1020
1021
1022                     {
1023                     if (data[1] == 101)
1024
1025
1026                     {
1027
1028                             static const unsigned short string[] =
1029                             {
1030                                 114, 109, 105, 110, 97, 116, 101
1031                             };
1032                             if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0)
1033
1034
1035                 return Terminate;
1036
1037                     }
1038
1039                 else if (data[1] == 114)
1040
1041
1042                     {
1043
1044                             static const unsigned short string[] =
1045                             {
1046                                 97, 110, 115, 102, 111, 114, 109
1047                             };
1048                             if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0)
1049
1050
1051                 return Transform;
1052
1053                     }
1054
1055
1056                     }
1057
1058
1059
1060             return NoKeyword;
1061         }
1062     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier10(const QChar *data)
1063
1064         {
1065             if (data[0] == 99)
1066
1067
1068                     {
1069
1070                             static const unsigned short string[] =
1071                             {
1072                                 97, 115, 101, 45, 111, 114, 100, 101, 114
1073                             };
1074                             if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
1075
1076
1077                 return CaseOrder;
1078
1079                     }
1080
1081                 else if (data[0] == 109)
1082
1083
1084                     {
1085
1086                             static const unsigned short string[] =
1087                             {
1088                                 101, 100, 105, 97, 45, 116, 121, 112, 101
1089                             };
1090                             if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
1091
1092
1093                 return MediaType;
1094
1095                     }
1096
1097                 else if (data[0] == 115)
1098
1099
1100                     {
1101                     if (data[1] == 116)
1102
1103
1104                     {
1105                     if (data[2] == 97)
1106
1107
1108                     {
1109
1110                             static const unsigned short string[] =
1111                             {
1112                                 110, 100, 97, 108, 111, 110, 101
1113                             };
1114                             if(memcmp(&data[3], &string, sizeof(QChar) * 7) == 0)
1115
1116
1117                 return Standalone;
1118
1119                     }
1120
1121                 else if (data[2] == 121)
1122
1123
1124                     {
1125
1126                             static const unsigned short string[] =
1127                             {
1128                                 108, 101, 115, 104, 101, 101, 116
1129                             };
1130                             if(memcmp(&data[3], &string, sizeof(QChar) * 7) == 0)
1131
1132
1133                 return Stylesheet;
1134
1135                     }
1136
1137
1138                     }
1139
1140
1141                     }
1142
1143                 else if (data[0] == 118)
1144
1145
1146                     {
1147
1148                             static const unsigned short string[] =
1149                             {
1150                                 97, 108, 105, 100, 97, 116, 105, 111, 110
1151                             };
1152                             if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
1153
1154
1155                 return Validation;
1156
1157                     }
1158
1159                 else if (data[0] == 119)
1160
1161
1162                     {
1163
1164                             static const unsigned short string[] =
1165                             {
1166                                 105, 116, 104, 45, 112, 97, 114, 97, 109
1167                             };
1168                             if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
1169
1170
1171                 return WithParam;
1172
1173                     }
1174
1175
1176
1177             return NoKeyword;
1178         }
1179     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier11(const QChar *data)
1180
1181         {
1182
1183                             static const unsigned short string[] =
1184                             {
1185                                 115, 116, 114, 105, 112, 45, 115, 112, 97, 99, 101
1186                             };
1187                             if(memcmp(&data[0], &string, sizeof(QChar) * 11) == 0)
1188
1189
1190                 return StripSpace;
1191
1192
1193             return NoKeyword;
1194         }
1195     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier12(const QChar *data)
1196
1197         {
1198
1199                             static const unsigned short string[] =
1200                             {
1201                                 112, 101, 114, 102, 111, 114, 109, 45, 115, 111, 114, 116
1202                             };
1203                             if(memcmp(&data[0], &string, sizeof(QChar) * 12) == 0)
1204
1205
1206                 return PerformSort;
1207
1208
1209             return NoKeyword;
1210         }
1211     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier13(const QChar *data)
1212
1213         {
1214             if (data[0] == 97)
1215
1216
1217                     {
1218
1219                             static const unsigned short string[] =
1220                             {
1221                                 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116
1222                             };
1223                             if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
1224
1225
1226                 return AttributeSet;
1227
1228                     }
1229
1230                 else if (data[0] == 99)
1231
1232
1233                     {
1234
1235                             static const unsigned short string[] =
1236                             {
1237                                 97, 108, 108, 45, 116, 101, 109, 112, 108, 97, 116, 101
1238                             };
1239                             if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
1240
1241
1242                 return CallTemplate;
1243
1244                     }
1245
1246                 else if (data[0] == 105)
1247
1248
1249                     {
1250
1251                             static const unsigned short string[] =
1252                             {
1253                                 109, 112, 111, 114, 116, 45, 115, 99, 104, 101, 109, 97
1254                             };
1255                             if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
1256
1257
1258                 return ImportSchema;
1259
1260                     }
1261
1262
1263
1264             return NoKeyword;
1265         }
1266     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier14(const QChar *data)
1267
1268         {
1269             if (data[0] == 97)
1270
1271
1272                     {
1273
1274                             static const unsigned short string[] =
1275                             {
1276                                 110, 97, 108, 121, 122, 101, 45, 115, 116, 114, 105, 110, 103
1277                             };
1278                             if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
1279
1280
1281                 return AnalyzeString;
1282
1283                     }
1284
1285                 else if (data[0] == 100)
1286
1287
1288                     {
1289                     if (data[1] == 111)
1290
1291
1292                     {
1293                     if (data[2] == 99)
1294
1295
1296                     {
1297                     if (data[3] == 116)
1298
1299
1300                     {
1301                     if (data[4] == 121)
1302
1303
1304                     {
1305                     if (data[5] == 112)
1306
1307
1308                     {
1309                     if (data[6] == 101)
1310
1311
1312                     {
1313                     if (data[7] == 45)
1314
1315
1316                     {
1317                     if (data[8] == 112)
1318
1319
1320                     {
1321
1322                             static const unsigned short string[] =
1323                             {
1324                                 117, 98, 108, 105, 99
1325                             };
1326                             if(memcmp(&data[9], &string, sizeof(QChar) * 5) == 0)
1327
1328
1329                 return DoctypePublic;
1330
1331                     }
1332
1333                 else if (data[8] == 115)
1334
1335
1336                     {
1337
1338                             static const unsigned short string[] =
1339                             {
1340                                 121, 115, 116, 101, 109
1341                             };
1342                             if(memcmp(&data[9], &string, sizeof(QChar) * 5) == 0)
1343
1344
1345                 return DoctypeSystem;
1346
1347                     }
1348
1349
1350                     }
1351
1352
1353                     }
1354
1355
1356                     }
1357
1358
1359                     }
1360
1361
1362                     }
1363
1364
1365                     }
1366
1367
1368                     }
1369
1370
1371                     }
1372
1373                 else if (data[0] == 111)
1374
1375
1376                     {
1377
1378                             static const unsigned short string[] =
1379                             {
1380                                 117, 116, 112, 117, 116, 45, 118, 101, 114, 115, 105, 111, 110
1381                             };
1382                             if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
1383
1384
1385                 return OutputVersion;
1386
1387                     }
1388
1389                 else if (data[0] == 112)
1390
1391
1392                     {
1393
1394                             static const unsigned short string[] =
1395                             {
1396                                 114, 101, 115, 101, 114, 118, 101, 45, 115, 112, 97, 99, 101
1397                             };
1398                             if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
1399
1400
1401                 return PreserveSpace;
1402
1403                     }
1404
1405
1406
1407             return NoKeyword;
1408         }
1409     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier15(const QChar *data)
1410
1411         {
1412             if (data[0] == 97)
1413
1414
1415                     {
1416
1417                             static const unsigned short string[] =
1418                             {
1419                                 112, 112, 108, 121, 45, 116, 101, 109, 112, 108, 97, 116, 101, 115
1420                             };
1421                             if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
1422
1423
1424                 return ApplyTemplates;
1425
1426                     }
1427
1428                 else if (data[0] == 98)
1429
1430
1431                     {
1432
1433                             static const unsigned short string[] =
1434                             {
1435                                 121, 116, 101, 45, 111, 114, 100, 101, 114, 45, 109, 97, 114, 107
1436                             };
1437                             if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
1438
1439
1440                 return ByteOrderMark;
1441
1442                     }
1443
1444                 else if (data[0] == 99)
1445
1446
1447                     {
1448
1449                             static const unsigned short string[] =
1450                             {
1451                                 111, 112, 121, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115
1452                             };
1453                             if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
1454
1455
1456                 return CopyNamespaces;
1457
1458                     }
1459
1460                 else if (data[0] == 114)
1461
1462
1463                     {
1464
1465                             static const unsigned short string[] =
1466                             {
1467                                 101, 115, 117, 108, 116, 45, 100, 111, 99, 117, 109, 101, 110, 116
1468                             };
1469                             if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
1470
1471
1472                 return ResultDocument;
1473
1474                     }
1475
1476                 else if (data[0] == 115)
1477
1478
1479                     {
1480
1481                             static const unsigned short string[] =
1482                             {
1483                                 99, 104, 101, 109, 97, 45, 108, 111, 99, 97, 116, 105, 111, 110
1484                             };
1485                             if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
1486
1487
1488                 return SchemaLocation;
1489
1490                     }
1491
1492
1493
1494             return NoKeyword;
1495         }
1496     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier17(const QChar *data)
1497
1498         {
1499
1500                             static const unsigned short string[] =
1501                             {
1502                                 100, 101, 102, 97, 117, 108, 116, 45, 99, 111, 108, 108, 97, 116, 105, 111, 110
1503                             };
1504                             if(memcmp(&data[0], &string, sizeof(QChar) * 17) == 0)
1505
1506
1507                 return DefaultCollation;
1508
1509
1510             return NoKeyword;
1511         }
1512     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier18(const QChar *data)
1513
1514         {
1515             if (data[0] == 100)
1516
1517
1518                     {
1519
1520                             static const unsigned short string[] =
1521                             {
1522                                 101, 102, 97, 117, 108, 116, 45, 118, 97, 108, 105, 100, 97, 116, 105, 111, 110
1523                             };
1524                             if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
1525
1526
1527                 return DefaultValidation;
1528
1529                     }
1530
1531                 else if (data[0] == 105)
1532
1533
1534                     {
1535
1536                             static const unsigned short string[] =
1537                             {
1538                                 110, 104, 101, 114, 105, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115
1539                             };
1540                             if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
1541
1542
1543                 return InheritNamespaces;
1544
1545                     }
1546
1547                 else if (data[0] == 109)
1548
1549
1550                     {
1551
1552                             static const unsigned short string[] =
1553                             {
1554                                 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103
1555                             };
1556                             if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
1557
1558
1559                 return MatchingSubstring;
1560
1561                     }
1562
1563                 else if (data[0] == 110)
1564
1565
1566                     {
1567
1568                             static const unsigned short string[] =
1569                             {
1570                                 111, 114, 109, 97, 108, 105, 122, 97, 116, 105, 111, 110, 45, 102, 111, 114, 109
1571                             };
1572                             if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
1573
1574
1575                 return NormalizationForm;
1576
1577                     }
1578
1579                 else if (data[0] == 117)
1580
1581
1582                     {
1583                     if (data[1] == 110)
1584
1585
1586                     {
1587
1588                             static const unsigned short string[] =
1589                             {
1590                                 100, 101, 99, 108, 97, 114, 101, 45, 112, 114, 101, 102, 105, 120, 101, 115
1591                             };
1592                             if(memcmp(&data[2], &string, sizeof(QChar) * 16) == 0)
1593
1594
1595                 return UndeclarePrefixes;
1596
1597                     }
1598
1599                 else if (data[1] == 115)
1600
1601
1602                     {
1603                     if (data[2] == 101)
1604
1605
1606                     {
1607                     if (data[3] == 45)
1608
1609
1610                     {
1611                     if (data[4] == 97)
1612
1613
1614                     {
1615
1616                             static const unsigned short string[] =
1617                             {
1618                                 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 115
1619                             };
1620                             if(memcmp(&data[5], &string, sizeof(QChar) * 13) == 0)
1621
1622
1623                 return UseAttributeSets;
1624
1625                     }
1626
1627                 else if (data[4] == 99)
1628
1629
1630                     {
1631
1632                             static const unsigned short string[] =
1633                             {
1634                                 104, 97, 114, 97, 99, 116, 101, 114, 45, 109, 97, 112, 115
1635                             };
1636                             if(memcmp(&data[5], &string, sizeof(QChar) * 13) == 0)
1637
1638
1639                 return UseCharacterMaps;
1640
1641                     }
1642
1643
1644                     }
1645
1646
1647                     }
1648
1649
1650                     }
1651
1652
1653                     }
1654
1655
1656
1657             return NoKeyword;
1658         }
1659     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier20(const QChar *data)
1660
1661         {
1662             if (data[0] == 105)
1663
1664
1665                     {
1666
1667                             static const unsigned short string[] =
1668                             {
1669                                 110, 99, 108, 117, 100, 101, 45, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101
1670                             };
1671                             if(memcmp(&data[1], &string, sizeof(QChar) * 19) == 0)
1672
1673
1674                 return IncludeContentType;
1675
1676                     }
1677
1678                 else if (data[0] == 111)
1679
1680
1681                     {
1682
1683                             static const unsigned short string[] =
1684                             {
1685                                 109, 105, 116, 45, 120, 109, 108, 45, 100, 101, 99, 108, 97, 114, 97, 116, 105, 111, 110
1686                             };
1687                             if(memcmp(&data[1], &string, sizeof(QChar) * 19) == 0)
1688
1689
1690                 return OmitXmlDeclaration;
1691
1692                     }
1693
1694
1695
1696             return NoKeyword;
1697         }
1698     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier21(const QChar *data)
1699
1700         {
1701
1702                             static const unsigned short string[] =
1703                             {
1704                                 101, 115, 99, 97, 112, 101, 45, 117, 114, 105, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 115
1705                             };
1706                             if(memcmp(&data[0], &string, sizeof(QChar) * 21) == 0)
1707
1708
1709                 return EscapeUriAttributes;
1710
1711
1712             return NoKeyword;
1713         }
1714     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier22(const QChar *data)
1715
1716         {
1717             if (data[0] == 99)
1718
1719
1720                     {
1721
1722                             static const unsigned short string[] =
1723                             {
1724                                 100, 97, 116, 97, 45, 115, 101, 99, 116, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 115
1725                             };
1726                             if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
1727
1728
1729                 return CdataSectionElements;
1730
1731                     }
1732
1733                 else if (data[0] == 105)
1734
1735
1736                     {
1737
1738                             static const unsigned short string[] =
1739                             {
1740                                 110, 112, 117, 116, 45, 116, 121, 112, 101, 45, 97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 115
1741                             };
1742                             if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
1743
1744
1745                 return InputTypeAnnotations;
1746
1747                     }
1748
1749                 else if (data[0] == 110)
1750
1751
1752                     {
1753
1754                             static const unsigned short string[] =
1755                             {
1756                                 111, 110, 45, 109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103
1757                             };
1758                             if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
1759
1760
1761                 return NonMatchingSubstring;
1762
1763                     }
1764
1765                 else if (data[0] == 112)
1766
1767
1768                     {
1769
1770                             static const unsigned short string[] =
1771                             {
1772                                 114, 111, 99, 101, 115, 115, 105, 110, 103, 45, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110
1773                             };
1774                             if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
1775
1776
1777                 return ProcessingInstruction;
1778
1779                     }
1780
1781
1782
1783             return NoKeyword;
1784         }
1785     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier23(const QChar *data)
1786
1787         {
1788             if (data[0] == 101)
1789
1790
1791                     {
1792
1793                             static const unsigned short string[] =
1794                             {
1795                                 120, 99, 108, 117, 100, 101, 45, 114, 101, 115, 117, 108, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115
1796                             };
1797                             if(memcmp(&data[1], &string, sizeof(QChar) * 22) == 0)
1798
1799
1800                 return ExcludeResultPrefixes;
1801
1802                     }
1803
1804                 else if (data[0] == 120)
1805
1806
1807                     {
1808
1809                             static const unsigned short string[] =
1810                             {
1811                                 112, 97, 116, 104, 45, 100, 101, 102, 97, 117, 108, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101
1812                             };
1813                             if(memcmp(&data[1], &string, sizeof(QChar) * 22) == 0)
1814
1815
1816                 return XpathDefaultNamespace;
1817
1818                     }
1819
1820
1821
1822             return NoKeyword;
1823         }
1824     XSLTTokenLookup::NodeName XSLTTokenLookup::classifier26(const QChar *data)
1825
1826         {
1827
1828                             static const unsigned short string[] =
1829                             {
1830                                 101, 120, 116, 101, 110, 115, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115
1831                             };
1832                             if(memcmp(&data[0], &string, sizeof(QChar) * 26) == 0)
1833
1834
1835                 return ExtensionElementPrefixes;
1836
1837
1838             return NoKeyword;
1839         }
1840     XSLTTokenLookup::NodeName XSLTTokenLookup::toToken(const QChar *data, int length)
1841             {
1842                 switch(length)
1843                 {
1844
1845                         case 2:
1846                             return classifier2(data);
1847
1848
1849                         case 3:
1850                             return classifier3(data);
1851
1852
1853                         case 4:
1854                             return classifier4(data);
1855
1856
1857                         case 5:
1858                             return classifier5(data);
1859
1860
1861                         case 6:
1862                             return classifier6(data);
1863
1864
1865                         case 7:
1866                             return classifier7(data);
1867
1868
1869                         case 8:
1870                             return classifier8(data);
1871
1872
1873                         case 9:
1874                             return classifier9(data);
1875
1876
1877                         case 10:
1878                             return classifier10(data);
1879
1880
1881                         case 11:
1882                             return classifier11(data);
1883
1884
1885                         case 12:
1886                             return classifier12(data);
1887
1888
1889                         case 13:
1890                             return classifier13(data);
1891
1892
1893                         case 14:
1894                             return classifier14(data);
1895
1896
1897                         case 15:
1898                             return classifier15(data);
1899
1900
1901                         case 17:
1902                             return classifier17(data);
1903
1904
1905                         case 18:
1906                             return classifier18(data);
1907
1908
1909                         case 20:
1910                             return classifier20(data);
1911
1912
1913                         case 21:
1914                             return classifier21(data);
1915
1916
1917                         case 22:
1918                             return classifier22(data);
1919
1920
1921                         case 23:
1922                             return classifier23(data);
1923
1924
1925                         case 26:
1926                             return classifier26(data);
1927
1928
1929                         default:
1930                             return NoKeyword;
1931                 }
1932             }
1933
1934
1935                 QString XSLTTokenLookup::toString(NodeName token)
1936                 {
1937                     const unsigned short *data = 0;
1938                     int length = 0;
1939
1940                     switch(token)
1941                     {
1942
1943                         case AnalyzeString:
1944                         {
1945                             static const unsigned short staticallyStoredAnalyzeString[] =
1946                             {
1947                             97, 110, 97, 108, 121, 122, 101, 45, 115, 116, 114, 105, 110, 103, 0
1948                             };
1949                             data = staticallyStoredAnalyzeString;
1950                             length = 14;
1951                             break;
1952                         }
1953
1954                         case ApplyTemplates:
1955                         {
1956                             static const unsigned short staticallyStoredApplyTemplates[] =
1957                             {
1958                             97, 112, 112, 108, 121, 45, 116, 101, 109, 112, 108, 97, 116, 101, 115, 0
1959                             };
1960                             data = staticallyStoredApplyTemplates;
1961                             length = 15;
1962                             break;
1963                         }
1964
1965                         case As:
1966                         {
1967                             static const unsigned short staticallyStoredAs[] =
1968                             {
1969                             97, 115, 0
1970                             };
1971                             data = staticallyStoredAs;
1972                             length = 2;
1973                             break;
1974                         }
1975
1976                         case Attribute:
1977                         {
1978                             static const unsigned short staticallyStoredAttribute[] =
1979                             {
1980                             97, 116, 116, 114, 105, 98, 117, 116, 101, 0
1981                             };
1982                             data = staticallyStoredAttribute;
1983                             length = 9;
1984                             break;
1985                         }
1986
1987                         case AttributeSet:
1988                         {
1989                             static const unsigned short staticallyStoredAttributeSet[] =
1990                             {
1991                             97, 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 0
1992                             };
1993                             data = staticallyStoredAttributeSet;
1994                             length = 13;
1995                             break;
1996                         }
1997
1998                         case ByteOrderMark:
1999                         {
2000                             static const unsigned short staticallyStoredByteOrderMark[] =
2001                             {
2002                             98, 121, 116, 101, 45, 111, 114, 100, 101, 114, 45, 109, 97, 114, 107, 0
2003                             };
2004                             data = staticallyStoredByteOrderMark;
2005                             length = 15;
2006                             break;
2007                         }
2008
2009                         case CallTemplate:
2010                         {
2011                             static const unsigned short staticallyStoredCallTemplate[] =
2012                             {
2013                             99, 97, 108, 108, 45, 116, 101, 109, 112, 108, 97, 116, 101, 0
2014                             };
2015                             data = staticallyStoredCallTemplate;
2016                             length = 13;
2017                             break;
2018                         }
2019
2020                         case CaseOrder:
2021                         {
2022                             static const unsigned short staticallyStoredCaseOrder[] =
2023                             {
2024                             99, 97, 115, 101, 45, 111, 114, 100, 101, 114, 0
2025                             };
2026                             data = staticallyStoredCaseOrder;
2027                             length = 10;
2028                             break;
2029                         }
2030
2031                         case CdataSectionElements:
2032                         {
2033                             static const unsigned short staticallyStoredCdataSectionElements[] =
2034                             {
2035                             99, 100, 97, 116, 97, 45, 115, 101, 99, 116, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 115, 0
2036                             };
2037                             data = staticallyStoredCdataSectionElements;
2038                             length = 22;
2039                             break;
2040                         }
2041
2042                         case Choose:
2043                         {
2044                             static const unsigned short staticallyStoredChoose[] =
2045                             {
2046                             99, 104, 111, 111, 115, 101, 0
2047                             };
2048                             data = staticallyStoredChoose;
2049                             length = 6;
2050                             break;
2051                         }
2052
2053                         case Collation:
2054                         {
2055                             static const unsigned short staticallyStoredCollation[] =
2056                             {
2057                             99, 111, 108, 108, 97, 116, 105, 111, 110, 0
2058                             };
2059                             data = staticallyStoredCollation;
2060                             length = 9;
2061                             break;
2062                         }
2063
2064                         case Comment:
2065                         {
2066                             static const unsigned short staticallyStoredComment[] =
2067                             {
2068                             99, 111, 109, 109, 101, 110, 116, 0
2069                             };
2070                             data = staticallyStoredComment;
2071                             length = 7;
2072                             break;
2073                         }
2074
2075                         case Copy:
2076                         {
2077                             static const unsigned short staticallyStoredCopy[] =
2078                             {
2079                             99, 111, 112, 121, 0
2080                             };
2081                             data = staticallyStoredCopy;
2082                             length = 4;
2083                             break;
2084                         }
2085
2086                         case CopyNamespaces:
2087                         {
2088                             static const unsigned short staticallyStoredCopyNamespaces[] =
2089                             {
2090                             99, 111, 112, 121, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115, 0
2091                             };
2092                             data = staticallyStoredCopyNamespaces;
2093                             length = 15;
2094                             break;
2095                         }
2096
2097                         case CopyOf:
2098                         {
2099                             static const unsigned short staticallyStoredCopyOf[] =
2100                             {
2101                             99, 111, 112, 121, 45, 111, 102, 0
2102                             };
2103                             data = staticallyStoredCopyOf;
2104                             length = 7;
2105                             break;
2106                         }
2107
2108                         case DataType:
2109                         {
2110                             static const unsigned short staticallyStoredDataType[] =
2111                             {
2112                             100, 97, 116, 97, 45, 116, 121, 112, 101, 0
2113                             };
2114                             data = staticallyStoredDataType;
2115                             length = 9;
2116                             break;
2117                         }
2118
2119                         case DefaultCollation:
2120                         {
2121                             static const unsigned short staticallyStoredDefaultCollation[] =
2122                             {
2123                             100, 101, 102, 97, 117, 108, 116, 45, 99, 111, 108, 108, 97, 116, 105, 111, 110, 0
2124                             };
2125                             data = staticallyStoredDefaultCollation;
2126                             length = 17;
2127                             break;
2128                         }
2129
2130                         case DefaultValidation:
2131                         {
2132                             static const unsigned short staticallyStoredDefaultValidation[] =
2133                             {
2134                             100, 101, 102, 97, 117, 108, 116, 45, 118, 97, 108, 105, 100, 97, 116, 105, 111, 110, 0
2135                             };
2136                             data = staticallyStoredDefaultValidation;
2137                             length = 18;
2138                             break;
2139                         }
2140
2141                         case DoctypePublic:
2142                         {
2143                             static const unsigned short staticallyStoredDoctypePublic[] =
2144                             {
2145                             100, 111, 99, 116, 121, 112, 101, 45, 112, 117, 98, 108, 105, 99, 0
2146                             };
2147                             data = staticallyStoredDoctypePublic;
2148                             length = 14;
2149                             break;
2150                         }
2151
2152                         case DoctypeSystem:
2153                         {
2154                             static const unsigned short staticallyStoredDoctypeSystem[] =
2155                             {
2156                             100, 111, 99, 116, 121, 112, 101, 45, 115, 121, 115, 116, 101, 109, 0
2157                             };
2158                             data = staticallyStoredDoctypeSystem;
2159                             length = 14;
2160                             break;
2161                         }
2162
2163                         case Document:
2164                         {
2165                             static const unsigned short staticallyStoredDocument[] =
2166                             {
2167                             100, 111, 99, 117, 109, 101, 110, 116, 0
2168                             };
2169                             data = staticallyStoredDocument;
2170                             length = 8;
2171                             break;
2172                         }
2173
2174                         case Element:
2175                         {
2176                             static const unsigned short staticallyStoredElement[] =
2177                             {
2178                             101, 108, 101, 109, 101, 110, 116, 0
2179                             };
2180                             data = staticallyStoredElement;
2181                             length = 7;
2182                             break;
2183                         }
2184
2185                         case Elements:
2186                         {
2187                             static const unsigned short staticallyStoredElements[] =
2188                             {
2189                             101, 108, 101, 109, 101, 110, 116, 115, 0
2190                             };
2191                             data = staticallyStoredElements;
2192                             length = 8;
2193                             break;
2194                         }
2195
2196                         case Encoding:
2197                         {
2198                             static const unsigned short staticallyStoredEncoding[] =
2199                             {
2200                             101, 110, 99, 111, 100, 105, 110, 103, 0
2201                             };
2202                             data = staticallyStoredEncoding;
2203                             length = 8;
2204                             break;
2205                         }
2206
2207                         case EscapeUriAttributes:
2208                         {
2209                             static const unsigned short staticallyStoredEscapeUriAttributes[] =
2210                             {
2211                             101, 115, 99, 97, 112, 101, 45, 117, 114, 105, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 115, 0
2212                             };
2213                             data = staticallyStoredEscapeUriAttributes;
2214                             length = 21;
2215                             break;
2216                         }
2217
2218                         case ExcludeResultPrefixes:
2219                         {
2220                             static const unsigned short staticallyStoredExcludeResultPrefixes[] =
2221                             {
2222                             101, 120, 99, 108, 117, 100, 101, 45, 114, 101, 115, 117, 108, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0
2223                             };
2224                             data = staticallyStoredExcludeResultPrefixes;
2225                             length = 23;
2226                             break;
2227                         }
2228
2229                         case ExtensionElementPrefixes:
2230                         {
2231                             static const unsigned short staticallyStoredExtensionElementPrefixes[] =
2232                             {
2233                             101, 120, 116, 101, 110, 115, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0
2234                             };
2235                             data = staticallyStoredExtensionElementPrefixes;
2236                             length = 26;
2237                             break;
2238                         }
2239
2240                         case Flags:
2241                         {
2242                             static const unsigned short staticallyStoredFlags[] =
2243                             {
2244                             102, 108, 97, 103, 115, 0
2245                             };
2246                             data = staticallyStoredFlags;
2247                             length = 5;
2248                             break;
2249                         }
2250
2251                         case ForEach:
2252                         {
2253                             static const unsigned short staticallyStoredForEach[] =
2254                             {
2255                             102, 111, 114, 45, 101, 97, 99, 104, 0
2256                             };
2257                             data = staticallyStoredForEach;
2258                             length = 8;
2259                             break;
2260                         }
2261
2262                         case Format:
2263                         {
2264                             static const unsigned short staticallyStoredFormat[] =
2265                             {
2266                             102, 111, 114, 109, 97, 116, 0
2267                             };
2268                             data = staticallyStoredFormat;
2269                             length = 6;
2270                             break;
2271                         }
2272
2273                         case Function:
2274                         {
2275                             static const unsigned short staticallyStoredFunction[] =
2276                             {
2277                             102, 117, 110, 99, 116, 105, 111, 110, 0
2278                             };
2279                             data = staticallyStoredFunction;
2280                             length = 8;
2281                             break;
2282                         }
2283
2284                         case Href:
2285                         {
2286                             static const unsigned short staticallyStoredHref[] =
2287                             {
2288                             104, 114, 101, 102, 0
2289                             };
2290                             data = staticallyStoredHref;
2291                             length = 4;
2292                             break;
2293                         }
2294
2295                         case Id:
2296                         {
2297                             static const unsigned short staticallyStoredId[] =
2298                             {
2299                             105, 100, 0
2300                             };
2301                             data = staticallyStoredId;
2302                             length = 2;
2303                             break;
2304                         }
2305
2306                         case If:
2307                         {
2308                             static const unsigned short staticallyStoredIf[] =
2309                             {
2310                             105, 102, 0
2311                             };
2312                             data = staticallyStoredIf;
2313                             length = 2;
2314                             break;
2315                         }
2316
2317                         case Import:
2318                         {
2319                             static const unsigned short staticallyStoredImport[] =
2320                             {
2321                             105, 109, 112, 111, 114, 116, 0
2322                             };
2323                             data = staticallyStoredImport;
2324                             length = 6;
2325                             break;
2326                         }
2327
2328                         case ImportSchema:
2329                         {
2330                             static const unsigned short staticallyStoredImportSchema[] =
2331                             {
2332                             105, 109, 112, 111, 114, 116, 45, 115, 99, 104, 101, 109, 97, 0
2333                             };
2334                             data = staticallyStoredImportSchema;
2335                             length = 13;
2336                             break;
2337                         }
2338
2339                         case Include:
2340                         {
2341                             static const unsigned short staticallyStoredInclude[] =
2342                             {
2343                             105, 110, 99, 108, 117, 100, 101, 0
2344                             };
2345                             data = staticallyStoredInclude;
2346                             length = 7;
2347                             break;
2348                         }
2349
2350                         case IncludeContentType:
2351                         {
2352                             static const unsigned short staticallyStoredIncludeContentType[] =
2353                             {
2354                             105, 110, 99, 108, 117, 100, 101, 45, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 0
2355                             };
2356                             data = staticallyStoredIncludeContentType;
2357                             length = 20;
2358                             break;
2359                         }
2360
2361                         case Indent:
2362                         {
2363                             static const unsigned short staticallyStoredIndent[] =
2364                             {
2365                             105, 110, 100, 101, 110, 116, 0
2366                             };
2367                             data = staticallyStoredIndent;
2368                             length = 6;
2369                             break;
2370                         }
2371
2372                         case InheritNamespaces:
2373                         {
2374                             static const unsigned short staticallyStoredInheritNamespaces[] =
2375                             {
2376                             105, 110, 104, 101, 114, 105, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115, 0
2377                             };
2378                             data = staticallyStoredInheritNamespaces;
2379                             length = 18;
2380                             break;
2381                         }
2382
2383                         case InputTypeAnnotations:
2384                         {
2385                             static const unsigned short staticallyStoredInputTypeAnnotations[] =
2386                             {
2387                             105, 110, 112, 117, 116, 45, 116, 121, 112, 101, 45, 97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 115, 0
2388                             };
2389                             data = staticallyStoredInputTypeAnnotations;
2390                             length = 22;
2391                             break;
2392                         }
2393
2394                         case Key:
2395                         {
2396                             static const unsigned short staticallyStoredKey[] =
2397                             {
2398                             107, 101, 121, 0
2399                             };
2400                             data = staticallyStoredKey;
2401                             length = 3;
2402                             break;
2403                         }
2404
2405                         case Lang:
2406                         {
2407                             static const unsigned short staticallyStoredLang[] =
2408                             {
2409                             108, 97, 110, 103, 0
2410                             };
2411                             data = staticallyStoredLang;
2412                             length = 4;
2413                             break;
2414                         }
2415
2416                         case Match:
2417                         {
2418                             static const unsigned short staticallyStoredMatch[] =
2419                             {
2420                             109, 97, 116, 99, 104, 0
2421                             };
2422                             data = staticallyStoredMatch;
2423                             length = 5;
2424                             break;
2425                         }
2426
2427                         case MatchingSubstring:
2428                         {
2429                             static const unsigned short staticallyStoredMatchingSubstring[] =
2430                             {
2431                             109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103, 0
2432                             };
2433                             data = staticallyStoredMatchingSubstring;
2434                             length = 18;
2435                             break;
2436                         }
2437
2438                         case MediaType:
2439                         {
2440                             static const unsigned short staticallyStoredMediaType[] =
2441                             {
2442                             109, 101, 100, 105, 97, 45, 116, 121, 112, 101, 0
2443                             };
2444                             data = staticallyStoredMediaType;
2445                             length = 10;
2446                             break;
2447                         }
2448
2449                         case Message:
2450                         {
2451                             static const unsigned short staticallyStoredMessage[] =
2452                             {
2453                             109, 101, 115, 115, 97, 103, 101, 0
2454                             };
2455                             data = staticallyStoredMessage;
2456                             length = 7;
2457                             break;
2458                         }
2459
2460                         case Method:
2461                         {
2462                             static const unsigned short staticallyStoredMethod[] =
2463                             {
2464                             109, 101, 116, 104, 111, 100, 0
2465                             };
2466                             data = staticallyStoredMethod;
2467                             length = 6;
2468                             break;
2469                         }
2470
2471                         case Mode:
2472                         {
2473                             static const unsigned short staticallyStoredMode[] =
2474                             {
2475                             109, 111, 100, 101, 0
2476                             };
2477                             data = staticallyStoredMode;
2478                             length = 4;
2479                             break;
2480                         }
2481
2482                         case Name:
2483                         {
2484                             static const unsigned short staticallyStoredName[] =
2485                             {
2486                             110, 97, 109, 101, 0
2487                             };
2488                             data = staticallyStoredName;
2489                             length = 4;
2490                             break;
2491                         }
2492
2493                         case Namespace:
2494                         {
2495                             static const unsigned short staticallyStoredNamespace[] =
2496                             {
2497                             110, 97, 109, 101, 115, 112, 97, 99, 101, 0
2498                             };
2499                             data = staticallyStoredNamespace;
2500                             length = 9;
2501                             break;
2502                         }
2503
2504                         case NonMatchingSubstring:
2505                         {
2506                             static const unsigned short staticallyStoredNonMatchingSubstring[] =
2507                             {
2508                             110, 111, 110, 45, 109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103, 0
2509                             };
2510                             data = staticallyStoredNonMatchingSubstring;
2511                             length = 22;
2512                             break;
2513                         }
2514
2515                         case NormalizationForm:
2516                         {
2517                             static const unsigned short staticallyStoredNormalizationForm[] =
2518                             {
2519                             110, 111, 114, 109, 97, 108, 105, 122, 97, 116, 105, 111, 110, 45, 102, 111, 114, 109, 0
2520                             };
2521                             data = staticallyStoredNormalizationForm;
2522                             length = 18;
2523                             break;
2524                         }
2525
2526                         case OmitXmlDeclaration:
2527                         {
2528                             static const unsigned short staticallyStoredOmitXmlDeclaration[] =
2529                             {
2530                             111, 109, 105, 116, 45, 120, 109, 108, 45, 100, 101, 99, 108, 97, 114, 97, 116, 105, 111, 110, 0
2531                             };
2532                             data = staticallyStoredOmitXmlDeclaration;
2533                             length = 20;
2534                             break;
2535                         }
2536
2537                         case Order:
2538                         {
2539                             static const unsigned short staticallyStoredOrder[] =
2540                             {
2541                             111, 114, 100, 101, 114, 0
2542                             };
2543                             data = staticallyStoredOrder;
2544                             length = 5;
2545                             break;
2546                         }
2547
2548                         case Otherwise:
2549                         {
2550                             static const unsigned short staticallyStoredOtherwise[] =
2551                             {
2552                             111, 116, 104, 101, 114, 119, 105, 115, 101, 0
2553                             };
2554                             data = staticallyStoredOtherwise;
2555                             length = 9;
2556                             break;
2557                         }
2558
2559                         case Output:
2560                         {
2561                             static const unsigned short staticallyStoredOutput[] =
2562                             {
2563                             111, 117, 116, 112, 117, 116, 0
2564                             };
2565                             data = staticallyStoredOutput;
2566                             length = 6;
2567                             break;
2568                         }
2569
2570                         case OutputVersion:
2571                         {
2572                             static const unsigned short staticallyStoredOutputVersion[] =
2573                             {
2574                             111, 117, 116, 112, 117, 116, 45, 118, 101, 114, 115, 105, 111, 110, 0
2575                             };
2576                             data = staticallyStoredOutputVersion;
2577                             length = 14;
2578                             break;
2579                         }
2580
2581                         case Override:
2582                         {
2583                             static const unsigned short staticallyStoredOverride[] =
2584                             {
2585                             111, 118, 101, 114, 114, 105, 100, 101, 0
2586                             };
2587                             data = staticallyStoredOverride;
2588                             length = 8;
2589                             break;
2590                         }
2591
2592                         case Param:
2593                         {
2594                             static const unsigned short staticallyStoredParam[] =
2595                             {
2596                             112, 97, 114, 97, 109, 0
2597                             };
2598                             data = staticallyStoredParam;
2599                             length = 5;
2600                             break;
2601                         }
2602
2603                         case PerformSort:
2604                         {
2605                             static const unsigned short staticallyStoredPerformSort[] =
2606                             {
2607                             112, 101, 114, 102, 111, 114, 109, 45, 115, 111, 114, 116, 0
2608                             };
2609                             data = staticallyStoredPerformSort;
2610                             length = 12;
2611                             break;
2612                         }
2613
2614                         case PreserveSpace:
2615                         {
2616                             static const unsigned short staticallyStoredPreserveSpace[] =
2617                             {
2618                             112, 114, 101, 115, 101, 114, 118, 101, 45, 115, 112, 97, 99, 101, 0
2619                             };
2620                             data = staticallyStoredPreserveSpace;
2621                             length = 14;
2622                             break;
2623                         }
2624
2625                         case Priority:
2626                         {
2627                             static const unsigned short staticallyStoredPriority[] =
2628                             {
2629                             112, 114, 105, 111, 114, 105, 116, 121, 0
2630                             };
2631                             data = staticallyStoredPriority;
2632                             length = 8;
2633                             break;
2634                         }
2635
2636                         case ProcessingInstruction:
2637                         {
2638                             static const unsigned short staticallyStoredProcessingInstruction[] =
2639                             {
2640                             112, 114, 111, 99, 101, 115, 115, 105, 110, 103, 45, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 0
2641                             };
2642                             data = staticallyStoredProcessingInstruction;
2643                             length = 22;
2644                             break;
2645                         }
2646
2647                         case Regex:
2648                         {
2649                             static const unsigned short staticallyStoredRegex[] =
2650                             {
2651                             114, 101, 103, 101, 120, 0
2652                             };
2653                             data = staticallyStoredRegex;
2654                             length = 5;
2655                             break;
2656                         }
2657
2658                         case Required:
2659                         {
2660                             static const unsigned short staticallyStoredRequired[] =
2661                             {
2662                             114, 101, 113, 117, 105, 114, 101, 100, 0
2663                             };
2664                             data = staticallyStoredRequired;
2665                             length = 8;
2666                             break;
2667                         }
2668
2669                         case ResultDocument:
2670                         {
2671                             static const unsigned short staticallyStoredResultDocument[] =
2672                             {
2673                             114, 101, 115, 117, 108, 116, 45, 100, 111, 99, 117, 109, 101, 110, 116, 0
2674                             };
2675                             data = staticallyStoredResultDocument;
2676                             length = 15;
2677                             break;
2678                         }
2679
2680                         case SchemaLocation:
2681                         {
2682                             static const unsigned short staticallyStoredSchemaLocation[] =
2683                             {
2684                             115, 99, 104, 101, 109, 97, 45, 108, 111, 99, 97, 116, 105, 111, 110, 0
2685                             };
2686                             data = staticallyStoredSchemaLocation;
2687                             length = 15;
2688                             break;
2689                         }
2690
2691                         case Select:
2692                         {
2693                             static const unsigned short staticallyStoredSelect[] =
2694                             {
2695                             115, 101, 108, 101, 99, 116, 0
2696                             };
2697                             data = staticallyStoredSelect;
2698                             length = 6;
2699                             break;
2700                         }
2701
2702                         case Separator:
2703                         {
2704                             static const unsigned short staticallyStoredSeparator[] =
2705                             {
2706                             115, 101, 112, 97, 114, 97, 116, 111, 114, 0
2707                             };
2708                             data = staticallyStoredSeparator;
2709                             length = 9;
2710                             break;
2711                         }
2712
2713                         case Sequence:
2714                         {
2715                             static const unsigned short staticallyStoredSequence[] =
2716                             {
2717                             115, 101, 113, 117, 101, 110, 99, 101, 0
2718                             };
2719                             data = staticallyStoredSequence;
2720                             length = 8;
2721                             break;
2722                         }
2723
2724                         case Sort:
2725                         {
2726                             static const unsigned short staticallyStoredSort[] =
2727                             {
2728                             115, 111, 114, 116, 0
2729                             };
2730                             data = staticallyStoredSort;
2731                             length = 4;
2732                             break;
2733                         }
2734
2735                         case Stable:
2736                         {
2737                             static const unsigned short staticallyStoredStable[] =
2738                             {
2739                             115, 116, 97, 98, 108, 101, 0
2740                             };
2741                             data = staticallyStoredStable;
2742                             length = 6;
2743                             break;
2744                         }
2745
2746                         case Standalone:
2747                         {
2748                             static const unsigned short staticallyStoredStandalone[] =
2749                             {
2750                             115, 116, 97, 110, 100, 97, 108, 111, 110, 101, 0
2751                             };
2752                             data = staticallyStoredStandalone;
2753                             length = 10;
2754                             break;
2755                         }
2756
2757                         case StripSpace:
2758                         {
2759                             static const unsigned short staticallyStoredStripSpace[] =
2760                             {
2761                             115, 116, 114, 105, 112, 45, 115, 112, 97, 99, 101, 0
2762                             };
2763                             data = staticallyStoredStripSpace;
2764                             length = 11;
2765                             break;
2766                         }
2767
2768                         case Stylesheet:
2769                         {
2770                             static const unsigned short staticallyStoredStylesheet[] =
2771                             {
2772                             115, 116, 121, 108, 101, 115, 104, 101, 101, 116, 0
2773                             };
2774                             data = staticallyStoredStylesheet;
2775                             length = 10;
2776                             break;
2777                         }
2778
2779                         case Template:
2780                         {
2781                             static const unsigned short staticallyStoredTemplate[] =
2782                             {
2783                             116, 101, 109, 112, 108, 97, 116, 101, 0
2784                             };
2785                             data = staticallyStoredTemplate;
2786                             length = 8;
2787                             break;
2788                         }
2789
2790                         case Terminate:
2791                         {
2792                             static const unsigned short staticallyStoredTerminate[] =
2793                             {
2794                             116, 101, 114, 109, 105, 110, 97, 116, 101, 0
2795                             };
2796                             data = staticallyStoredTerminate;
2797                             length = 9;
2798                             break;
2799                         }
2800
2801                         case Test:
2802                         {
2803                             static const unsigned short staticallyStoredTest[] =
2804                             {
2805                             116, 101, 115, 116, 0
2806                             };
2807                             data = staticallyStoredTest;
2808                             length = 4;
2809                             break;
2810                         }
2811
2812                         case Text:
2813                         {
2814                             static const unsigned short staticallyStoredText[] =
2815                             {
2816                             116, 101, 120, 116, 0
2817                             };
2818                             data = staticallyStoredText;
2819                             length = 4;
2820                             break;
2821                         }
2822
2823                         case Transform:
2824                         {
2825                             static const unsigned short staticallyStoredTransform[] =
2826                             {
2827                             116, 114, 97, 110, 115, 102, 111, 114, 109, 0
2828                             };
2829                             data = staticallyStoredTransform;
2830                             length = 9;
2831                             break;
2832                         }
2833
2834                         case Tunnel:
2835                         {
2836                             static const unsigned short staticallyStoredTunnel[] =
2837                             {
2838                             116, 117, 110, 110, 101, 108, 0
2839                             };
2840                             data = staticallyStoredTunnel;
2841                             length = 6;
2842                             break;
2843                         }
2844
2845                         case Type:
2846                         {
2847                             static const unsigned short staticallyStoredType[] =
2848                             {
2849                             116, 121, 112, 101, 0
2850                             };
2851                             data = staticallyStoredType;
2852                             length = 4;
2853                             break;
2854                         }
2855
2856                         case UndeclarePrefixes:
2857                         {
2858                             static const unsigned short staticallyStoredUndeclarePrefixes[] =
2859                             {
2860                             117, 110, 100, 101, 99, 108, 97, 114, 101, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0
2861                             };
2862                             data = staticallyStoredUndeclarePrefixes;
2863                             length = 18;
2864                             break;
2865                         }
2866
2867                         case Use:
2868                         {
2869                             static const unsigned short staticallyStoredUse[] =
2870                             {
2871                             117, 115, 101, 0
2872                             };
2873                             data = staticallyStoredUse;
2874                             length = 3;
2875                             break;
2876                         }
2877
2878                         case UseAttributeSets:
2879                         {
2880                             static const unsigned short staticallyStoredUseAttributeSets[] =
2881                             {
2882                             117, 115, 101, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 115, 0
2883                             };
2884                             data = staticallyStoredUseAttributeSets;
2885                             length = 18;
2886                             break;
2887                         }
2888
2889                         case UseCharacterMaps:
2890                         {
2891                             static const unsigned short staticallyStoredUseCharacterMaps[] =
2892                             {
2893                             117, 115, 101, 45, 99, 104, 97, 114, 97, 99, 116, 101, 114, 45, 109, 97, 112, 115, 0
2894                             };
2895                             data = staticallyStoredUseCharacterMaps;
2896                             length = 18;
2897                             break;
2898                         }
2899
2900                         case UseWhen:
2901                         {
2902                             static const unsigned short staticallyStoredUseWhen[] =
2903                             {
2904                             117, 115, 101, 45, 119, 104, 101, 110, 0
2905                             };
2906                             data = staticallyStoredUseWhen;
2907                             length = 8;
2908                             break;
2909                         }
2910
2911                         case Validation:
2912                         {
2913                             static const unsigned short staticallyStoredValidation[] =
2914                             {
2915                             118, 97, 108, 105, 100, 97, 116, 105, 111, 110, 0
2916                             };
2917                             data = staticallyStoredValidation;
2918                             length = 10;
2919                             break;
2920                         }
2921
2922                         case ValueOf:
2923                         {
2924                             static const unsigned short staticallyStoredValueOf[] =
2925                             {
2926                             118, 97, 108, 117, 101, 45, 111, 102, 0
2927                             };
2928                             data = staticallyStoredValueOf;
2929                             length = 8;
2930                             break;
2931                         }
2932
2933                         case Variable:
2934                         {
2935                             static const unsigned short staticallyStoredVariable[] =
2936                             {
2937                             118, 97, 114, 105, 97, 98, 108, 101, 0
2938                             };
2939                             data = staticallyStoredVariable;
2940                             length = 8;
2941                             break;
2942                         }
2943
2944                         case Version:
2945                         {
2946                             static const unsigned short staticallyStoredVersion[] =
2947                             {
2948                             118, 101, 114, 115, 105, 111, 110, 0
2949                             };
2950                             data = staticallyStoredVersion;
2951                             length = 7;
2952                             break;
2953                         }
2954
2955                         case When:
2956                         {
2957                             static const unsigned short staticallyStoredWhen[] =
2958                             {
2959                             119, 104, 101, 110, 0
2960                             };
2961                             data = staticallyStoredWhen;
2962                             length = 4;
2963                             break;
2964                         }
2965
2966                         case WithParam:
2967                         {
2968                             static const unsigned short staticallyStoredWithParam[] =
2969                             {
2970                             119, 105, 116, 104, 45, 112, 97, 114, 97, 109, 0
2971                             };
2972                             data = staticallyStoredWithParam;
2973                             length = 10;
2974                             break;
2975                         }
2976
2977                         case XpathDefaultNamespace:
2978                         {
2979                             static const unsigned short staticallyStoredXpathDefaultNamespace[] =
2980                             {
2981                             120, 112, 97, 116, 104, 45, 100, 101, 102, 97, 117, 108, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 0
2982                             };
2983                             data = staticallyStoredXpathDefaultNamespace;
2984                             length = 23;
2985                             break;
2986                         }
2987
2988                         default:
2989                             /* It's either the default token, or an undefined enum
2990                              * value. We silence a compiler warning, and return the
2991                              * empty string. */
2992                             ;
2993                     }
2994
2995                     union
2996                     {
2997                         const unsigned short *data;
2998                         const QChar *asQChar;
2999                     } converter;
3000                     converter.data = data;
3001
3002                     return QString::fromRawData(converter.asQChar, length);
3003                 }
3004
3005 QT_END_NAMESPACE
3006