data/gles2/shaders/keywords.test

   1 # WARNING: This file is auto-generated. Do NOT modify it manually, but rather
   2 # modify the generating script file. Otherwise changes will be lost!
   3
   4 group keywords "Usage of keywords as identifiers."
   5
   6         case attribute
   7                 expect compile_fail
   8                 values {}
   9
  10                 both ""
  11                         precision mediump float;
  12
  13                         ${DECLARATIONS}
  14
  15                         void main()
  16                         {
  17                                 ${SETUP}
  18                                 float attribute = 1.0;
  19                                 ${OUTPUT}
  20                         }
  21                 ""
  22         end
  23         case const
  24                 expect compile_fail
  25                 values {}
  26
  27                 both ""
  28                         precision mediump float;
  29
  30                         ${DECLARATIONS}
  31
  32                         void main()
  33                         {
  34                                 ${SETUP}
  35                                 float const = 1.0;
  36                                 ${OUTPUT}
  37                         }
  38                 ""
  39         end
  40         case uniform
  41                 expect compile_fail
  42                 values {}
  43
  44                 both ""
  45                         precision mediump float;
  46
  47                         ${DECLARATIONS}
  48
  49                         void main()
  50                         {
  51                                 ${SETUP}
  52                                 float uniform = 1.0;
  53                                 ${OUTPUT}
  54                         }
  55                 ""
  56         end
  57         case varying
  58                 expect compile_fail
  59                 values {}
  60
  61                 both ""
  62                         precision mediump float;
  63
  64                         ${DECLARATIONS}
  65
  66                         void main()
  67                         {
  68                                 ${SETUP}
  69                                 float varying = 1.0;
  70                                 ${OUTPUT}
  71                         }
  72                 ""
  73         end
  74         case break
  75                 expect compile_fail
  76                 values {}
  77
  78                 both ""
  79                         precision mediump float;
  80
  81                         ${DECLARATIONS}
  82
  83                         void main()
  84                         {
  85                                 ${SETUP}
  86                                 float break = 1.0;
  87                                 ${OUTPUT}
  88                         }
  89                 ""
  90         end
  91         case continue
  92                 expect compile_fail
  93                 values {}
  94
  95                 both ""
  96                         precision mediump float;
  97
  98                         ${DECLARATIONS}
  99
 100                         void main()
 101                         {
 102                                 ${SETUP}
 103                                 float continue = 1.0;
 104                                 ${OUTPUT}
 105                         }
 106                 ""
 107         end
 108         case do
 109                 expect compile_fail
 110                 values {}
 111
 112                 both ""
 113                         precision mediump float;
 114
 115                         ${DECLARATIONS}
 116
 117                         void main()
 118                         {
 119                                 ${SETUP}
 120                                 float do = 1.0;
 121                                 ${OUTPUT}
 122                         }
 123                 ""
 124         end
 125         case for
 126                 expect compile_fail
 127                 values {}
 128
 129                 both ""
 130                         precision mediump float;
 131
 132                         ${DECLARATIONS}
 133
 134                         void main()
 135                         {
 136                                 ${SETUP}
 137                                 float for = 1.0;
 138                                 ${OUTPUT}
 139                         }
 140                 ""
 141         end
 142         case while
 143                 expect compile_fail
 144                 values {}
 145
 146                 both ""
 147                         precision mediump float;
 148
 149                         ${DECLARATIONS}
 150
 151                         void main()
 152                         {
 153                                 ${SETUP}
 154                                 float while = 1.0;
 155                                 ${OUTPUT}
 156                         }
 157                 ""
 158         end
 159         case if
 160                 expect compile_fail
 161                 values {}
 162
 163                 both ""
 164                         precision mediump float;
 165
 166                         ${DECLARATIONS}
 167
 168                         void main()
 169                         {
 170                                 ${SETUP}
 171                                 float if = 1.0;
 172                                 ${OUTPUT}
 173                         }
 174                 ""
 175         end
 176         case else
 177                 expect compile_fail
 178                 values {}
 179
 180                 both ""
 181                         precision mediump float;
 182
 183                         ${DECLARATIONS}
 184
 185                         void main()
 186                         {
 187                                 ${SETUP}
 188                                 float else = 1.0;
 189                                 ${OUTPUT}
 190                         }
 191                 ""
 192         end
 193         case in
 194                 expect compile_fail
 195                 values {}
 196
 197                 both ""
 198                         precision mediump float;
 199
 200                         ${DECLARATIONS}
 201
 202                         void main()
 203                         {
 204                                 ${SETUP}
 205                                 float in = 1.0;
 206                                 ${OUTPUT}
 207                         }
 208                 ""
 209         end
 210         case out
 211                 expect compile_fail
 212                 values {}
 213
 214                 both ""
 215                         precision mediump float;
 216
 217                         ${DECLARATIONS}
 218
 219                         void main()
 220                         {
 221                                 ${SETUP}
 222                                 float out = 1.0;
 223                                 ${OUTPUT}
 224                         }
 225                 ""
 226         end
 227         case inout
 228                 expect compile_fail
 229                 values {}
 230
 231                 both ""
 232                         precision mediump float;
 233
 234                         ${DECLARATIONS}
 235
 236                         void main()
 237                         {
 238                                 ${SETUP}
 239                                 float inout = 1.0;
 240                                 ${OUTPUT}
 241                         }
 242                 ""
 243         end
 244         case float
 245                 expect compile_fail
 246                 values {}
 247
 248                 both ""
 249                         precision mediump float;
 250
 251                         ${DECLARATIONS}
 252
 253                         void main()
 254                         {
 255                                 ${SETUP}
 256                                 float float = 1.0;
 257                                 ${OUTPUT}
 258                         }
 259                 ""
 260         end
 261         case int
 262                 expect compile_fail
 263                 values {}
 264
 265                 both ""
 266                         precision mediump float;
 267
 268                         ${DECLARATIONS}
 269
 270                         void main()
 271                         {
 272                                 ${SETUP}
 273                                 float int = 1.0;
 274                                 ${OUTPUT}
 275                         }
 276                 ""
 277         end
 278         case void
 279                 expect compile_fail
 280                 values {}
 281
 282                 both ""
 283                         precision mediump float;
 284
 285                         ${DECLARATIONS}
 286
 287                         void main()
 288                         {
 289                                 ${SETUP}
 290                                 float void = 1.0;
 291                                 ${OUTPUT}
 292                         }
 293                 ""
 294         end
 295         case bool
 296                 expect compile_fail
 297                 values {}
 298
 299                 both ""
 300                         precision mediump float;
 301
 302                         ${DECLARATIONS}
 303
 304                         void main()
 305                         {
 306                                 ${SETUP}
 307                                 float bool = 1.0;
 308                                 ${OUTPUT}
 309                         }
 310                 ""
 311         end
 312         case true
 313                 expect compile_fail
 314                 values {}
 315
 316                 both ""
 317                         precision mediump float;
 318
 319                         ${DECLARATIONS}
 320
 321                         void main()
 322                         {
 323                                 ${SETUP}
 324                                 float true = 1.0;
 325                                 ${OUTPUT}
 326                         }
 327                 ""
 328         end
 329         case false
 330                 expect compile_fail
 331                 values {}
 332
 333                 both ""
 334                         precision mediump float;
 335
 336                         ${DECLARATIONS}
 337
 338                         void main()
 339                         {
 340                                 ${SETUP}
 341                                 float false = 1.0;
 342                                 ${OUTPUT}
 343                         }
 344                 ""
 345         end
 346         case lowp
 347                 expect compile_fail
 348                 values {}
 349
 350                 both ""
 351                         precision mediump float;
 352
 353                         ${DECLARATIONS}
 354
 355                         void main()
 356                         {
 357                                 ${SETUP}
 358                                 float lowp = 1.0;
 359                                 ${OUTPUT}
 360                         }
 361                 ""
 362         end
 363         case mediump
 364                 expect compile_fail
 365                 values {}
 366
 367                 both ""
 368                         precision mediump float;
 369
 370                         ${DECLARATIONS}
 371
 372                         void main()
 373                         {
 374                                 ${SETUP}
 375                                 float mediump = 1.0;
 376                                 ${OUTPUT}
 377                         }
 378                 ""
 379         end
 380         case highp
 381                 expect compile_fail
 382                 values {}
 383
 384                 both ""
 385                         precision mediump float;
 386
 387                         ${DECLARATIONS}
 388
 389                         void main()
 390                         {
 391                                 ${SETUP}
 392                                 float highp = 1.0;
 393                                 ${OUTPUT}
 394                         }
 395                 ""
 396         end
 397         case precision
 398                 expect compile_fail
 399                 values {}
 400
 401                 both ""
 402                         precision mediump float;
 403
 404                         ${DECLARATIONS}
 405
 406                         void main()
 407                         {
 408                                 ${SETUP}
 409                                 float precision = 1.0;
 410                                 ${OUTPUT}
 411                         }
 412                 ""
 413         end
 414         case invariant
 415                 expect compile_fail
 416                 values {}
 417
 418                 both ""
 419                         precision mediump float;
 420
 421                         ${DECLARATIONS}
 422
 423                         void main()
 424                         {
 425                                 ${SETUP}
 426                                 float invariant = 1.0;
 427                                 ${OUTPUT}
 428                         }
 429                 ""
 430         end
 431         case discard
 432                 expect compile_fail
 433                 values {}
 434
 435                 both ""
 436                         precision mediump float;
 437
 438                         ${DECLARATIONS}
 439
 440                         void main()
 441                         {
 442                                 ${SETUP}
 443                                 float discard = 1.0;
 444                                 ${OUTPUT}
 445                         }
 446                 ""
 447         end
 448         case return
 449                 expect compile_fail
 450                 values {}
 451
 452                 both ""
 453                         precision mediump float;
 454
 455                         ${DECLARATIONS}
 456
 457                         void main()
 458                         {
 459                                 ${SETUP}
 460                                 float return = 1.0;
 461                                 ${OUTPUT}
 462                         }
 463                 ""
 464         end
 465         case mat2
 466                 expect compile_fail
 467                 values {}
 468
 469                 both ""
 470                         precision mediump float;
 471
 472                         ${DECLARATIONS}
 473
 474                         void main()
 475                         {
 476                                 ${SETUP}
 477                                 float mat2 = 1.0;
 478                                 ${OUTPUT}
 479                         }
 480                 ""
 481         end
 482         case mat3
 483                 expect compile_fail
 484                 values {}
 485
 486                 both ""
 487                         precision mediump float;
 488
 489                         ${DECLARATIONS}
 490
 491                         void main()
 492                         {
 493                                 ${SETUP}
 494                                 float mat3 = 1.0;
 495                                 ${OUTPUT}
 496                         }
 497                 ""
 498         end
 499         case mat4
 500                 expect compile_fail
 501                 values {}
 502
 503                 both ""
 504                         precision mediump float;
 505
 506                         ${DECLARATIONS}
 507
 508                         void main()
 509                         {
 510                                 ${SETUP}
 511                                 float mat4 = 1.0;
 512                                 ${OUTPUT}
 513                         }
 514                 ""
 515         end
 516         case vec2
 517                 expect compile_fail
 518                 values {}
 519
 520                 both ""
 521                         precision mediump float;
 522
 523                         ${DECLARATIONS}
 524
 525                         void main()
 526                         {
 527                                 ${SETUP}
 528                                 float vec2 = 1.0;
 529                                 ${OUTPUT}
 530                         }
 531                 ""
 532         end
 533         case vec3
 534                 expect compile_fail
 535                 values {}
 536
 537                 both ""
 538                         precision mediump float;
 539
 540                         ${DECLARATIONS}
 541
 542                         void main()
 543                         {
 544                                 ${SETUP}
 545                                 float vec3 = 1.0;
 546                                 ${OUTPUT}
 547                         }
 548                 ""
 549         end
 550         case vec4
 551                 expect compile_fail
 552                 values {}
 553
 554                 both ""
 555                         precision mediump float;
 556
 557                         ${DECLARATIONS}
 558
 559                         void main()
 560                         {
 561                                 ${SETUP}
 562                                 float vec4 = 1.0;
 563                                 ${OUTPUT}
 564                         }
 565                 ""
 566         end
 567         case ivec2
 568                 expect compile_fail
 569                 values {}
 570
 571                 both ""
 572                         precision mediump float;
 573
 574                         ${DECLARATIONS}
 575
 576                         void main()
 577                         {
 578                                 ${SETUP}
 579                                 float ivec2 = 1.0;
 580                                 ${OUTPUT}
 581                         }
 582                 ""
 583         end
 584         case ivec3
 585                 expect compile_fail
 586                 values {}
 587
 588                 both ""
 589                         precision mediump float;
 590
 591                         ${DECLARATIONS}
 592
 593                         void main()
 594                         {
 595                                 ${SETUP}
 596                                 float ivec3 = 1.0;
 597                                 ${OUTPUT}
 598                         }
 599                 ""
 600         end
 601         case ivec4
 602                 expect compile_fail
 603                 values {}
 604
 605                 both ""
 606                         precision mediump float;
 607
 608                         ${DECLARATIONS}
 609
 610                         void main()
 611                         {
 612                                 ${SETUP}
 613                                 float ivec4 = 1.0;
 614                                 ${OUTPUT}
 615                         }
 616                 ""
 617         end
 618         case bvec2
 619                 expect compile_fail
 620                 values {}
 621
 622                 both ""
 623                         precision mediump float;
 624
 625                         ${DECLARATIONS}
 626
 627                         void main()
 628                         {
 629                                 ${SETUP}
 630                                 float bvec2 = 1.0;
 631                                 ${OUTPUT}
 632                         }
 633                 ""
 634         end
 635         case bvec3
 636                 expect compile_fail
 637                 values {}
 638
 639                 both ""
 640                         precision mediump float;
 641
 642                         ${DECLARATIONS}
 643
 644                         void main()
 645                         {
 646                                 ${SETUP}
 647                                 float bvec3 = 1.0;
 648                                 ${OUTPUT}
 649                         }
 650                 ""
 651         end
 652         case bvec4
 653                 expect compile_fail
 654                 values {}
 655
 656                 both ""
 657                         precision mediump float;
 658
 659                         ${DECLARATIONS}
 660
 661                         void main()
 662                         {
 663                                 ${SETUP}
 664                                 float bvec4 = 1.0;
 665                                 ${OUTPUT}
 666                         }
 667                 ""
 668         end
 669         case sampler2D
 670                 expect compile_fail
 671                 values {}
 672
 673                 both ""
 674                         precision mediump float;
 675
 676                         ${DECLARATIONS}
 677
 678                         void main()
 679                         {
 680                                 ${SETUP}
 681                                 float sampler2D = 1.0;
 682                                 ${OUTPUT}
 683                         }
 684                 ""
 685         end
 686         case samplerCube
 687                 expect compile_fail
 688                 values {}
 689
 690                 both ""
 691                         precision mediump float;
 692
 693                         ${DECLARATIONS}
 694
 695                         void main()
 696                         {
 697                                 ${SETUP}
 698                                 float samplerCube = 1.0;
 699                                 ${OUTPUT}
 700                         }
 701                 ""
 702         end
 703         case struct
 704                 expect compile_fail
 705                 values {}
 706
 707                 both ""
 708                         precision mediump float;
 709
 710                         ${DECLARATIONS}
 711
 712                         void main()
 713                         {
 714                                 ${SETUP}
 715                                 float struct = 1.0;
 716                                 ${OUTPUT}
 717                         }
 718                 ""
 719         end
 720
 721 end # keywords
 722 group reserved_keywords "Usage of reserved keywords as identifiers."
 723
 724         case asm
 725                 expect compile_fail
 726                 values {}
 727
 728                 both ""
 729                         precision mediump float;
 730
 731                         ${DECLARATIONS}
 732
 733                         void main()
 734                         {
 735                                 ${SETUP}
 736                                 float asm = 1.0;
 737                                 ${OUTPUT}
 738                         }
 739                 ""
 740         end
 741         case class
 742                 expect compile_fail
 743                 values {}
 744
 745                 both ""
 746                         precision mediump float;
 747
 748                         ${DECLARATIONS}
 749
 750                         void main()
 751                         {
 752                                 ${SETUP}
 753                                 float class = 1.0;
 754                                 ${OUTPUT}
 755                         }
 756                 ""
 757         end
 758         case union
 759                 expect compile_fail
 760                 values {}
 761
 762                 both ""
 763                         precision mediump float;
 764
 765                         ${DECLARATIONS}
 766
 767                         void main()
 768                         {
 769                                 ${SETUP}
 770                                 float union = 1.0;
 771                                 ${OUTPUT}
 772                         }
 773                 ""
 774         end
 775         case enum
 776                 expect compile_fail
 777                 values {}
 778
 779                 both ""
 780                         precision mediump float;
 781
 782                         ${DECLARATIONS}
 783
 784                         void main()
 785                         {
 786                                 ${SETUP}
 787                                 float enum = 1.0;
 788                                 ${OUTPUT}
 789                         }
 790                 ""
 791         end
 792         case typedef
 793                 expect compile_fail
 794                 values {}
 795
 796                 both ""
 797                         precision mediump float;
 798
 799                         ${DECLARATIONS}
 800
 801                         void main()
 802                         {
 803                                 ${SETUP}
 804                                 float typedef = 1.0;
 805                                 ${OUTPUT}
 806                         }
 807                 ""
 808         end
 809         case template
 810                 expect compile_fail
 811                 values {}
 812
 813                 both ""
 814                         precision mediump float;
 815
 816                         ${DECLARATIONS}
 817
 818                         void main()
 819                         {
 820                                 ${SETUP}
 821                                 float template = 1.0;
 822                                 ${OUTPUT}
 823                         }
 824                 ""
 825         end
 826         case this
 827                 expect compile_fail
 828                 values {}
 829
 830                 both ""
 831                         precision mediump float;
 832
 833                         ${DECLARATIONS}
 834
 835                         void main()
 836                         {
 837                                 ${SETUP}
 838                                 float this = 1.0;
 839                                 ${OUTPUT}
 840                         }
 841                 ""
 842         end
 843         case packed
 844                 expect compile_fail
 845                 values {}
 846
 847                 both ""
 848                         precision mediump float;
 849
 850                         ${DECLARATIONS}
 851
 852                         void main()
 853                         {
 854                                 ${SETUP}
 855                                 float packed = 1.0;
 856                                 ${OUTPUT}
 857                         }
 858                 ""
 859         end
 860         case goto
 861                 expect compile_fail
 862                 values {}
 863
 864                 both ""
 865                         precision mediump float;
 866
 867                         ${DECLARATIONS}
 868
 869                         void main()
 870                         {
 871                                 ${SETUP}
 872                                 float goto = 1.0;
 873                                 ${OUTPUT}
 874                         }
 875                 ""
 876         end
 877         case switch
 878                 expect compile_fail
 879                 values {}
 880
 881                 both ""
 882                         precision mediump float;
 883
 884                         ${DECLARATIONS}
 885
 886                         void main()
 887                         {
 888                                 ${SETUP}
 889                                 float switch = 1.0;
 890                                 ${OUTPUT}
 891                         }
 892                 ""
 893         end
 894         case default
 895                 expect compile_fail
 896                 values {}
 897
 898                 both ""
 899                         precision mediump float;
 900
 901                         ${DECLARATIONS}
 902
 903                         void main()
 904                         {
 905                                 ${SETUP}
 906                                 float default = 1.0;
 907                                 ${OUTPUT}
 908                         }
 909                 ""
 910         end
 911         case inline
 912                 expect compile_fail
 913                 values {}
 914
 915                 both ""
 916                         precision mediump float;
 917
 918                         ${DECLARATIONS}
 919
 920                         void main()
 921                         {
 922                                 ${SETUP}
 923                                 float inline = 1.0;
 924                                 ${OUTPUT}
 925                         }
 926                 ""
 927         end
 928         case noinline
 929                 expect compile_fail
 930                 values {}
 931
 932                 both ""
 933                         precision mediump float;
 934
 935                         ${DECLARATIONS}
 936
 937                         void main()
 938                         {
 939                                 ${SETUP}
 940                                 float noinline = 1.0;
 941                                 ${OUTPUT}
 942                         }
 943                 ""
 944         end
 945         case volatile
 946                 expect compile_fail
 947                 values {}
 948
 949                 both ""
 950                         precision mediump float;
 951
 952                         ${DECLARATIONS}
 953
 954                         void main()
 955                         {
 956                                 ${SETUP}
 957                                 float volatile = 1.0;
 958                                 ${OUTPUT}
 959                         }
 960                 ""
 961         end
 962         case public
 963                 expect compile_fail
 964                 values {}
 965
 966                 both ""
 967                         precision mediump float;
 968
 969                         ${DECLARATIONS}
 970
 971                         void main()
 972                         {
 973                                 ${SETUP}
 974                                 float public = 1.0;
 975                                 ${OUTPUT}
 976                         }
 977                 ""
 978         end
 979         case static
 980                 expect compile_fail
 981                 values {}
 982
 983                 both ""
 984                         precision mediump float;
 985
 986                         ${DECLARATIONS}
 987
 988                         void main()
 989                         {
 990                                 ${SETUP}
 991                                 float static = 1.0;
 992                                 ${OUTPUT}
 993                         }
 994                 ""
 995         end
 996         case extern
 997                 expect compile_fail
 998                 values {}
 999
