src/xmlpatterns/schema/qxsdschematoken.cpp

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