1000                 both ""
1001                         precision mediump float;
1002
1003                         ${DECLARATIONS}
1004
1005                         void main()
1006                         {
1007                                 ${SETUP}
1008                                 float extern = 1.0;
1009                                 ${OUTPUT}
1010                         }
1011                 ""
1012         end
1013         case external
1014                 expect compile_fail
1015                 values {}
1016
1017                 both ""
1018                         precision mediump float;
1019
1020                         ${DECLARATIONS}
1021
1022                         void main()
1023                         {
1024                                 ${SETUP}
1025                                 float external = 1.0;
1026                                 ${OUTPUT}
1027                         }
1028                 ""
1029         end
1030         case interface
1031                 expect compile_fail
1032                 values {}
1033
1034                 both ""
1035                         precision mediump float;
1036
1037                         ${DECLARATIONS}
1038
1039                         void main()
1040                         {
1041                                 ${SETUP}
1042                                 float interface = 1.0;
1043                                 ${OUTPUT}
1044                         }
1045                 ""
1046         end
1047         case flat
1048                 expect compile_fail
1049                 values {}
1050
1051                 both ""
1052                         precision mediump float;
1053
1054                         ${DECLARATIONS}
1055
1056                         void main()
1057                         {
1058                                 ${SETUP}
1059                                 float flat = 1.0;
1060                                 ${OUTPUT}
1061                         }
1062                 ""
1063         end
1064         case long
1065                 expect compile_fail
1066                 values {}
1067
1068                 both ""
1069                         precision mediump float;
1070
1071                         ${DECLARATIONS}
1072
1073                         void main()
1074                         {
1075                                 ${SETUP}
1076                                 float long = 1.0;
1077                                 ${OUTPUT}
1078                         }
1079                 ""
1080         end
1081         case short
1082                 expect compile_fail
1083                 values {}
1084
1085                 both ""
1086                         precision mediump float;
1087
1088                         ${DECLARATIONS}
1089
1090                         void main()
1091                         {
1092                                 ${SETUP}
1093                                 float short = 1.0;
1094                                 ${OUTPUT}
1095                         }
1096                 ""
1097         end
1098         case double
1099                 expect compile_fail
1100                 values {}
1101
1102                 both ""
1103                         precision mediump float;
1104
1105                         ${DECLARATIONS}
1106
1107                         void main()
1108                         {
1109                                 ${SETUP}
1110                                 float double = 1.0;
1111                                 ${OUTPUT}
1112                         }
1113                 ""
1114         end
1115         case half
1116                 expect compile_fail
1117                 values {}
1118
1119                 both ""
1120                         precision mediump float;
1121
1122                         ${DECLARATIONS}
1123
1124                         void main()
1125                         {
1126                                 ${SETUP}
1127                                 float half = 1.0;
1128                                 ${OUTPUT}
1129                         }
1130                 ""
1131         end
1132         case fixed
1133                 expect compile_fail
1134                 values {}
1135
1136                 both ""
1137                         precision mediump float;
1138
1139                         ${DECLARATIONS}
1140
1141                         void main()
1142                         {
1143                                 ${SETUP}
1144                                 float fixed = 1.0;
1145                                 ${OUTPUT}
1146                         }
1147                 ""
1148         end
1149         case unsigned
1150                 expect compile_fail
1151                 values {}
1152
1153                 both ""
1154                         precision mediump float;
1155
1156                         ${DECLARATIONS}
1157
1158                         void main()
1159                         {
1160                                 ${SETUP}
1161                                 float unsigned = 1.0;
1162                                 ${OUTPUT}
1163                         }
1164                 ""
1165         end
1166         case superp
1167                 expect compile_fail
1168                 values {}
1169
1170                 both ""
1171                         precision mediump float;
1172
1173                         ${DECLARATIONS}
1174
1175                         void main()
1176                         {
1177                                 ${SETUP}
1178                                 float superp = 1.0;
1179                                 ${OUTPUT}
1180                         }
1181                 ""
1182         end
1183         case input
1184                 expect compile_fail
1185                 values {}
1186
1187                 both ""
1188                         precision mediump float;
1189
1190                         ${DECLARATIONS}
1191
1192                         void main()
1193                         {
1194                                 ${SETUP}
1195                                 float input = 1.0;
1196                                 ${OUTPUT}
1197                         }
1198                 ""
1199         end
1200         case output
1201                 expect compile_fail
1202                 values {}
1203
1204                 both ""
1205                         precision mediump float;
1206
1207                         ${DECLARATIONS}
1208
1209                         void main()
1210                         {
1211                                 ${SETUP}
1212                                 float output = 1.0;
1213                                 ${OUTPUT}
1214                         }
1215                 ""
1216         end
1217         case hvec2
1218                 expect compile_fail
1219                 values {}
1220
1221                 both ""
1222                         precision mediump float;
1223
1224                         ${DECLARATIONS}
1225
1226                         void main()
1227                         {
1228                                 ${SETUP}
1229                                 float hvec2 = 1.0;
1230                                 ${OUTPUT}
1231                         }
1232                 ""
1233         end
1234         case hvec3
1235                 expect compile_fail
1236                 values {}
1237
1238                 both ""
1239                         precision mediump float;
1240
1241                         ${DECLARATIONS}
1242
1243                         void main()
1244                         {
1245                                 ${SETUP}
1246                                 float hvec3 = 1.0;
1247                                 ${OUTPUT}
1248                         }
1249                 ""
1250         end
1251         case hvec4
1252                 expect compile_fail
1253                 values {}
1254
1255                 both ""
1256                         precision mediump float;
1257
1258                         ${DECLARATIONS}
1259
1260                         void main()
1261                         {
1262                                 ${SETUP}
1263                                 float hvec4 = 1.0;
1264                                 ${OUTPUT}
1265                         }
1266                 ""
1267         end
1268         case dvec2
1269                 expect compile_fail
1270                 values {}
1271
1272                 both ""
1273                         precision mediump float;
1274
1275                         ${DECLARATIONS}
1276
1277                         void main()
1278                         {
1279                                 ${SETUP}
1280                                 float dvec2 = 1.0;
1281                                 ${OUTPUT}
1282                         }
1283                 ""
1284         end
1285         case dvec3
1286                 expect compile_fail
1287                 values {}
1288
1289                 both ""
1290                         precision mediump float;
1291
1292                         ${DECLARATIONS}
1293
1294                         void main()
1295                         {
1296                                 ${SETUP}
1297                                 float dvec3 = 1.0;
1298                                 ${OUTPUT}
1299                         }
1300                 ""
1301         end
1302         case dvec4
1303                 expect compile_fail
1304                 values {}
1305
1306                 both ""
1307                         precision mediump float;
1308
1309                         ${DECLARATIONS}
1310
1311                         void main()
1312                         {
1313                                 ${SETUP}
1314                                 float dvec4 = 1.0;
1315                                 ${OUTPUT}
1316                         }
1317                 ""
1318         end
1319         case fvec2
1320                 expect compile_fail
1321                 values {}
1322
1323                 both ""
1324                         precision mediump float;
1325
1326                         ${DECLARATIONS}
1327
1328                         void main()
1329                         {
1330                                 ${SETUP}
1331                                 float fvec2 = 1.0;
1332                                 ${OUTPUT}
1333                         }
1334                 ""
1335         end
1336         case fvec3
1337                 expect compile_fail
1338                 values {}
1339
1340                 both ""
1341                         precision mediump float;
1342
1343                         ${DECLARATIONS}
1344
1345                         void main()
1346                         {
1347                                 ${SETUP}
1348                                 float fvec3 = 1.0;
1349                                 ${OUTPUT}
1350                         }
1351                 ""
1352         end
1353         case fvec4
1354                 expect compile_fail
1355                 values {}
1356
1357                 both ""
1358                         precision mediump float;
1359
1360                         ${DECLARATIONS}
1361
1362                         void main()
1363                         {
1364                                 ${SETUP}
1365                                 float fvec4 = 1.0;
1366                                 ${OUTPUT}
1367                         }
1368                 ""
1369         end
1370         case sampler1D
1371                 expect compile_fail
1372                 values {}
1373
1374                 both ""
1375                         precision mediump float;
1376
1377                         ${DECLARATIONS}
1378
1379                         void main()
1380                         {
1381                                 ${SETUP}
1382                                 float sampler1D = 1.0;
1383                                 ${OUTPUT}
1384                         }
1385                 ""
1386         end
1387         case sampler3D
1388                 expect compile_fail
1389                 values {}
1390
1391                 both ""
1392                         precision mediump float;
1393
1394                         ${DECLARATIONS}
1395
1396                         void main()
1397                         {
1398                                 ${SETUP}
1399                                 float sampler3D = 1.0;
1400                                 ${OUTPUT}
1401                         }
1402                 ""
1403         end
1404         case sampler1DShadow
1405                 expect compile_fail
1406                 values {}
1407
1408                 both ""
1409                         precision mediump float;
1410
1411                         ${DECLARATIONS}
1412
1413                         void main()
1414                         {
1415                                 ${SETUP}
1416                                 float sampler1DShadow = 1.0;
1417                                 ${OUTPUT}
1418                         }
1419                 ""
1420         end
1421         case sampler2DShadow
1422                 expect compile_fail
1423                 values {}
1424
1425                 both ""
1426                         precision mediump float;
1427
1428                         ${DECLARATIONS}
1429
1430                         void main()
1431                         {
1432                                 ${SETUP}
1433                                 float sampler2DShadow = 1.0;
1434                                 ${OUTPUT}
1435                         }
1436                 ""
1437         end
1438         case sampler2DRect
1439                 expect compile_fail
1440                 values {}
1441
1442                 both ""
1443                         precision mediump float;
1444
1445                         ${DECLARATIONS}
1446
1447                         void main()
1448                         {
1449                                 ${SETUP}
1450                                 float sampler2DRect = 1.0;
1451                                 ${OUTPUT}
1452                         }
1453                 ""
1454         end
1455         case sampler3DRect
1456                 expect compile_fail
1457                 values {}
1458
1459                 both ""
1460                         precision mediump float;
1461
1462                         ${DECLARATIONS}
1463
1464                         void main()
1465                         {
1466                                 ${SETUP}
1467                                 float sampler3DRect = 1.0;
1468                                 ${OUTPUT}
1469                         }
1470                 ""
1471         end
1472         case sampler2DRectShadow
1473                 expect compile_fail
1474                 values {}
1475
1476                 both ""
1477                         precision mediump float;
1478
1479                         ${DECLARATIONS}
1480
1481                         void main()
1482                         {
1483                                 ${SETUP}
1484                                 float sampler2DRectShadow = 1.0;
1485                                 ${OUTPUT}
1486                         }
1487                 ""
1488         end
1489         case sizeof
1490                 expect compile_fail
1491                 values {}
1492
1493                 both ""
1494                         precision mediump float;
1495
1496                         ${DECLARATIONS}
1497
1498                         void main()
1499                         {
1500                                 ${SETUP}
1501                                 float sizeof = 1.0;
1502                                 ${OUTPUT}
1503                         }
1504                 ""
1505         end
1506         case cast
1507                 expect compile_fail
1508                 values {}
1509
1510                 both ""
1511                         precision mediump float;
1512
1513                         ${DECLARATIONS}
1514
1515                         void main()
1516                         {
1517                                 ${SETUP}
1518                                 float cast = 1.0;
1519                                 ${OUTPUT}
1520                         }
1521                 ""
1522         end
1523         case namespace
1524                 expect compile_fail
1525                 values {}
1526
1527                 both ""
1528                         precision mediump float;
1529
1530                         ${DECLARATIONS}
1531
1532                         void main()
1533                         {
1534                                 ${SETUP}
1535                                 float namespace = 1.0;
1536                                 ${OUTPUT}
1537                         }
1538                 ""
1539         end
1540         case using
1541                 expect compile_fail
1542                 values {}
1543
1544                 both ""
1545                         precision mediump float;
1546
1547                         ${DECLARATIONS}
1548
1549                         void main()
1550                         {
1551                                 ${SETUP}
1552                                 float using = 1.0;
1553                                 ${OUTPUT}
1554                         }
1555                 ""
1556         end
1557
1558 end # reserved_keywords
1559 group invalid_identifiers "Usage of invalid identifiers."
1560
1561         case gl_begin
1562                 expect compile_fail
1563                 values {}
1564
1565                 both ""
1566                         precision mediump float;
1567
1568                         ${DECLARATIONS}
1569
1570                         void main()
1571                         {
1572                                 ${SETUP}
1573                                 float gl_Invalid = 1.0;
1574                                 ${OUTPUT}
1575                         }
1576                 ""
1577         end
1578         case digit
1579                 expect compile_fail
1580                 values {}
1581
1582                 both ""
1583                         precision mediump float;
1584
1585                         ${DECLARATIONS}
1586
1587                         void main()
1588                         {
1589                                 ${SETUP}
1590                                 float 0123 = 1.0;
1591                                 ${OUTPUT}
1592                         }
1593                 ""
1594         end
1595         case digit_begin
1596                 expect compile_fail
1597                 values {}
1598
1599                 both ""
1600                         precision mediump float;
1601
1602                         ${DECLARATIONS}
1603
1604                         void main()
1605                         {
1606                                 ${SETUP}
1607                                 float 0invalid = 1.0;
1608                                 ${OUTPUT}
1609                         }
1610                 ""
1611         end
1612
1613 end # invalid_identifiers