NV fp parser: Support new scalar constant behavior
authorIan Romanick <ian.d.romanick@intel.com>
Thu, 3 Sep 2009 21:05:18 +0000 (14:05 -0700)
committerIan Romanick <ian.d.romanick@intel.com>
Thu, 3 Sep 2009 21:05:18 +0000 (14:05 -0700)
ARBfp requires scalar constants have a '.x' suffix, but NVfp_option
does not.  This shows up with instructions that require a scalar
parameter (e.g., COS).

src/mesa/shader/program_parse.tab.c
src/mesa/shader/program_parse.y

index 06aefd073fdc3eb2f65e98fcf579250e9dae8a38..508ac617e4a9b33f37b6f61de4c7f67e68655041 100644 (file)
@@ -588,16 +588,16 @@ union yyalloc
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  5
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   349
+#define YYLAST   351
 
 /* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  116
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  135
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  266
+#define YYNRULES  267
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  447
+#define YYNSTATES  448
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
@@ -657,29 +657,29 @@ static const yytype_uint16 yyprhs[] =
       24,    27,    30,    32,    34,    36,    38,    40,    42,    44,
       46,    48,    50,    52,    54,    59,    64,    69,    76,    83,
       92,   101,   104,   117,   120,   122,   124,   126,   128,   130,
-     132,   134,   136,   138,   140,   142,   144,   151,   155,   159,
-     162,   165,   173,   176,   178,   180,   182,   184,   189,   191,
-     193,   195,   197,   199,   201,   203,   207,   208,   211,   214,
-     216,   218,   220,   222,   224,   226,   228,   230,   232,   233,
-     235,   237,   239,   241,   242,   244,   246,   248,   250,   252,
-     254,   259,   262,   265,   267,   270,   272,   275,   277,   280,
-     285,   290,   292,   293,   297,   299,   301,   304,   306,   309,
-     311,   313,   317,   324,   325,   327,   330,   335,   337,   341,
-     343,   345,   347,   349,   351,   353,   355,   357,   359,   361,
+     132,   134,   136,   138,   140,   142,   144,   151,   155,   158,
+     162,   165,   168,   176,   179,   181,   183,   185,   187,   192,
+     194,   196,   198,   200,   202,   204,   206,   210,   211,   214,
+     217,   219,   221,   223,   225,   227,   229,   231,   233,   235,
+     236,   238,   240,   242,   244,   245,   247,   249,   251,   253,
+     255,   257,   262,   265,   268,   270,   273,   275,   278,   280,
+     283,   288,   293,   295,   296,   300,   302,   304,   307,   309,
+     312,   314,   316,   320,   327,   328,   330,   333,   338,   340,
+     344,   346,   348,   350,   352,   354,   356,   358,   360,   362,
      364,   367,   370,   373,   376,   379,   382,   385,   388,   391,
-     394,   397,   401,   403,   405,   407,   413,   415,   417,   419,
-     422,   424,   426,   429,   431,   434,   441,   443,   447,   449,
-     451,   453,   455,   457,   462,   464,   466,   468,   470,   472,
-     474,   477,   479,   481,   487,   489,   492,   494,   496,   502,
-     505,   506,   513,   517,   518,   520,   522,   524,   526,   528,
-     531,   533,   535,   538,   543,   548,   549,   551,   553,   555,
-     557,   560,   562,   564,   566,   568,   574,   576,   580,   586,
-     592,   594,   598,   604,   606,   608,   610,   612,   614,   616,
-     618,   620,   622,   626,   632,   640,   650,   653,   656,   658,
-     660,   661,   662,   666,   667,   671,   675,   677,   682,   685,
-     688,   691,   694,   698,   701,   705,   706,   708,   710,   711,
-     713,   715,   716,   718,   720,   721,   723,   725,   726,   730,
-     731,   735,   736,   740,   742,   744,   746
+     394,   397,   400,   404,   406,   408,   410,   416,   418,   420,
+     422,   425,   427,   429,   432,   434,   437,   444,   446,   450,
+     452,   454,   456,   458,   460,   465,   467,   469,   471,   473,
+     475,   477,   480,   482,   484,   490,   492,   495,   497,   499,
+     505,   508,   509,   516,   520,   521,   523,   525,   527,   529,
+     531,   534,   536,   538,   541,   546,   551,   552,   554,   556,
+     558,   560,   563,   565,   567,   569,   571,   577,   579,   583,
+     589,   595,   597,   601,   607,   609,   611,   613,   615,   617,
+     619,   621,   623,   625,   629,   635,   643,   653,   656,   659,
+     661,   663,   664,   665,   669,   670,   674,   678,   680,   685,
+     688,   691,   694,   697,   701,   704,   708,   709,   711,   713,
+     714,   716,   718,   719,   721,   723,   724,   726,   728,   729,
+     733,   734,   738,   739,   743,   745,   747,   749
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
@@ -700,67 +700,67 @@ static const yytype_int16 yyrhs[] =
       84,    -1,    85,    -1,    86,    -1,    87,    -1,    88,    -1,
       89,    -1,    90,    -1,    91,    -1,    92,    -1,    93,    -1,
       94,    -1,    95,    -1,    21,   140,   108,   145,   108,   142,
-      -1,   231,   145,   157,    -1,   231,   145,   158,    -1,   146,
-     159,    -1,   154,   156,    -1,   143,   108,   143,   108,   143,
-     108,   143,    -1,   231,   144,    -1,    23,    -1,    99,    -1,
-      99,    -1,   162,    -1,   147,   109,   148,   110,    -1,   176,
-      -1,   238,    -1,    99,    -1,    99,    -1,   149,    -1,   150,
-      -1,    23,    -1,   154,   155,   151,    -1,    -1,   111,   152,
-      -1,   112,   153,    -1,    23,    -1,    23,    -1,    99,    -1,
-     103,    -1,   103,    -1,   103,    -1,   103,    -1,   100,    -1,
-     104,    -1,    -1,   100,    -1,   101,    -1,   102,    -1,   103,
-      -1,    -1,   161,    -1,   168,    -1,   232,    -1,   234,    -1,
-     237,    -1,   250,    -1,     7,    99,   113,   162,    -1,    96,
-     163,    -1,    38,   167,    -1,    60,    -1,    98,   165,    -1,
-      53,    -1,    29,   243,    -1,    37,    -1,    74,   244,    -1,
-      50,   109,   166,   110,    -1,    97,   109,   164,   110,    -1,
-      23,    -1,    -1,   109,   166,   110,    -1,    23,    -1,    60,
-      -1,    29,   243,    -1,    37,    -1,    74,   244,    -1,   169,
-      -1,   170,    -1,    10,    99,   172,    -1,    10,    99,   109,
-     171,   110,   173,    -1,    -1,    23,    -1,   113,   175,    -1,
-     113,   114,   174,   115,    -1,   177,    -1,   174,   108,   177,
-      -1,   179,    -1,   215,    -1,   225,    -1,   179,    -1,   215,
-      -1,   226,    -1,   178,    -1,   216,    -1,   225,    -1,   179,
-      -1,    73,   203,    -1,    73,   180,    -1,    73,   182,    -1,
-      73,   185,    -1,    73,   187,    -1,    73,   193,    -1,    73,
-     189,    -1,    73,   196,    -1,    73,   198,    -1,    73,   200,
-      -1,    73,   202,    -1,    73,   214,    -1,    47,   242,   181,
-      -1,   191,    -1,    33,    -1,    69,    -1,    43,   109,   192,
-     110,   183,    -1,   191,    -1,    60,    -1,    26,    -1,    72,
-     184,    -1,    40,    -1,    32,    -1,    44,   186,    -1,    25,
-      -1,   242,    67,    -1,    45,   109,   192,   110,   242,   188,
-      -1,   191,    -1,    75,   246,   190,    -1,    29,    -1,    25,
-      -1,    31,    -1,    71,    -1,    23,    -1,    76,   244,   194,
-     195,    -1,    35,    -1,    54,    -1,    79,    -1,    80,    -1,
-      78,    -1,    77,    -1,    36,   197,    -1,    29,    -1,    56,
-      -1,    28,   109,   199,   110,    57,    -1,    23,    -1,    58,
-     201,    -1,    70,    -1,    26,    -1,   205,    66,   109,   208,
-     110,    -1,   205,   204,    -1,    -1,    66,   109,   208,   105,
-     208,   110,    -1,    49,   209,   206,    -1,    -1,   207,    -1,
-      41,    -1,    82,    -1,    42,    -1,    23,    -1,    51,   210,
-      -1,    63,    -1,    52,    -1,    81,   244,    -1,    55,   109,
-     212,   110,    -1,    48,   109,   213,   110,    -1,    -1,   211,
-      -1,    23,    -1,    23,    -1,    23,    -1,    30,    64,    -1,
-     219,    -1,   222,    -1,   217,    -1,   220,    -1,    62,    34,
-     109,   218,   110,    -1,   223,    -1,   223,   105,   223,    -1,
-      62,    34,   109,   223,   110,    -1,    62,    46,   109,   221,
-     110,    -1,   224,    -1,   224,   105,   224,    -1,    62,    46,
-     109,   224,   110,    -1,    23,    -1,    23,    -1,   227,    -1,
-     229,    -1,   228,    -1,   229,    -1,   230,    -1,    24,    -1,
-      23,    -1,   114,   230,   115,    -1,   114,   230,   108,   230,
-     115,    -1,   114,   230,   108,   230,   108,   230,   115,    -1,
-     114,   230,   108,   230,   108,   230,   108,   230,   115,    -1,
-     231,    24,    -1,   231,    23,    -1,   111,    -1,   112,    -1,
-      -1,    -1,    11,   233,   236,    -1,    -1,     5,   235,   236,
-      -1,   236,   108,    99,    -1,    99,    -1,     9,    99,   113,
-     238,    -1,    65,    60,    -1,    65,    37,    -1,    65,   239,
-      -1,    65,    59,    -1,    65,    74,   244,    -1,    65,    30,
-      -1,    29,   240,   241,    -1,    -1,    39,    -1,    27,    -1,
-      -1,    61,    -1,    68,    -1,    -1,    39,    -1,    27,    -1,
-      -1,    61,    -1,    68,    -1,    -1,   109,   247,   110,    -1,
-      -1,   109,   248,   110,    -1,    -1,   109,   249,   110,    -1,
-      23,    -1,    23,    -1,    23,    -1,     6,    99,   113,    99,
-      -1
+      -1,   231,   145,   157,    -1,   231,   228,    -1,   231,   145,
+     158,    -1,   146,   159,    -1,   154,   156,    -1,   143,   108,
+     143,   108,   143,   108,   143,    -1,   231,   144,    -1,    23,
+      -1,    99,    -1,    99,    -1,   162,    -1,   147,   109,   148,
+     110,    -1,   176,    -1,   238,    -1,    99,    -1,    99,    -1,
+     149,    -1,   150,    -1,    23,    -1,   154,   155,   151,    -1,
+      -1,   111,   152,    -1,   112,   153,    -1,    23,    -1,    23,
+      -1,    99,    -1,   103,    -1,   103,    -1,   103,    -1,   103,
+      -1,   100,    -1,   104,    -1,    -1,   100,    -1,   101,    -1,
+     102,    -1,   103,    -1,    -1,   161,    -1,   168,    -1,   232,
+      -1,   234,    -1,   237,    -1,   250,    -1,     7,    99,   113,
+     162,    -1,    96,   163,    -1,    38,   167,    -1,    60,    -1,
+      98,   165,    -1,    53,    -1,    29,   243,    -1,    37,    -1,
+      74,   244,    -1,    50,   109,   166,   110,    -1,    97,   109,
+     164,   110,    -1,    23,    -1,    -1,   109,   166,   110,    -1,
+      23,    -1,    60,    -1,    29,   243,    -1,    37,    -1,    74,
+     244,    -1,   169,    -1,   170,    -1,    10,    99,   172,    -1,
+      10,    99,   109,   171,   110,   173,    -1,    -1,    23,    -1,
+     113,   175,    -1,   113,   114,   174,   115,    -1,   177,    -1,
+     174,   108,   177,    -1,   179,    -1,   215,    -1,   225,    -1,
+     179,    -1,   215,    -1,   226,    -1,   178,    -1,   216,    -1,
+     225,    -1,   179,    -1,    73,   203,    -1,    73,   180,    -1,
+      73,   182,    -1,    73,   185,    -1,    73,   187,    -1,    73,
+     193,    -1,    73,   189,    -1,    73,   196,    -1,    73,   198,
+      -1,    73,   200,    -1,    73,   202,    -1,    73,   214,    -1,
+      47,   242,   181,    -1,   191,    -1,    33,    -1,    69,    -1,
+      43,   109,   192,   110,   183,    -1,   191,    -1,    60,    -1,
+      26,    -1,    72,   184,    -1,    40,    -1,    32,    -1,    44,
+     186,    -1,    25,    -1,   242,    67,    -1,    45,   109,   192,
+     110,   242,   188,    -1,   191,    -1,    75,   246,   190,    -1,
+      29,    -1,    25,    -1,    31,    -1,    71,    -1,    23,    -1,
+      76,   244,   194,   195,    -1,    35,    -1,    54,    -1,    79,
+      -1,    80,    -1,    78,    -1,    77,    -1,    36,   197,    -1,
+      29,    -1,    56,    -1,    28,   109,   199,   110,    57,    -1,
+      23,    -1,    58,   201,    -1,    70,    -1,    26,    -1,   205,
+      66,   109,   208,   110,    -1,   205,   204,    -1,    -1,    66,
+     109,   208,   105,   208,   110,    -1,    49,   209,   206,    -1,
+      -1,   207,    -1,    41,    -1,    82,    -1,    42,    -1,    23,
+      -1,    51,   210,    -1,    63,    -1,    52,    -1,    81,   244,
+      -1,    55,   109,   212,   110,    -1,    48,   109,   213,   110,
+      -1,    -1,   211,    -1,    23,    -1,    23,    -1,    23,    -1,
+      30,    64,    -1,   219,    -1,   222,    -1,   217,    -1,   220,
+      -1,    62,    34,   109,   218,   110,    -1,   223,    -1,   223,
+     105,   223,    -1,    62,    34,   109,   223,   110,    -1,    62,
+      46,   109,   221,   110,    -1,   224,    -1,   224,   105,   224,
+      -1,    62,    46,   109,   224,   110,    -1,    23,    -1,    23,
+      -1,   227,    -1,   229,    -1,   228,    -1,   229,    -1,   230,
+      -1,    24,    -1,    23,    -1,   114,   230,   115,    -1,   114,
+     230,   108,   230,   115,    -1,   114,   230,   108,   230,   108,
+     230,   115,    -1,   114,   230,   108,   230,   108,   230,   108,
+     230,   115,    -1,   231,    24,    -1,   231,    23,    -1,   111,
+      -1,   112,    -1,    -1,    -1,    11,   233,   236,    -1,    -1,
+       5,   235,   236,    -1,   236,   108,    99,    -1,    99,    -1,
+       9,    99,   113,   238,    -1,    65,    60,    -1,    65,    37,
+      -1,    65,   239,    -1,    65,    59,    -1,    65,    74,   244,
+      -1,    65,    30,    -1,    29,   240,   241,    -1,    -1,    39,
+      -1,    27,    -1,    -1,    61,    -1,    68,    -1,    -1,    39,
+      -1,    27,    -1,    -1,    61,    -1,    68,    -1,    -1,   109,
+     247,   110,    -1,    -1,   109,   248,   110,    -1,    -1,   109,
+     249,   110,    -1,    23,    -1,    23,    -1,    23,    -1,     6,
+      99,   113,    99,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
@@ -770,29 +770,29 @@ static const yytype_uint16 yyrline[] =
      309,   324,   327,   332,   339,   340,   341,   342,   343,   344,
      345,   348,   349,   350,   353,   359,   366,   373,   381,   388,
      396,   441,   448,   493,   499,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   513,   526,   539,   552,
-     574,   583,   616,   623,   638,   688,   730,   741,   762,   772,
-     778,   809,   826,   826,   828,   835,   847,   848,   849,   852,
-     864,   876,   894,   905,   917,   919,   920,   921,   922,   925,
-     925,   925,   925,   926,   929,   930,   931,   932,   933,   934,
-     937,   955,   959,   965,   969,   973,   977,   986,   995,   999,
-    1004,  1010,  1021,  1021,  1022,  1024,  1028,  1032,  1036,  1042,
-    1042,  1044,  1060,  1083,  1086,  1097,  1103,  1109,  1110,  1117,
-    1123,  1129,  1137,  1143,  1149,  1157,  1163,  1169,  1177,  1178,
-    1181,  1182,  1183,  1184,  1185,  1186,  1187,  1188,  1189,  1190,
-    1191,  1194,  1203,  1207,  1211,  1217,  1226,  1230,  1234,  1243,
-    1247,  1253,  1259,  1266,  1271,  1279,  1289,  1291,  1299,  1305,
-    1309,  1313,  1319,  1330,  1339,  1343,  1348,  1352,  1356,  1360,
-    1366,  1373,  1377,  1383,  1391,  1402,  1409,  1413,  1419,  1429,
-    1440,  1444,  1462,  1471,  1474,  1480,  1484,  1488,  1494,  1505,
-    1510,  1515,  1520,  1525,  1530,  1538,  1541,  1546,  1559,  1567,
-    1578,  1586,  1586,  1588,  1588,  1590,  1600,  1605,  1612,  1622,
-    1631,  1636,  1643,  1653,  1663,  1675,  1675,  1676,  1676,  1678,
-    1688,  1696,  1706,  1714,  1722,  1731,  1742,  1746,  1752,  1753,
-    1754,  1757,  1757,  1760,  1760,  1763,  1769,  1777,  1790,  1799,
-    1808,  1812,  1821,  1830,  1841,  1848,  1853,  1862,  1874,  1877,
-    1886,  1897,  1898,  1899,  1902,  1903,  1904,  1907,  1908,  1911,
-    1912,  1915,  1916,  1919,  1930,  1941,  1952
+     505,   506,   507,   508,   509,   510,   513,   526,   537,   556,
+     569,   591,   600,   633,   640,   655,   705,   747,   758,   779,
+     789,   795,   826,   843,   843,   845,   852,   864,   865,   866,
+     869,   881,   893,   911,   922,   934,   936,   937,   938,   939,
+     942,   942,   942,   942,   943,   946,   947,   948,   949,   950,
+     951,   954,   972,   976,   982,   986,   990,   994,  1003,  1012,
+    1016,  1021,  1027,  1038,  1038,  1039,  1041,  1045,  1049,  1053,
+    1059,  1059,  1061,  1077,  1100,  1103,  1114,  1120,  1126,  1127,
+    1134,  1140,  1146,  1154,  1160,  1166,  1174,  1180,  1186,  1194,
+    1195,  1198,  1199,  1200,  1201,  1202,  1203,  1204,  1205,  1206,
+    1207,  1208,  1211,  1220,  1224,  1228,  1234,  1243,  1247,  1251,
+    1260,  1264,  1270,  1276,  1283,  1288,  1296,  1306,  1308,  1316,
+    1322,  1326,  1330,  1336,  1347,  1356,  1360,  1365,  1369,  1373,
+    1377,  1383,  1390,  1394,  1400,  1408,  1419,  1426,  1430,  1436,
+    1446,  1457,  1461,  1479,  1488,  1491,  1497,  1501,  1505,  1511,
+    1522,  1527,  1532,  1537,  1542,  1547,  1555,  1558,  1563,  1576,
+    1584,  1595,  1603,  1603,  1605,  1605,  1607,  1617,  1622,  1629,
+    1639,  1648,  1653,  1660,  1670,  1680,  1692,  1692,  1693,  1693,
+    1695,  1705,  1713,  1723,  1731,  1739,  1748,  1759,  1763,  1769,
+    1770,  1771,  1774,  1774,  1777,  1777,  1780,  1786,  1794,  1807,
+    1816,  1825,  1829,  1838,  1847,  1858,  1865,  1870,  1879,  1891,
+    1894,  1903,  1914,  1915,  1916,  1919,  1920,  1921,  1924,  1925,
+    1928,  1929,  1932,  1933,  1936,  1947,  1958,  1969
 };
 #endif
 
@@ -890,29 +890,29 @@ static const yytype_uint8 yyr1[] =
      122,   122,   123,   123,   124,   124,   124,   124,   124,   124,
      124,   125,   125,   125,   126,   127,   128,   129,   130,   131,
      132,   133,   134,   135,   136,   136,   136,   136,   136,   136,
-     136,   136,   136,   136,   136,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   144,   145,   145,   145,   145,   146,
-     146,   147,   148,   148,   149,   150,   151,   151,   151,   152,
-     153,   154,   155,   156,   157,   158,   158,   158,   158,   159,
-     159,   159,   159,   159,   160,   160,   160,   160,   160,   160,
-     161,   162,   162,   163,   163,   163,   163,   163,   163,   163,
-     163,   164,   165,   165,   166,   167,   167,   167,   167,   168,
-     168,   169,   170,   171,   171,   172,   173,   174,   174,   175,
-     175,   175,   176,   176,   176,   177,   177,   177,   178,   178,
-     179,   179,   179,   179,   179,   179,   179,   179,   179,   179,
-     179,   180,   181,   181,   181,   182,   183,   183,   183,   183,
-     183,   184,   185,   186,   186,   187,   188,   189,   190,   191,
-     191,   191,   192,   193,   194,   194,   195,   195,   195,   195,
-     196,   197,   197,   198,   199,   200,   201,   201,   202,   203,
-     204,   204,   205,   206,   206,   207,   207,   207,   208,   209,
-     209,   209,   209,   209,   209,   210,   210,   211,   212,   213,
-     214,   215,   215,   216,   216,   217,   218,   218,   219,   220,
-     221,   221,   222,   223,   224,   225,   225,   226,   226,   227,
-     228,   228,   229,   229,   229,   229,   230,   230,   231,   231,
-     231,   233,   232,   235,   234,   236,   236,   237,   238,   238,
-     238,   238,   238,   238,   239,   240,   240,   240,   241,   241,
-     241,   242,   242,   242,   243,   243,   243,   244,   244,   245,
-     245,   246,   246,   247,   248,   249,   250
+     136,   136,   136,   136,   136,   136,   137,   138,   138,   139,
+     140,   141,   142,   143,   144,   144,   145,   145,   145,   145,
+     146,   146,   147,   148,   148,   149,   150,   151,   151,   151,
+     152,   153,   154,   155,   156,   157,   158,   158,   158,   158,
+     159,   159,   159,   159,   159,   160,   160,   160,   160,   160,
+     160,   161,   162,   162,   163,   163,   163,   163,   163,   163,
+     163,   163,   164,   165,   165,   166,   167,   167,   167,   167,
+     168,   168,   169,   170,   171,   171,   172,   173,   174,   174,
+     175,   175,   175,   176,   176,   176,   177,   177,   177,   178,
+     178,   179,   179,   179,   179,   179,   179,   179,   179,   179,
+     179,   179,   180,   181,   181,   181,   182,   183,   183,   183,
+     183,   183,   184,   185,   186,   186,   187,   188,   189,   190,
+     191,   191,   191,   192,   193,   194,   194,   195,   195,   195,
+     195,   196,   197,   197,   198,   199,   200,   201,   201,   202,
+     203,   204,   204,   205,   206,   206,   207,   207,   207,   208,
+     209,   209,   209,   209,   209,   209,   210,   210,   211,   212,
+     213,   214,   215,   215,   216,   216,   217,   218,   218,   219,
+     220,   221,   221,   222,   223,   224,   225,   225,   226,   226,
+     227,   228,   228,   229,   229,   229,   229,   230,   230,   231,
+     231,   231,   233,   232,   235,   234,   236,   236,   237,   238,
+     238,   238,   238,   238,   238,   239,   240,   240,   240,   241,
+     241,   241,   242,   242,   242,   243,   243,   243,   244,   244,
+     245,   245,   246,   246,   247,   248,   249,   250
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -922,29 +922,29 @@ static const yytype_uint8 yyr2[] =
        2,     2,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     4,     4,     4,     6,     6,     8,
        8,     2,    12,     2,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     6,     3,     3,     2,
-       2,     7,     2,     1,     1,     1,     1,     4,     1,     1,
-       1,     1,     1,     1,     1,     3,     0,     2,     2,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     0,     1,
-       1,     1,     1,     0,     1,     1,     1,     1,     1,     1,
-       4,     2,     2,     1,     2,     1,     2,     1,     2,     4,
-       4,     1,     0,     3,     1,     1,     2,     1,     2,     1,
-       1,     3,     6,     0,     1,     2,     4,     1,     3,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
+       1,     1,     1,     1,     1,     1,     6,     3,     2,     3,
+       2,     2,     7,     2,     1,     1,     1,     1,     4,     1,
+       1,     1,     1,     1,     1,     1,     3,     0,     2,     2,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
+       1,     1,     1,     1,     0,     1,     1,     1,     1,     1,
+       1,     4,     2,     2,     1,     2,     1,     2,     1,     2,
+       4,     4,     1,     0,     3,     1,     1,     2,     1,     2,
+       1,     1,     3,     6,     0,     1,     2,     4,     1,     3,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     3,     1,     1,     1,     5,     1,     1,     1,     2,
-       1,     1,     2,     1,     2,     6,     1,     3,     1,     1,
-       1,     1,     1,     4,     1,     1,     1,     1,     1,     1,
-       2,     1,     1,     5,     1,     2,     1,     1,     5,     2,
-       0,     6,     3,     0,     1,     1,     1,     1,     1,     2,
-       1,     1,     2,     4,     4,     0,     1,     1,     1,     1,
-       2,     1,     1,     1,     1,     5,     1,     3,     5,     5,
-       1,     3,     5,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     3,     5,     7,     9,     2,     2,     1,     1,
-       0,     0,     3,     0,     3,     3,     1,     4,     2,     2,
-       2,     2,     3,     2,     3,     0,     1,     1,     0,     1,
-       1,     0,     1,     1,     0,     1,     1,     0,     3,     0,
-       3,     0,     3,     1,     1,     1,     4
+       2,     2,     3,     1,     1,     1,     5,     1,     1,     1,
+       2,     1,     1,     2,     1,     2,     6,     1,     3,     1,
+       1,     1,     1,     1,     4,     1,     1,     1,     1,     1,
+       1,     2,     1,     1,     5,     1,     2,     1,     1,     5,
+       2,     0,     6,     3,     0,     1,     1,     1,     1,     1,
+       2,     1,     1,     2,     4,     4,     0,     1,     1,     1,
+       1,     2,     1,     1,     1,     1,     5,     1,     3,     5,
+       5,     1,     3,     5,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     3,     5,     7,     9,     2,     2,     1,
+       1,     0,     0,     3,     0,     3,     3,     1,     4,     2,
+       2,     2,     2,     3,     2,     3,     0,     1,     1,     0,
+       1,     1,     0,     1,     1,     0,     1,     1,     0,     3,
+       0,     3,     0,     3,     1,     1,     1,     4
 };
 
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -953,223 +953,225 @@ static const yytype_uint8 yyr2[] =
 static const yytype_uint16 yydefact[] =
 {
        0,     3,     4,     0,     6,     1,     9,     0,     5,     0,
-       0,   233,     0,     0,     0,     0,   231,     2,     0,     0,
-       0,     0,     0,     0,     0,   230,     0,     0,     8,     0,
+       0,   234,     0,     0,     0,     0,   232,     2,     0,     0,
+       0,     0,     0,     0,     0,   231,     0,     0,     8,     0,
       12,    13,    14,    15,    16,    17,    18,    19,    21,    22,
-      23,    20,     0,    84,    85,   109,   110,    86,    87,    88,
-      89,     7,     0,     0,     0,     0,     0,     0,     0,    60,
-       0,    83,    59,     0,     0,     0,     0,     0,    71,     0,
-       0,   228,   229,    31,     0,     0,     0,    10,    11,   236,
-     234,     0,     0,     0,   113,   230,   111,   232,   245,   243,
-     239,   241,   238,   257,   240,   230,    79,    80,    81,    82,
-      49,   230,   230,   230,   230,   230,   230,    73,    50,   221,
-     220,     0,     0,     0,     0,    55,   230,    78,     0,    56,
-      58,   122,   123,   201,   202,   124,   217,   218,     0,   230,
-       0,   266,    90,   237,   114,     0,   115,   119,   120,   121,
-     215,   216,   219,     0,   247,   246,   248,     0,   242,     0,
-       0,     0,     0,    26,     0,    25,    24,   254,   107,   105,
-     257,    92,     0,     0,     0,     0,     0,     0,   251,     0,
-     251,     0,     0,   261,   257,   130,   131,   132,   133,   135,
-     134,   136,   137,   138,   139,     0,   140,   254,    97,     0,
-      95,    93,   257,     0,   102,    91,     0,    76,    75,    77,
-      48,     0,     0,     0,   235,     0,   227,   226,   249,   250,
-     244,   263,     0,   230,   230,     0,     0,   230,   255,   256,
-     106,   108,     0,     0,     0,   200,   171,   172,   170,     0,
-     153,   253,   252,   152,     0,     0,     0,     0,   195,   191,
-       0,   190,   257,   183,   177,   176,   175,     0,     0,     0,
-       0,    96,     0,    98,     0,     0,    94,   230,   222,    64,
-       0,    62,    63,     0,   230,   230,     0,   112,   258,    28,
-      27,    74,    47,   259,     0,     0,   213,     0,   214,     0,
-     174,     0,   162,     0,   154,     0,   159,   160,   143,   144,
-     161,   141,   142,     0,   197,   189,   196,     0,   192,   185,
-     187,   186,   182,   184,   265,     0,   158,   157,   164,   165,
-       0,     0,   104,     0,   101,     0,     0,     0,    57,    72,
-      66,    46,     0,     0,     0,   230,     0,    33,     0,   230,
-     208,   212,     0,     0,   251,   199,     0,   198,     0,   262,
-     169,   168,   166,   167,   163,   188,     0,    99,   100,   103,
-     230,   223,     0,     0,    65,   230,    53,    54,    52,   230,
-       0,     0,     0,   117,   125,   128,   126,   203,   204,   127,
-     264,     0,    34,    35,    36,    37,    38,    39,    40,    41,
-      42,    43,    44,    45,    30,    29,   173,   148,   150,   147,
-       0,   145,   146,     0,   194,   193,   178,     0,    69,    67,
-      70,    68,     0,     0,     0,     0,   129,   180,   230,   116,
-     260,   151,   149,   155,   156,   230,   224,   230,     0,     0,
-       0,     0,   179,   118,     0,     0,     0,     0,   206,     0,
-     210,     0,   225,   230,     0,   205,     0,   209,     0,     0,
-      51,    32,   207,   211,     0,     0,   181
+      23,    20,     0,    85,    86,   110,   111,    87,    88,    89,
+      90,     7,     0,     0,     0,     0,     0,     0,     0,    61,
+       0,    84,    60,     0,     0,     0,     0,     0,    72,     0,
+       0,   229,   230,    31,     0,     0,     0,    10,    11,   237,
+     235,     0,     0,     0,   114,   231,   112,   233,   246,   244,
+     240,   242,   239,   258,   241,   231,    80,    81,    82,    83,
+      50,   231,   231,   231,   231,   231,   231,    74,    51,   222,
+     221,     0,     0,     0,     0,    56,   231,    79,     0,    57,
+      59,   123,   124,   202,   203,   125,   218,   219,     0,   231,
+       0,   267,    91,   238,   115,     0,   116,   120,   121,   122,
+     216,   217,   220,     0,   248,   247,   249,     0,   243,     0,
+       0,     0,     0,    26,     0,    25,    24,   255,   108,   106,
+     258,    93,     0,     0,     0,     0,     0,     0,   252,     0,
+     252,     0,     0,   262,   258,   131,   132,   133,   134,   136,
+     135,   137,   138,   139,   140,     0,   141,   255,    98,     0,
+      96,    94,   258,     0,   103,    92,     0,    77,    76,    78,
+      49,     0,     0,     0,   236,     0,   228,   227,   250,   251,
+     245,   264,     0,   231,   231,     0,    48,     0,   231,   256,
+     257,   107,   109,     0,     0,     0,   201,   172,   173,   171,
+       0,   154,   254,   253,   153,     0,     0,     0,     0,   196,
+     192,     0,   191,   258,   184,   178,   177,   176,     0,     0,
+       0,     0,    97,     0,    99,     0,     0,    95,   231,   223,
+      65,     0,    63,    64,     0,   231,   231,     0,   113,   259,
+      28,    27,    75,    47,   260,     0,     0,   214,     0,   215,
+       0,   175,     0,   163,     0,   155,     0,   160,   161,   144,
+     145,   162,   142,   143,     0,   198,   190,   197,     0,   193,
+     186,   188,   187,   183,   185,   266,     0,   159,   158,   165,
+     166,     0,     0,   105,     0,   102,     0,     0,     0,    58,
+      73,    67,    46,     0,     0,     0,   231,     0,    33,     0,
+     231,   209,   213,     0,     0,   252,   200,     0,   199,     0,
+     263,   170,   169,   167,   168,   164,   189,     0,   100,   101,
+     104,   231,   224,     0,     0,    66,   231,    54,    55,    53,
+     231,     0,     0,     0,   118,   126,   129,   127,   204,   205,
+     128,   265,     0,    34,    35,    36,    37,    38,    39,    40,
+      41,    42,    43,    44,    45,    30,    29,   174,   149,   151,
+     148,     0,   146,   147,     0,   195,   194,   179,     0,    70,
+      68,    71,    69,     0,     0,     0,     0,   130,   181,   231,
+     117,   261,   152,   150,   156,   157,   231,   225,   231,     0,
+       0,     0,     0,   180,   119,     0,     0,     0,     0,   207,
+       0,   211,     0,   226,   231,     0,   206,     0,   210,     0,
+       0,    52,    32,   208,   212,     0,     0,   182
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
       -1,     3,     4,     6,     8,     9,    28,    29,    30,    31,
-      32,    33,    34,    35,    36,    37,    38,    39,    40,   274,
-     384,    41,   150,    73,    60,    69,   321,   322,   358,   117,
-      61,   118,   260,   261,   262,   354,   399,   401,    70,   320,
-     108,   272,   200,   100,    42,    43,   119,   195,   315,   256,
-     313,   161,    44,    45,    46,   135,    86,   267,   362,   136,
-     120,   363,   364,   121,   175,   291,   176,   391,   412,   177,
-     233,   178,   413,   179,   307,   292,   283,   180,   310,   344,
-     181,   228,   182,   281,   183,   246,   184,   406,   422,   185,
-     302,   303,   346,   243,   295,   296,   338,   336,   186,   122,
-     366,   367,   427,   123,   368,   429,   124,   277,   279,   369,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,   275,
+     385,    41,   150,    73,    60,    69,   322,   323,   359,   117,
+      61,   118,   261,   262,   263,   355,   400,   402,    70,   321,
+     108,   273,   200,   100,    42,    43,   119,   195,   316,   257,
+     314,   161,    44,    45,    46,   135,    86,   268,   363,   136,
+     120,   364,   365,   121,   175,   292,   176,   392,   413,   177,
+     234,   178,   414,   179,   308,   293,   284,   180,   311,   345,
+     181,   229,   182,   282,   183,   247,   184,   407,   423,   185,
+     303,   304,   347,   244,   296,   297,   339,   337,   186,   122,
+     367,   368,   428,   123,   369,   430,   124,   278,   280,   370,
      125,   140,   126,   127,   142,    74,    47,    57,    48,    52,
-      80,    49,    62,    94,   146,   210,   234,   220,   148,   327,
-     248,   212,   371,   305,    50
+      80,    49,    62,    94,   146,   210,   235,   221,   148,   328,
+     249,   212,   372,   306,    50
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -384
+#define YYPACT_NINF -399
 static const yytype_int16 yypact[] =
 {
-     167,  -384,  -384,    37,  -384,  -384,    60,   -70,  -384,   171,
-     -23,  -384,   -13,     9,    12,    63,  -384,  -384,   -33,   -33,
-     -33,   -33,   -33,   -33,    67,   104,   -33,   -33,  -384,    66,
-    -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,
-    -384,  -384,    68,  -384,  -384,  -384,  -384,  -384,  -384,  -384,
-    -384,  -384,   115,   109,   111,   112,    -4,   115,    22,  -384,
-     113,   106,  -384,   118,   120,   121,   122,   123,  -384,   124,
-     130,  -384,  -384,  -384,   -16,   126,   127,  -384,  -384,  -384,
-     128,   140,   -18,   158,   204,   -39,  -384,   128,    26,  -384,
-    -384,  -384,  -384,   134,  -384,   104,  -384,  -384,  -384,  -384,
-    -384,   104,   104,   104,   104,   104,   104,  -384,  -384,  -384,
-    -384,    73,    84,    76,   -10,   135,   104,    64,   136,  -384,
-    -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,   -16,   104,
-     147,  -384,  -384,  -384,  -384,   137,  -384,  -384,  -384,  -384,
-    -384,  -384,  -384,   194,  -384,  -384,    46,   225,  -384,   141,
-     142,   -16,   143,  -384,   144,  -384,  -384,    87,  -384,  -384,
-     134,  -384,   145,   146,   148,   189,    15,   149,    88,   150,
-      97,    80,     0,   151,   134,  -384,  -384,  -384,  -384,  -384,
-    -384,  -384,  -384,  -384,  -384,   190,  -384,    87,  -384,   152,
-    -384,  -384,   134,   153,   154,  -384,    42,  -384,  -384,  -384,
-    -384,    -8,   156,   159,  -384,   160,  -384,  -384,  -384,  -384,
-    -384,  -384,   161,   104,   104,   163,   186,   104,  -384,  -384,
-    -384,  -384,   249,   251,   252,  -384,  -384,  -384,  -384,   253,
-    -384,  -384,  -384,  -384,   210,   253,     8,   169,   256,  -384,
-     172,  -384,   134,    21,  -384,  -384,  -384,   257,   254,    -7,
-     173,  -384,   261,  -384,   262,   261,  -384,   104,  -384,  -384,
-     176,  -384,  -384,   184,   104,   104,   174,  -384,  -384,  -384,
-    -384,  -384,  -384,   180,   182,   183,  -384,   185,  -384,   187,
-    -384,   188,  -384,   191,  -384,   193,  -384,  -384,  -384,  -384,
-    -384,  -384,  -384,   269,  -384,  -384,  -384,   270,  -384,  -384,
-    -384,  -384,  -384,  -384,  -384,   195,  -384,  -384,  -384,  -384,
-     133,   271,  -384,   196,  -384,   197,   198,    45,  -384,  -384,
-     108,  -384,   192,    -6,   201,   -17,   273,  -384,   110,   104,
-    -384,  -384,   242,    29,    97,  -384,   200,  -384,   202,  -384,
-    -384,  -384,  -384,  -384,  -384,  -384,   203,  -384,  -384,  -384,
-     104,  -384,   281,   288,  -384,   104,  -384,  -384,  -384,   104,
-     103,    76,    48,  -384,  -384,  -384,  -384,  -384,  -384,  -384,
-    -384,   205,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,
-    -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,
-     282,  -384,  -384,     5,  -384,  -384,  -384,    50,  -384,  -384,
-    -384,  -384,   208,   209,   211,   212,  -384,   260,   -17,  -384,
-    -384,  -384,  -384,  -384,  -384,   104,  -384,   104,   186,   249,
-     251,   213,  -384,  -384,   214,   219,   220,   221,   228,   224,
-     230,   271,  -384,   104,   110,  -384,   249,  -384,   251,    49,
-    -384,  -384,  -384,  -384,   271,   226,  -384
+     154,  -399,  -399,    48,  -399,  -399,    51,   -37,  -399,   172,
+      -2,  -399,    17,    31,    42,    47,  -399,  -399,   -33,   -33,
+     -33,   -33,   -33,   -33,    54,    56,   -33,   -33,  -399,     6,
+    -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,
+    -399,  -399,    52,  -399,  -399,  -399,  -399,  -399,  -399,  -399,
+    -399,  -399,    66,    25,    61,   112,    -6,    66,   102,  -399,
+     118,   116,  -399,   119,   120,   121,   122,   123,  -399,   124,
+     130,  -399,  -399,  -399,   -16,   126,   127,  -399,  -399,  -399,
+     128,    70,   -15,   159,   214,   -36,  -399,   128,    28,  -399,
+    -399,  -399,  -399,   131,  -399,    56,  -399,  -399,  -399,  -399,
+    -399,    56,    56,    56,    56,    56,    56,  -399,  -399,  -399,
+    -399,    27,    38,    76,    -9,   135,    56,    60,   136,  -399,
+    -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,   -16,    56,
+     147,  -399,  -399,  -399,  -399,   137,  -399,  -399,  -399,  -399,
+    -399,  -399,  -399,   148,  -399,  -399,    18,   225,  -399,   141,
+     142,   -16,   144,  -399,   145,  -399,  -399,    50,  -399,  -399,
+     131,  -399,   146,   149,   150,   187,     7,   151,    43,   152,
+      69,    85,    -1,   153,   131,  -399,  -399,  -399,  -399,  -399,
+    -399,  -399,  -399,  -399,  -399,   190,  -399,    50,  -399,   155,
+    -399,  -399,   131,   156,   158,  -399,    20,  -399,  -399,  -399,
+    -399,    -8,   160,   162,  -399,   161,  -399,  -399,  -399,  -399,
+    -399,  -399,   163,    56,    56,   169,   173,   171,    56,  -399,
+    -399,  -399,  -399,   234,   240,   252,  -399,  -399,  -399,  -399,
+     254,  -399,  -399,  -399,  -399,   211,   254,     2,   170,   257,
+    -399,   174,  -399,   131,    12,  -399,  -399,  -399,   258,   253,
+      -5,   175,  -399,   262,  -399,   263,   262,  -399,    56,  -399,
+    -399,   177,  -399,  -399,   185,    56,    56,   176,  -399,  -399,
+    -399,  -399,  -399,  -399,   180,   183,   184,  -399,   186,  -399,
+     189,  -399,   191,  -399,   192,  -399,   194,  -399,  -399,  -399,
+    -399,  -399,  -399,  -399,   270,  -399,  -399,  -399,   271,  -399,
+    -399,  -399,  -399,  -399,  -399,  -399,   195,  -399,  -399,  -399,
+    -399,   143,   272,  -399,   196,  -399,   197,   198,    34,  -399,
+    -399,   101,  -399,   201,    -4,   202,   -12,   274,  -399,   111,
+      56,  -399,  -399,   241,    84,    69,  -399,   203,  -399,   204,
+    -399,  -399,  -399,  -399,  -399,  -399,  -399,   205,  -399,  -399,
+    -399,    56,  -399,   277,   288,  -399,    56,  -399,  -399,  -399,
+      56,    80,    76,    35,  -399,  -399,  -399,  -399,  -399,  -399,
+    -399,  -399,   206,  -399,  -399,  -399,  -399,  -399,  -399,  -399,
+    -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,
+    -399,   280,  -399,  -399,    14,  -399,  -399,  -399,    39,  -399,
+    -399,  -399,  -399,   209,   210,   212,   213,  -399,   261,   -12,
+    -399,  -399,  -399,  -399,  -399,  -399,    56,  -399,    56,   171,
+     234,   240,   219,  -399,  -399,   208,   221,   222,   224,   215,
+     226,   227,   272,  -399,    56,   111,  -399,   234,  -399,   240,
+     -13,  -399,  -399,  -399,  -399,   272,   228,  -399
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,
-    -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -100,
-    -115,  -384,   -97,   -91,   119,  -384,  -384,  -343,  -384,   -93,
-    -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,   138,  -384,
-    -384,  -384,  -384,  -384,  -384,  -384,   255,  -384,  -384,  -384,
-      83,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,
-    -384,   -68,  -384,   -84,  -384,  -384,  -384,  -384,  -384,  -384,
-    -384,  -384,  -384,  -384,  -384,  -308,   107,  -384,  -384,  -384,
-    -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,  -384,   -20,
-    -384,  -384,  -383,  -384,  -384,  -384,  -384,  -384,  -384,   258,
-    -384,  -384,  -384,  -384,  -384,  -384,  -384,  -320,  -371,   259,
-    -384,  -384,  -384,   -83,  -113,   -85,  -384,  -384,  -384,  -384,
-     289,  -384,   264,  -384,  -384,  -384,  -165,   162,  -150,  -384,
-    -384,  -384,  -384,  -384,  -384
+    -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,
+    -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -100,
+     -98,  -399,   -97,   -91,   188,  -399,  -399,  -344,  -399,   -99,
+    -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,   134,  -399,
+    -399,  -399,  -399,  -399,  -399,  -399,   259,  -399,  -399,  -399,
+      83,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,
+    -399,   -69,  -399,   -84,  -399,  -399,  -399,  -399,  -399,  -399,
+    -399,  -399,  -399,  -399,  -399,  -317,   106,  -399,  -399,  -399,
+    -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,   -19,
+    -399,  -399,  -398,  -399,  -399,  -399,  -399,  -399,  -399,   260,
+    -399,  -399,  -399,  -399,  -399,  -399,  -399,  -377,  -381,   265,
+    -399,  -399,   193,   -83,  -113,   -85,  -399,  -399,  -399,  -399,
+     289,  -399,   264,  -399,  -399,  -399,  -165,   164,  -150,  -399,
+    -399,  -399,  -399,  -399,  -399
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
    If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -62
+#define YYTABLE_NINF -219
 static const yytype_int16 yytable[] =
 {
-     143,   137,   141,   196,   149,   236,   153,   109,   110,   156,
-     221,   152,   402,   154,   155,   259,   151,   356,   151,   187,
-     111,   151,   111,   112,   249,   392,   244,   188,   308,    10,
-     286,   143,    58,   286,   113,   202,   287,     5,   203,   287,
-     189,   288,   253,   190,   226,   360,   112,   309,   439,   430,
-     191,    88,    89,   144,   286,   387,   361,   113,   215,    90,
-     287,   445,   299,   300,   192,   145,    59,   443,     7,   388,
-     245,   227,    71,    72,   425,   116,   290,   289,   114,   290,
-     114,    91,    92,   115,    51,   414,    53,   193,   194,   389,
-     440,    68,   298,   357,    71,    72,    93,   116,   116,   428,
-     290,   390,   157,   301,   164,    84,   165,   208,    54,    85,
-     158,    55,   166,   230,   209,   231,   442,   270,   162,   167,
-     168,   169,   269,   170,   231,   171,   275,   232,   237,   151,
-     163,   238,   239,   159,   172,   240,   232,   404,    63,    64,
-      65,    66,    67,   241,   317,    75,    76,   160,   218,   405,
-     257,   173,   174,   350,   444,   219,   408,   258,   415,   396,
-     351,   242,    56,   409,   197,   416,    68,   198,   199,   393,
-       1,     2,   143,    77,   324,    78,    11,    12,    13,   323,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    27,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,    96,    97,    98,    99,
-     340,   341,   342,   343,    79,    71,    72,   206,   207,   352,
-     353,    95,    81,    58,    82,    83,   101,   134,   102,   103,
-     104,   105,   106,   107,   128,   129,   130,   397,   385,   131,
-     143,   365,   141,   147,   -61,   201,   204,   205,   211,   213,
-     214,   216,   217,   225,   222,   223,   250,   224,   229,   235,
-     247,   252,   254,   255,   264,   143,   271,   265,   403,   273,
-     323,   268,   276,   266,   278,   280,   282,   284,   293,   294,
-     304,   297,   311,   306,   312,   314,   318,   319,   325,   326,
-     328,   329,   335,   337,   345,   330,   370,   331,   332,   386,
-     355,   333,   424,   334,   398,   339,   347,   348,   349,   359,
-     394,   400,   395,   396,   411,   410,   417,   418,   426,   441,
-     419,   420,   431,   143,   365,   141,   421,   433,   434,   432,
-     143,   435,   323,   436,   437,   438,   446,   132,   316,   263,
-     423,   407,   285,   138,   139,     0,    87,   133,   323,   251
+     143,   137,   141,   196,   149,   237,   153,   109,   110,   156,
+     222,   152,   403,   154,   155,   260,   151,   393,   151,   357,
+     187,   151,   111,   111,   250,   245,   112,   287,   188,   202,
+     309,   143,    58,   288,   440,   289,   227,   113,   203,   287,
+     431,   189,   254,   429,   190,   288,   112,   446,     5,   310,
+     361,   191,   215,   300,   301,   144,   157,   113,   444,     7,
+     443,   362,    10,   228,   158,   192,    59,   145,   231,   246,
+     232,   290,   162,   291,   426,    71,    72,   415,   116,   208,
+     114,   114,   233,   115,   163,   291,   209,   159,   193,   194,
+     441,    68,   445,   299,   302,   358,   232,   397,   116,    71,
+      72,   160,   116,    84,   164,    51,   165,    85,   233,   287,
+     388,   219,   166,    77,   405,   288,    53,   271,   220,   167,
+     168,   169,   270,   170,   389,   171,   406,   276,   258,   151,
+      54,    88,    89,   238,   172,   259,   239,   240,    81,    90,
+     241,    55,   351,   409,   390,   318,    56,   416,   242,   352,
+     410,   173,   174,    68,   417,   291,   391,     1,     2,    78,
+     197,    91,    92,   198,   199,    79,   243,    71,    72,   131,
+     394,   206,   207,   143,    82,   325,    93,    11,    12,    13,
+     324,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    27,   373,   374,   375,   376,   377,
+     378,   379,   380,   381,   382,   383,   384,    63,    64,    65,
+      66,    67,   353,   354,    75,    76,    96,    97,    98,    99,
+     341,   342,   343,   344,    58,    83,    95,   101,   102,   103,
+     104,   105,   106,   107,   128,   129,   130,   134,   398,   386,
+     147,   143,   366,   141,   -62,   201,   204,   205,   211,   213,
+     214,   226,   217,   218,   274,   223,   251,   277,   224,   225,
+     230,   236,   248,   279,   253,   255,   143,   256,   265,   404,
+     266,   324,   272,   269,   267,   281,  -218,   283,   285,   294,
+     295,   305,   307,   298,   312,   313,   315,   319,   320,   327,
+     326,   329,   330,   336,   338,   346,   331,   371,   387,   332,
+     399,   333,   334,   425,   335,   340,   348,   349,   350,   356,
+     360,   401,   412,   395,   396,   397,   411,   418,   419,   427,
+     437,   420,   421,   433,   143,   366,   141,   422,   432,   434,
+     435,   143,   439,   324,   436,   264,   438,   442,   447,   317,
+     424,   132,   286,   408,   216,   138,    87,   133,     0,   324,
+     139,   252
 };
 
 static const yytype_int16 yycheck[] =
 {
       85,    85,    85,   116,    95,   170,   103,    23,    24,   106,
-     160,   102,   355,   104,   105,    23,   101,    23,   103,    29,
-      38,   106,    38,    62,   174,   333,    26,    37,    35,    99,
-      25,   116,    65,    25,    73,   128,    31,     0,   129,    31,
-      50,    33,   192,    53,    29,    62,    62,    54,   431,   420,
-      60,    29,    30,    27,    25,    26,    73,    73,   151,    37,
-      31,   444,    41,    42,    74,    39,    99,   438,     8,    40,
-      70,    56,   111,   112,   417,   114,    71,    69,    96,    71,
-      96,    59,    60,    99,   107,   393,    99,    97,    98,    60,
-     433,    99,   242,    99,   111,   112,    74,   114,   114,   419,
-      71,    72,    29,    82,    28,   109,    30,    61,    99,   113,
-      37,    99,    36,    25,    68,    27,   436,   214,    34,    43,
-      44,    45,   213,    47,    27,    49,   217,    39,    48,   214,
-      46,    51,    52,    60,    58,    55,    39,    34,    19,    20,
-      21,    22,    23,    63,   257,    26,    27,    74,    61,    46,
-     108,    75,    76,   108,   105,    68,   108,   115,   108,   110,
-     115,    81,    99,   115,   100,   115,    99,   103,   104,   334,
-       3,     4,   257,   107,   265,   107,     5,     6,     7,   264,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,   100,   101,   102,   103,
-      77,    78,    79,    80,    99,   111,   112,    23,    24,   111,
-     112,   108,   113,    65,   113,   113,   108,    23,   108,   108,
-     108,   108,   108,   103,   108,   108,   108,   350,   329,    99,
-     325,   325,   325,   109,   109,   109,    99,   110,    23,   108,
-     108,   108,   108,    64,   109,   109,    66,   109,   109,   109,
-     109,   109,   109,   109,   108,   350,   103,   108,   359,    83,
-     355,   110,    23,   113,    23,    23,    23,    67,   109,    23,
-      23,   109,   109,    29,    23,    23,   110,   103,   114,   109,
-     108,   108,    23,    23,    23,   110,    23,   110,   110,    57,
-     108,   110,   415,   110,    23,   110,   110,   110,   110,   108,
-     110,    23,   110,   110,    32,   110,   108,   108,   418,   434,
-     109,   109,   109,   408,   408,   408,    66,   108,   108,   115,
-     415,   110,   417,   105,   110,   105,   110,    82,   255,   201,
-     408,   361,   235,    85,    85,    -1,    57,    83,   433,   187
+     160,   102,   356,   104,   105,    23,   101,   334,   103,    23,
+      29,   106,    38,    38,   174,    26,    62,    25,    37,   128,
+      35,   116,    65,    31,   432,    33,    29,    73,   129,    25,
+     421,    50,   192,   420,    53,    31,    62,   445,     0,    54,
+      62,    60,   151,    41,    42,    27,    29,    73,   439,     8,
+     437,    73,    99,    56,    37,    74,    99,    39,    25,    70,
+      27,    69,    34,    71,   418,   111,   112,   394,   114,    61,
+      96,    96,    39,    99,    46,    71,    68,    60,    97,    98,
+     434,    99,   105,   243,    82,    99,    27,   110,   114,   111,
+     112,    74,   114,   109,    28,   107,    30,   113,    39,    25,
+      26,    61,    36,   107,    34,    31,    99,   214,    68,    43,
+      44,    45,   213,    47,    40,    49,    46,   218,   108,   214,
+      99,    29,    30,    48,    58,   115,    51,    52,   113,    37,
+      55,    99,   108,   108,    60,   258,    99,   108,    63,   115,
+     115,    75,    76,    99,   115,    71,    72,     3,     4,   107,
+     100,    59,    60,   103,   104,    99,    81,   111,   112,    99,
+     335,    23,    24,   258,   113,   266,    74,     5,     6,     7,
+     265,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    19,    20,    21,
+      22,    23,   111,   112,    26,    27,   100,   101,   102,   103,
+      77,    78,    79,    80,    65,   113,   108,   108,   108,   108,
+     108,   108,   108,   103,   108,   108,   108,    23,   351,   330,
+     109,   326,   326,   326,   109,   109,    99,   110,    23,   108,
+     108,    64,   108,   108,    83,   109,    66,    23,   109,   109,
+     109,   109,   109,    23,   109,   109,   351,   109,   108,   360,
+     108,   356,   103,   110,   113,    23,   103,    23,    67,   109,
+      23,    23,    29,   109,   109,    23,    23,   110,   103,   109,
+     114,   108,   108,    23,    23,    23,   110,    23,    57,   110,
+      23,   110,   110,   416,   110,   110,   110,   110,   110,   108,
+     108,    23,    32,   110,   110,   110,   110,   108,   108,   419,
+     105,   109,   109,   115,   409,   409,   409,    66,   109,   108,
+     108,   416,   105,   418,   110,   201,   110,   435,   110,   256,
+     409,    82,   236,   362,   151,    85,    57,    83,    -1,   434,
+      85,   187
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -1197,30 +1199,30 @@ static const yytype_uint8 yystos[] =
      193,   196,   198,   200,   202,   205,   214,    29,    37,    50,
       53,    60,    74,    97,    98,   163,   230,   100,   103,   104,
      158,   109,   145,   139,    99,   110,    23,    24,    61,    68,
-     241,    23,   247,   108,   108,   145,   108,   108,    61,    68,
-     243,   244,   109,   109,   109,    64,    29,    56,   197,   109,
-      25,    27,    39,   186,   242,   109,   242,    48,    51,    52,
-      55,    63,    81,   209,    26,    70,   201,   109,   246,   244,
-      66,   243,   109,   244,   109,   109,   165,   108,   115,    23,
-     148,   149,   150,   154,   108,   108,   113,   173,   110,   139,
-     138,   103,   157,    83,   135,   139,    23,   223,    23,   224,
-      23,   199,    23,   192,    67,   192,    25,    31,    33,    69,
-      71,   181,   191,   109,    23,   210,   211,   109,   244,    41,
-      42,    82,   206,   207,    23,   249,    29,   190,    35,    54,
-     194,   109,    23,   166,    23,   164,   166,   230,   110,   103,
-     155,   142,   143,   231,   139,   114,   109,   245,   108,   108,
-     110,   110,   110,   110,   110,    23,   213,    23,   212,   110,
-      77,    78,    79,    80,   195,    23,   208,   110,   110,   110,
-     108,   115,   111,   112,   151,   108,    23,    99,   144,   108,
-      62,    73,   174,   177,   178,   179,   216,   217,   220,   225,
-      23,   248,    84,    85,    86,    87,    88,    89,    90,    91,
-      92,    93,    94,    95,   136,   139,    57,    26,    40,    60,
-      72,   183,   191,   242,   110,   110,   110,   230,    23,   152,
-      23,   153,   143,   139,    34,    46,   203,   205,   108,   115,
-     110,    32,   184,   188,   191,   108,   115,   108,   108,   109,
-     109,    66,   204,   177,   230,   143,   135,   218,   223,   221,
-     224,   109,   115,   108,   108,   110,   105,   110,   105,   208,
-     143,   136,   223,   224,   105,   208,   110
+     241,    23,   247,   108,   108,   145,   228,   108,   108,    61,
+      68,   243,   244,   109,   109,   109,    64,    29,    56,   197,
+     109,    25,    27,    39,   186,   242,   109,   242,    48,    51,
+      52,    55,    63,    81,   209,    26,    70,   201,   109,   246,
+     244,    66,   243,   109,   244,   109,   109,   165,   108,   115,
+      23,   148,   149,   150,   154,   108,   108,   113,   173,   110,
+     139,   138,   103,   157,    83,   135,   139,    23,   223,    23,
+     224,    23,   199,    23,   192,    67,   192,    25,    31,    33,
+      69,    71,   181,   191,   109,    23,   210,   211,   109,   244,
+      41,    42,    82,   206,   207,    23,   249,    29,   190,    35,
+      54,   194,   109,    23,   166,    23,   164,   166,   230,   110,
+     103,   155,   142,   143,   231,   139,   114,   109,   245,   108,
+     108,   110,   110,   110,   110,   110,    23,   213,    23,   212,
+     110,    77,    78,    79,    80,   195,    23,   208,   110,   110,
+     110,   108,   115,   111,   112,   151,   108,    23,    99,   144,
+     108,    62,    73,   174,   177,   178,   179,   216,   217,   220,
+     225,    23,   248,    84,    85,    86,    87,    88,    89,    90,
+      91,    92,    93,    94,    95,   136,   139,    57,    26,    40,
+      60,    72,   183,   191,   242,   110,   110,   110,   230,    23,
+     152,    23,   153,   143,   139,    34,    46,   203,   205,   108,
+     115,   110,    32,   184,   188,   191,   108,   115,   108,   108,
+     109,   109,    66,   204,   177,   230,   143,   135,   218,   223,
+     221,   224,   109,   115,   108,   108,   110,   105,   110,   105,
+     208,   143,   136,   223,   224,   105,   208,   110
 };
 
 #define yyerrok                (yyerrstatus = 0)
@@ -2457,7 +2459,29 @@ yyreduce:
   case 48:
 
 /* Line 1455 of yacc.c  */
-#line 540 "program_parse.y"
+#line 538 "program_parse.y"
+    {
+          struct asm_symbol temp_sym;
+
+          if (!state->option.NV_fragment) {
+             yyerror(& (yylsp[(2) - (2)]), state, "expected scalar suffix");
+             YYERROR;
+          }
+
+          memset(& temp_sym, 0, sizeof(temp_sym));
+          temp_sym.param_binding_begin = ~0;
+          initialize_symbol_from_const(state->prog, & temp_sym, & (yyvsp[(2) - (2)].vector));
+
+          init_src_reg(& (yyval.src_reg));
+          (yyval.src_reg).Base.File = PROGRAM_CONSTANT;
+          (yyval.src_reg).Base.Index = temp_sym.param_binding_begin;
+       ;}
+    break;
+
+  case 49:
+
+/* Line 1455 of yacc.c  */
+#line 557 "program_parse.y"
     {
           (yyval.src_reg) = (yyvsp[(2) - (3)].src_reg);
 
@@ -2470,10 +2494,10 @@ yyreduce:
        ;}
     break;
 
-  case 49:
+  case 50:
 
 /* Line 1455 of yacc.c  */
-#line 553 "program_parse.y"
+#line 570 "program_parse.y"
     {
           (yyval.dst_reg) = (yyvsp[(1) - (2)].dst_reg);
           (yyval.dst_reg).WriteMask = (yyvsp[(2) - (2)].swiz_mask).mask;
@@ -2495,10 +2519,10 @@ yyreduce:
        ;}
     break;
 
-  case 50:
+  case 51:
 
 /* Line 1455 of yacc.c  */
-#line 575 "program_parse.y"
+#line 592 "program_parse.y"
     {
           init_dst_reg(& (yyval.dst_reg));
           (yyval.dst_reg).File = PROGRAM_ADDRESS;
@@ -2507,10 +2531,10 @@ yyreduce:
        ;}
     break;
 
-  case 51:
+  case 52:
 
 /* Line 1455 of yacc.c  */
-#line 584 "program_parse.y"
+#line 601 "program_parse.y"
     {
           const unsigned xyzw_valid =
              ((yyvsp[(1) - (7)].ext_swizzle).xyzw_valid << 0)
@@ -2543,20 +2567,20 @@ yyreduce:
        ;}
     break;
 
-  case 52:
+  case 53:
 
 /* Line 1455 of yacc.c  */
-#line 617 "program_parse.y"
+#line 634 "program_parse.y"
     {
           (yyval.ext_swizzle) = (yyvsp[(2) - (2)].ext_swizzle);
           (yyval.ext_swizzle).negate = ((yyvsp[(1) - (2)].negate)) ? 1 : 0;
        ;}
     break;
 
-  case 53:
+  case 54:
 
 /* Line 1455 of yacc.c  */
-#line 624 "program_parse.y"
+#line 641 "program_parse.y"
     {
           if (((yyvsp[(1) - (1)].integer) != 0) && ((yyvsp[(1) - (1)].integer) != 1)) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid extended swizzle selector");
@@ -2573,10 +2597,10 @@ yyreduce:
        ;}
     break;
 
-  case 54:
+  case 55:
 
 /* Line 1455 of yacc.c  */
-#line 639 "program_parse.y"
+#line 656 "program_parse.y"
     {
           if (strlen((yyvsp[(1) - (1)].string)) > 1) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid extended swizzle selector");
@@ -2626,10 +2650,10 @@ yyreduce:
        ;}
     break;
 
-  case 55:
+  case 56:
 
 /* Line 1455 of yacc.c  */
-#line 689 "program_parse.y"
+#line 706 "program_parse.y"
     {
           struct asm_symbol *const s = (struct asm_symbol *)
              _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(1) - (1)].string));
@@ -2673,10 +2697,10 @@ yyreduce:
        ;}
     break;
 
-  case 56:
+  case 57:
 
 /* Line 1455 of yacc.c  */
-#line 731 "program_parse.y"
+#line 748 "program_parse.y"
     {
           init_src_reg(& (yyval.src_reg));
           (yyval.src_reg).Base.File = PROGRAM_INPUT;
@@ -2689,10 +2713,10 @@ yyreduce:
        ;}
     break;
 
-  case 57:
+  case 58:
 
 /* Line 1455 of yacc.c  */
-#line 742 "program_parse.y"
+#line 759 "program_parse.y"
     {
           if (! (yyvsp[(3) - (4)].src_reg).Base.RelAddr
               && ((unsigned) (yyvsp[(3) - (4)].src_reg).Base.Index >= (yyvsp[(1) - (4)].sym)->param_binding_length)) {
@@ -2715,10 +2739,10 @@ yyreduce:
        ;}
     break;
 
-  case 58:
+  case 59:
 
 /* Line 1455 of yacc.c  */
-#line 763 "program_parse.y"
+#line 780 "program_parse.y"
     {
           init_src_reg(& (yyval.src_reg));
           (yyval.src_reg).Base.File = ((yyvsp[(1) - (1)].temp_sym).name != NULL) 
@@ -2728,10 +2752,10 @@ yyreduce:
        ;}
     break;
 
-  case 59:
+  case 60:
 
 /* Line 1455 of yacc.c  */
-#line 773 "program_parse.y"
+#line 790 "program_parse.y"
     {
           init_dst_reg(& (yyval.dst_reg));
           (yyval.dst_reg).File = PROGRAM_OUTPUT;
@@ -2739,10 +2763,10 @@ yyreduce:
        ;}
     break;
 
-  case 60:
+  case 61:
 
 /* Line 1455 of yacc.c  */
-#line 779 "program_parse.y"
+#line 796 "program_parse.y"
     {
           struct asm_symbol *const s = (struct asm_symbol *)
              _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(1) - (1)].string));
@@ -2773,10 +2797,10 @@ yyreduce:
        ;}
     break;
 
-  case 61:
+  case 62:
 
 /* Line 1455 of yacc.c  */
-#line 810 "program_parse.y"
+#line 827 "program_parse.y"
     {
           struct asm_symbol *const s = (struct asm_symbol *)
              _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(1) - (1)].string));
@@ -2793,20 +2817,20 @@ yyreduce:
        ;}
     break;
 
-  case 64:
+  case 65:
 
 /* Line 1455 of yacc.c  */
-#line 829 "program_parse.y"
+#line 846 "program_parse.y"
     {
           init_src_reg(& (yyval.src_reg));
           (yyval.src_reg).Base.Index = (yyvsp[(1) - (1)].integer);
        ;}
     break;
 
-  case 65:
+  case 66:
 
 /* Line 1455 of yacc.c  */
-#line 836 "program_parse.y"
+#line 853 "program_parse.y"
     {
           /* FINISHME: Add support for multiple address registers.
            */
@@ -2818,31 +2842,31 @@ yyreduce:
        ;}
     break;
 
-  case 66:
+  case 67:
 
 /* Line 1455 of yacc.c  */
-#line 847 "program_parse.y"
+#line 864 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
-  case 67:
+  case 68:
 
 /* Line 1455 of yacc.c  */
-#line 848 "program_parse.y"
+#line 865 "program_parse.y"
     { (yyval.integer) = (yyvsp[(2) - (2)].integer); ;}
     break;
 
-  case 68:
+  case 69:
 
 /* Line 1455 of yacc.c  */
-#line 849 "program_parse.y"
+#line 866 "program_parse.y"
     { (yyval.integer) = -(yyvsp[(2) - (2)].integer); ;}
     break;
 
-  case 69:
+  case 70:
 
 /* Line 1455 of yacc.c  */
-#line 853 "program_parse.y"
+#line 870 "program_parse.y"
     {
           if (((yyvsp[(1) - (1)].integer) < 0) || ((yyvsp[(1) - (1)].integer) > 63)) {
              yyerror(& (yylsp[(1) - (1)]), state,
@@ -2854,10 +2878,10 @@ yyreduce:
        ;}
     break;
 
-  case 70:
+  case 71:
 
 /* Line 1455 of yacc.c  */
-#line 865 "program_parse.y"
+#line 882 "program_parse.y"
     {
           if (((yyvsp[(1) - (1)].integer) < 0) || ((yyvsp[(1) - (1)].integer) > 64)) {
              yyerror(& (yylsp[(1) - (1)]), state,
@@ -2869,10 +2893,10 @@ yyreduce:
        ;}
     break;
 
-  case 71:
+  case 72:
 
 /* Line 1455 of yacc.c  */
-#line 877 "program_parse.y"
+#line 894 "program_parse.y"
     {
           struct asm_symbol *const s = (struct asm_symbol *)
              _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(1) - (1)].string));
@@ -2890,10 +2914,10 @@ yyreduce:
        ;}
     break;
 
-  case 72:
+  case 73:
 
 /* Line 1455 of yacc.c  */
-#line 895 "program_parse.y"
+#line 912 "program_parse.y"
     {
           if ((yyvsp[(1) - (1)].swiz_mask).mask != WRITEMASK_X) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid address component selector");
@@ -2904,10 +2928,10 @@ yyreduce:
        ;}
     break;
 
-  case 73:
+  case 74:
 
 /* Line 1455 of yacc.c  */
-#line 906 "program_parse.y"
+#line 923 "program_parse.y"
     {
           if ((yyvsp[(1) - (1)].swiz_mask).mask != WRITEMASK_X) {
              yyerror(& (yylsp[(1) - (1)]), state,
@@ -2919,24 +2943,24 @@ yyreduce:
        ;}
     break;
 
-  case 78:
+  case 79:
 
 /* Line 1455 of yacc.c  */
-#line 922 "program_parse.y"
+#line 939 "program_parse.y"
     { (yyval.swiz_mask).swizzle = SWIZZLE_NOOP; (yyval.swiz_mask).mask = WRITEMASK_XYZW; ;}
     break;
 
-  case 83:
+  case 84:
 
 /* Line 1455 of yacc.c  */
-#line 926 "program_parse.y"
+#line 943 "program_parse.y"
     { (yyval.swiz_mask).swizzle = SWIZZLE_NOOP; (yyval.swiz_mask).mask = WRITEMASK_XYZW; ;}
     break;
 
-  case 90:
+  case 91:
 
 /* Line 1455 of yacc.c  */
-#line 938 "program_parse.y"
+#line 955 "program_parse.y"
     {
           struct asm_symbol *const s =
              declare_variable(state, (yyvsp[(2) - (4)].string), at_attrib, & (yylsp[(2) - (4)]));
@@ -2954,55 +2978,55 @@ yyreduce:
        ;}
     break;
 
-  case 91:
+  case 92:
 
 /* Line 1455 of yacc.c  */
-#line 956 "program_parse.y"
+#line 973 "program_parse.y"
     {
           (yyval.attrib) = (yyvsp[(2) - (2)].attrib);
        ;}
     break;
 
-  case 92:
+  case 93:
 
 /* Line 1455 of yacc.c  */
-#line 960 "program_parse.y"
+#line 977 "program_parse.y"
     {
           (yyval.attrib) = (yyvsp[(2) - (2)].attrib);
        ;}
     break;
 
-  case 93:
+  case 94:
 
 /* Line 1455 of yacc.c  */
-#line 966 "program_parse.y"
+#line 983 "program_parse.y"
     {
           (yyval.attrib) = VERT_ATTRIB_POS;
        ;}
     break;
 
-  case 94:
+  case 95:
 
 /* Line 1455 of yacc.c  */
-#line 970 "program_parse.y"
+#line 987 "program_parse.y"
     {
           (yyval.attrib) = VERT_ATTRIB_WEIGHT;
        ;}
     break;
 
-  case 95:
+  case 96:
 
 /* Line 1455 of yacc.c  */
-#line 974 "program_parse.y"
+#line 991 "program_parse.y"
     {
           (yyval.attrib) = VERT_ATTRIB_NORMAL;
        ;}
     break;
 
-  case 96:
+  case 97:
 
 /* Line 1455 of yacc.c  */
-#line 978 "program_parse.y"
+#line 995 "program_parse.y"
     {
           if (!state->ctx->Extensions.EXT_secondary_color) {
              yyerror(& (yylsp[(2) - (2)]), state, "GL_EXT_secondary_color not supported");
@@ -3013,10 +3037,10 @@ yyreduce:
        ;}
     break;
 
-  case 97:
+  case 98:
 
 /* Line 1455 of yacc.c  */
-#line 987 "program_parse.y"
+#line 1004 "program_parse.y"
     {
           if (!state->ctx->Extensions.EXT_fog_coord) {
              yyerror(& (yylsp[(1) - (1)]), state, "GL_EXT_fog_coord not supported");
@@ -3027,38 +3051,38 @@ yyreduce:
        ;}
     break;
 
-  case 98:
+  case 99:
 
 /* Line 1455 of yacc.c  */
-#line 996 "program_parse.y"
+#line 1013 "program_parse.y"
     {
           (yyval.attrib) = VERT_ATTRIB_TEX0 + (yyvsp[(2) - (2)].integer);
        ;}
     break;
 
-  case 99:
+  case 100:
 
 /* Line 1455 of yacc.c  */
-#line 1000 "program_parse.y"
+#line 1017 "program_parse.y"
     {
           yyerror(& (yylsp[(1) - (4)]), state, "GL_ARB_matrix_palette not supported");
           YYERROR;
        ;}
     break;
 
-  case 100:
+  case 101:
 
 /* Line 1455 of yacc.c  */
-#line 1005 "program_parse.y"
+#line 1022 "program_parse.y"
     {
           (yyval.attrib) = VERT_ATTRIB_GENERIC0 + (yyvsp[(3) - (4)].integer);
        ;}
     break;
 
-  case 101:
+  case 102:
 
 /* Line 1455 of yacc.c  */
-#line 1011 "program_parse.y"
+#line 1028 "program_parse.y"
     {
           if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxAttribs) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid vertex attribute reference");
@@ -3069,46 +3093,46 @@ yyreduce:
        ;}
     break;
 
-  case 105:
+  case 106:
 
 /* Line 1455 of yacc.c  */
-#line 1025 "program_parse.y"
+#line 1042 "program_parse.y"
     {
           (yyval.attrib) = FRAG_ATTRIB_WPOS;
        ;}
     break;
 
-  case 106:
+  case 107:
 
 /* Line 1455 of yacc.c  */
-#line 1029 "program_parse.y"
+#line 1046 "program_parse.y"
     {
           (yyval.attrib) = FRAG_ATTRIB_COL0 + (yyvsp[(2) - (2)].integer);
        ;}
     break;
 
-  case 107:
+  case 108:
 
 /* Line 1455 of yacc.c  */
-#line 1033 "program_parse.y"
+#line 1050 "program_parse.y"
     {
           (yyval.attrib) = FRAG_ATTRIB_FOGC;
        ;}
     break;
 
-  case 108:
+  case 109:
 
 /* Line 1455 of yacc.c  */
-#line 1037 "program_parse.y"
+#line 1054 "program_parse.y"
     {
           (yyval.attrib) = FRAG_ATTRIB_TEX0 + (yyvsp[(2) - (2)].integer);
        ;}
     break;
 
-  case 111:
+  case 112:
 
 /* Line 1455 of yacc.c  */
-#line 1045 "program_parse.y"
+#line 1062 "program_parse.y"
     {
           struct asm_symbol *const s =
              declare_variable(state, (yyvsp[(2) - (3)].string), at_param, & (yylsp[(2) - (3)]));
@@ -3124,10 +3148,10 @@ yyreduce:
        ;}
     break;
 
-  case 112:
+  case 113:
 
 /* Line 1455 of yacc.c  */
-#line 1061 "program_parse.y"
+#line 1078 "program_parse.y"
     {
           if (((yyvsp[(4) - (6)].integer) != 0) && ((unsigned) (yyvsp[(4) - (6)].integer) != (yyvsp[(6) - (6)].temp_sym).param_binding_length)) {
              yyerror(& (yylsp[(4) - (6)]), state, 
@@ -3149,19 +3173,19 @@ yyreduce:
        ;}
     break;
 
-  case 113:
+  case 114:
 
 /* Line 1455 of yacc.c  */
-#line 1083 "program_parse.y"
+#line 1100 "program_parse.y"
     {
           (yyval.integer) = 0;
        ;}
     break;
 
-  case 114:
+  case 115:
 
 /* Line 1455 of yacc.c  */
-#line 1087 "program_parse.y"
+#line 1104 "program_parse.y"
     {
           if (((yyvsp[(1) - (1)].integer) < 1) || ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxParameters)) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid parameter array size");
@@ -3172,38 +3196,38 @@ yyreduce:
        ;}
     break;
 
-  case 115:
+  case 116:
 
 /* Line 1455 of yacc.c  */
-#line 1098 "program_parse.y"
+#line 1115 "program_parse.y"
     {
           (yyval.temp_sym) = (yyvsp[(2) - (2)].temp_sym);
        ;}
     break;
 
-  case 116:
+  case 117:
 
 /* Line 1455 of yacc.c  */
-#line 1104 "program_parse.y"
+#line 1121 "program_parse.y"
     {
           (yyval.temp_sym) = (yyvsp[(3) - (4)].temp_sym);
        ;}
     break;
 
-  case 118:
+  case 119:
 
 /* Line 1455 of yacc.c  */
-#line 1111 "program_parse.y"
+#line 1128 "program_parse.y"
     {
           (yyvsp[(1) - (3)].temp_sym).param_binding_length += (yyvsp[(3) - (3)].temp_sym).param_binding_length;
           (yyval.temp_sym) = (yyvsp[(1) - (3)].temp_sym);
        ;}
     break;
 
-  case 119:
+  case 120:
 
 /* Line 1455 of yacc.c  */
-#line 1118 "program_parse.y"
+#line 1135 "program_parse.y"
     {
           memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
           (yyval.temp_sym).param_binding_begin = ~0;
@@ -3211,10 +3235,10 @@ yyreduce:
        ;}
     break;
 
-  case 120:
+  case 121:
 
 /* Line 1455 of yacc.c  */
-#line 1124 "program_parse.y"
+#line 1141 "program_parse.y"
     {
           memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
           (yyval.temp_sym).param_binding_begin = ~0;
@@ -3222,10 +3246,10 @@ yyreduce:
        ;}
     break;
 
-  case 121:
+  case 122:
 
 /* Line 1455 of yacc.c  */
-#line 1130 "program_parse.y"
+#line 1147 "program_parse.y"
     {
           memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
           (yyval.temp_sym).param_binding_begin = ~0;
@@ -3233,10 +3257,10 @@ yyreduce:
        ;}
     break;
 
-  case 122:
+  case 123:
 
 /* Line 1455 of yacc.c  */
-#line 1138 "program_parse.y"
+#line 1155 "program_parse.y"
     {
           memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
           (yyval.temp_sym).param_binding_begin = ~0;
@@ -3244,10 +3268,10 @@ yyreduce:
        ;}
     break;
 
-  case 123:
+  case 124:
 
 /* Line 1455 of yacc.c  */
-#line 1144 "program_parse.y"
+#line 1161 "program_parse.y"
     {
           memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
           (yyval.temp_sym).param_binding_begin = ~0;
@@ -3255,10 +3279,10 @@ yyreduce:
        ;}
     break;
 
-  case 124:
+  case 125:
 
 /* Line 1455 of yacc.c  */
-#line 1150 "program_parse.y"
+#line 1167 "program_parse.y"
     {
           memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
           (yyval.temp_sym).param_binding_begin = ~0;
@@ -3266,10 +3290,10 @@ yyreduce:
        ;}
     break;
 
-  case 125:
+  case 126:
 
 /* Line 1455 of yacc.c  */
-#line 1158 "program_parse.y"
+#line 1175 "program_parse.y"
     {
           memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
           (yyval.temp_sym).param_binding_begin = ~0;
@@ -3277,10 +3301,10 @@ yyreduce:
        ;}
     break;
 
-  case 126:
+  case 127:
 
 /* Line 1455 of yacc.c  */
-#line 1164 "program_parse.y"
+#line 1181 "program_parse.y"
     {
           memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
           (yyval.temp_sym).param_binding_begin = ~0;
@@ -3288,10 +3312,10 @@ yyreduce:
        ;}
     break;
 
-  case 127:
+  case 128:
 
 /* Line 1455 of yacc.c  */
-#line 1170 "program_parse.y"
+#line 1187 "program_parse.y"
     {
           memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
           (yyval.temp_sym).param_binding_begin = ~0;
@@ -3299,101 +3323,101 @@ yyreduce:
        ;}
     break;
 
-  case 128:
-
-/* Line 1455 of yacc.c  */
-#line 1177 "program_parse.y"
-    { memcpy((yyval.state), (yyvsp[(1) - (1)].state), sizeof((yyval.state))); ;}
-    break;
-
   case 129:
 
 /* Line 1455 of yacc.c  */
-#line 1178 "program_parse.y"
-    { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
+#line 1194 "program_parse.y"
+    { memcpy((yyval.state), (yyvsp[(1) - (1)].state), sizeof((yyval.state))); ;}
     break;
 
   case 130:
 
 /* Line 1455 of yacc.c  */
-#line 1181 "program_parse.y"
+#line 1195 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 131:
 
 /* Line 1455 of yacc.c  */
-#line 1182 "program_parse.y"
+#line 1198 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 132:
 
 /* Line 1455 of yacc.c  */
-#line 1183 "program_parse.y"
+#line 1199 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 133:
 
 /* Line 1455 of yacc.c  */
-#line 1184 "program_parse.y"
+#line 1200 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 134:
 
 /* Line 1455 of yacc.c  */
-#line 1185 "program_parse.y"
+#line 1201 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 135:
 
 /* Line 1455 of yacc.c  */
-#line 1186 "program_parse.y"
+#line 1202 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 136:
 
 /* Line 1455 of yacc.c  */
-#line 1187 "program_parse.y"
+#line 1203 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 137:
 
 /* Line 1455 of yacc.c  */
-#line 1188 "program_parse.y"
+#line 1204 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 138:
 
 /* Line 1455 of yacc.c  */
-#line 1189 "program_parse.y"
+#line 1205 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 139:
 
 /* Line 1455 of yacc.c  */
-#line 1190 "program_parse.y"
+#line 1206 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 140:
 
 /* Line 1455 of yacc.c  */
-#line 1191 "program_parse.y"
+#line 1207 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 141:
 
 /* Line 1455 of yacc.c  */
-#line 1195 "program_parse.y"
+#line 1208 "program_parse.y"
+    { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
+    break;
+
+  case 142:
+
+/* Line 1455 of yacc.c  */
+#line 1212 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = STATE_MATERIAL;
@@ -3402,37 +3426,37 @@ yyreduce:
        ;}
     break;
 
-  case 142:
+  case 143:
 
 /* Line 1455 of yacc.c  */
-#line 1204 "program_parse.y"
+#line 1221 "program_parse.y"
     {
           (yyval.integer) = (yyvsp[(1) - (1)].integer);
        ;}
     break;
 
-  case 143:
+  case 144:
 
 /* Line 1455 of yacc.c  */
-#line 1208 "program_parse.y"
+#line 1225 "program_parse.y"
     {
           (yyval.integer) = STATE_EMISSION;
        ;}
     break;
 
-  case 144:
+  case 145:
 
 /* Line 1455 of yacc.c  */
-#line 1212 "program_parse.y"
+#line 1229 "program_parse.y"
     {
           (yyval.integer) = STATE_SHININESS;
        ;}
     break;
 
-  case 145:
+  case 146:
 
 /* Line 1455 of yacc.c  */
-#line 1218 "program_parse.y"
+#line 1235 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = STATE_LIGHT;
@@ -3441,28 +3465,28 @@ yyreduce:
        ;}
     break;
 
-  case 146:
+  case 147:
 
 /* Line 1455 of yacc.c  */
-#line 1227 "program_parse.y"
+#line 1244 "program_parse.y"
     {
           (yyval.integer) = (yyvsp[(1) - (1)].integer);
        ;}
     break;
 
-  case 147:
+  case 148:
 
 /* Line 1455 of yacc.c  */
-#line 1231 "program_parse.y"
+#line 1248 "program_parse.y"
     {
           (yyval.integer) = STATE_POSITION;
        ;}
     break;
 
-  case 148:
+  case 149:
 
 /* Line 1455 of yacc.c  */
-#line 1235 "program_parse.y"
+#line 1252 "program_parse.y"
     {
           if (!state->ctx->Extensions.EXT_point_parameters) {
              yyerror(& (yylsp[(1) - (1)]), state, "GL_ARB_point_parameters not supported");
@@ -3473,57 +3497,57 @@ yyreduce:
        ;}
     break;
 
-  case 149:
+  case 150:
 
 /* Line 1455 of yacc.c  */
-#line 1244 "program_parse.y"
+#line 1261 "program_parse.y"
     {
           (yyval.integer) = (yyvsp[(2) - (2)].integer);
        ;}
     break;
 
-  case 150:
+  case 151:
 
 /* Line 1455 of yacc.c  */
-#line 1248 "program_parse.y"
+#line 1265 "program_parse.y"
     {
           (yyval.integer) = STATE_HALF_VECTOR;
        ;}
     break;
 
-  case 151:
+  case 152:
 
 /* Line 1455 of yacc.c  */
-#line 1254 "program_parse.y"
+#line 1271 "program_parse.y"
     {
           (yyval.integer) = STATE_SPOT_DIRECTION;
        ;}
     break;
 
-  case 152:
+  case 153:
 
 /* Line 1455 of yacc.c  */
-#line 1260 "program_parse.y"
+#line 1277 "program_parse.y"
     {
           (yyval.state)[0] = (yyvsp[(2) - (2)].state)[0];
           (yyval.state)[1] = (yyvsp[(2) - (2)].state)[1];
        ;}
     break;
 
-  case 153:
+  case 154:
 
 /* Line 1455 of yacc.c  */
-#line 1267 "program_parse.y"
+#line 1284 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = STATE_LIGHTMODEL_AMBIENT;
        ;}
     break;
 
-  case 154:
+  case 155:
 
 /* Line 1455 of yacc.c  */
-#line 1272 "program_parse.y"
+#line 1289 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = STATE_LIGHTMODEL_SCENECOLOR;
@@ -3531,10 +3555,10 @@ yyreduce:
        ;}
     break;
 
-  case 155:
+  case 156:
 
 /* Line 1455 of yacc.c  */
-#line 1280 "program_parse.y"
+#line 1297 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = STATE_LIGHTPROD;
@@ -3544,10 +3568,10 @@ yyreduce:
        ;}
     break;
 
-  case 157:
+  case 158:
 
 /* Line 1455 of yacc.c  */
-#line 1292 "program_parse.y"
+#line 1309 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = (yyvsp[(3) - (3)].integer);
@@ -3555,46 +3579,46 @@ yyreduce:
        ;}
     break;
 
-  case 158:
+  case 159:
 
 /* Line 1455 of yacc.c  */
-#line 1300 "program_parse.y"
+#line 1317 "program_parse.y"
     {
           (yyval.integer) = STATE_TEXENV_COLOR;
        ;}
     break;
 
-  case 159:
+  case 160:
 
 /* Line 1455 of yacc.c  */
-#line 1306 "program_parse.y"
+#line 1323 "program_parse.y"
     {
           (yyval.integer) = STATE_AMBIENT;
        ;}
     break;
 
-  case 160:
+  case 161:
 
 /* Line 1455 of yacc.c  */
-#line 1310 "program_parse.y"
+#line 1327 "program_parse.y"
     {
           (yyval.integer) = STATE_DIFFUSE;
        ;}
     break;
 
-  case 161:
+  case 162:
 
 /* Line 1455 of yacc.c  */
-#line 1314 "program_parse.y"
+#line 1331 "program_parse.y"
     {
           (yyval.integer) = STATE_SPECULAR;
        ;}
     break;
 
-  case 162:
+  case 163:
 
 /* Line 1455 of yacc.c  */
-#line 1320 "program_parse.y"
+#line 1337 "program_parse.y"
     {
           if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxLights) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid light selector");
@@ -3605,10 +3629,10 @@ yyreduce:
        ;}
     break;
 
-  case 163:
+  case 164:
 
 /* Line 1455 of yacc.c  */
-#line 1331 "program_parse.y"
+#line 1348 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = STATE_TEXGEN;
@@ -3617,92 +3641,92 @@ yyreduce:
        ;}
     break;
 
-  case 164:
+  case 165:
 
 /* Line 1455 of yacc.c  */
-#line 1340 "program_parse.y"
+#line 1357 "program_parse.y"
     {
           (yyval.integer) = STATE_TEXGEN_EYE_S;
        ;}
     break;
 
-  case 165:
+  case 166:
 
 /* Line 1455 of yacc.c  */
-#line 1344 "program_parse.y"
+#line 1361 "program_parse.y"
     {
           (yyval.integer) = STATE_TEXGEN_OBJECT_S;
        ;}
     break;
 
-  case 166:
+  case 167:
 
 /* Line 1455 of yacc.c  */
-#line 1349 "program_parse.y"
+#line 1366 "program_parse.y"
     {
           (yyval.integer) = STATE_TEXGEN_EYE_S - STATE_TEXGEN_EYE_S;
        ;}
     break;
 
-  case 167:
+  case 168:
 
 /* Line 1455 of yacc.c  */
-#line 1353 "program_parse.y"
+#line 1370 "program_parse.y"
     {
           (yyval.integer) = STATE_TEXGEN_EYE_T - STATE_TEXGEN_EYE_S;
        ;}
     break;
 
-  case 168:
+  case 169:
 
 /* Line 1455 of yacc.c  */
-#line 1357 "program_parse.y"
+#line 1374 "program_parse.y"
     {
           (yyval.integer) = STATE_TEXGEN_EYE_R - STATE_TEXGEN_EYE_S;
        ;}
     break;
 
-  case 169:
+  case 170:
 
 /* Line 1455 of yacc.c  */
-#line 1361 "program_parse.y"
+#line 1378 "program_parse.y"
     {
           (yyval.integer) = STATE_TEXGEN_EYE_Q - STATE_TEXGEN_EYE_S;
        ;}
     break;
 
-  case 170:
+  case 171:
 
 /* Line 1455 of yacc.c  */
-#line 1367 "program_parse.y"
+#line 1384 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = (yyvsp[(2) - (2)].integer);
        ;}
     break;
 
-  case 171:
+  case 172:
 
 /* Line 1455 of yacc.c  */
-#line 1374 "program_parse.y"
+#line 1391 "program_parse.y"
     {
           (yyval.integer) = STATE_FOG_COLOR;
        ;}
     break;
 
-  case 172:
+  case 173:
 
 /* Line 1455 of yacc.c  */
-#line 1378 "program_parse.y"
+#line 1395 "program_parse.y"
     {
           (yyval.integer) = STATE_FOG_PARAMS;
        ;}
     break;
 
-  case 173:
+  case 174:
 
 /* Line 1455 of yacc.c  */
-#line 1384 "program_parse.y"
+#line 1401 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = STATE_CLIPPLANE;
@@ -3710,10 +3734,10 @@ yyreduce:
        ;}
     break;
 
-  case 174:
+  case 175:
 
 /* Line 1455 of yacc.c  */
-#line 1392 "program_parse.y"
+#line 1409 "program_parse.y"
     {
           if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxClipPlanes) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid clip plane selector");
@@ -3724,38 +3748,38 @@ yyreduce:
        ;}
     break;
 
-  case 175:
+  case 176:
 
 /* Line 1455 of yacc.c  */
-#line 1403 "program_parse.y"
+#line 1420 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = (yyvsp[(2) - (2)].integer);
        ;}
     break;
 
-  case 176:
+  case 177:
 
 /* Line 1455 of yacc.c  */
-#line 1410 "program_parse.y"
+#line 1427 "program_parse.y"
     {
           (yyval.integer) = STATE_POINT_SIZE;
        ;}
     break;
 
-  case 177:
+  case 178:
 
 /* Line 1455 of yacc.c  */
-#line 1414 "program_parse.y"
+#line 1431 "program_parse.y"
     {
           (yyval.integer) = STATE_POINT_ATTENUATION;
        ;}
     break;
 
-  case 178:
+  case 179:
 
 /* Line 1455 of yacc.c  */
-#line 1420 "program_parse.y"
+#line 1437 "program_parse.y"
     {
           (yyval.state)[0] = (yyvsp[(1) - (5)].state)[0];
           (yyval.state)[1] = (yyvsp[(1) - (5)].state)[1];
@@ -3765,10 +3789,10 @@ yyreduce:
        ;}
     break;
 
-  case 179:
+  case 180:
 
 /* Line 1455 of yacc.c  */
-#line 1430 "program_parse.y"
+#line 1447 "program_parse.y"
     {
           (yyval.state)[0] = (yyvsp[(1) - (2)].state)[0];
           (yyval.state)[1] = (yyvsp[(1) - (2)].state)[1];
@@ -3778,20 +3802,20 @@ yyreduce:
        ;}
     break;
 
-  case 180:
+  case 181:
 
 /* Line 1455 of yacc.c  */
-#line 1440 "program_parse.y"
+#line 1457 "program_parse.y"
     {
           (yyval.state)[2] = 0;
           (yyval.state)[3] = 3;
        ;}
     break;
 
-  case 181:
+  case 182:
 
 /* Line 1455 of yacc.c  */
-#line 1445 "program_parse.y"
+#line 1462 "program_parse.y"
     {
           /* It seems logical that the matrix row range specifier would have
            * to specify a range or more than one row (i.e., $5 > $3).
@@ -3809,10 +3833,10 @@ yyreduce:
        ;}
     break;
 
-  case 182:
+  case 183:
 
 /* Line 1455 of yacc.c  */
-#line 1463 "program_parse.y"
+#line 1480 "program_parse.y"
     {
           (yyval.state)[0] = (yyvsp[(2) - (3)].state)[0];
           (yyval.state)[1] = (yyvsp[(2) - (3)].state)[1];
@@ -3820,55 +3844,55 @@ yyreduce:
        ;}
     break;
 
-  case 183:
+  case 184:
 
 /* Line 1455 of yacc.c  */
-#line 1471 "program_parse.y"
+#line 1488 "program_parse.y"
     {
           (yyval.integer) = 0;
        ;}
     break;
 
-  case 184:
+  case 185:
 
 /* Line 1455 of yacc.c  */
-#line 1475 "program_parse.y"
+#line 1492 "program_parse.y"
     {
           (yyval.integer) = (yyvsp[(1) - (1)].integer);
        ;}
     break;
 
-  case 185:
+  case 186:
 
 /* Line 1455 of yacc.c  */
-#line 1481 "program_parse.y"
+#line 1498 "program_parse.y"
     {
           (yyval.integer) = STATE_MATRIX_INVERSE;
        ;}
     break;
 
-  case 186:
+  case 187:
 
 /* Line 1455 of yacc.c  */
-#line 1485 "program_parse.y"
+#line 1502 "program_parse.y"
     {
           (yyval.integer) = STATE_MATRIX_TRANSPOSE;
        ;}
     break;
 
-  case 187:
+  case 188:
 
 /* Line 1455 of yacc.c  */
-#line 1489 "program_parse.y"
+#line 1506 "program_parse.y"
     {
           (yyval.integer) = STATE_MATRIX_INVTRANS;
        ;}
     break;
 
-  case 188:
+  case 189:
 
 /* Line 1455 of yacc.c  */
-#line 1495 "program_parse.y"
+#line 1512 "program_parse.y"
     {
           if ((yyvsp[(1) - (1)].integer) > 3) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid matrix row reference");
@@ -3879,88 +3903,88 @@ yyreduce:
        ;}
     break;
 
-  case 189:
+  case 190:
 
 /* Line 1455 of yacc.c  */
-#line 1506 "program_parse.y"
+#line 1523 "program_parse.y"
     {
           (yyval.state)[0] = STATE_MODELVIEW_MATRIX;
           (yyval.state)[1] = (yyvsp[(2) - (2)].integer);
        ;}
     break;
 
-  case 190:
+  case 191:
 
 /* Line 1455 of yacc.c  */
-#line 1511 "program_parse.y"
+#line 1528 "program_parse.y"
     {
           (yyval.state)[0] = STATE_PROJECTION_MATRIX;
           (yyval.state)[1] = 0;
        ;}
     break;
 
-  case 191:
+  case 192:
 
 /* Line 1455 of yacc.c  */
-#line 1516 "program_parse.y"
+#line 1533 "program_parse.y"
     {
           (yyval.state)[0] = STATE_MVP_MATRIX;
           (yyval.state)[1] = 0;
        ;}
     break;
 
-  case 192:
+  case 193:
 
 /* Line 1455 of yacc.c  */
-#line 1521 "program_parse.y"
+#line 1538 "program_parse.y"
     {
           (yyval.state)[0] = STATE_TEXTURE_MATRIX;
           (yyval.state)[1] = (yyvsp[(2) - (2)].integer);
        ;}
     break;
 
-  case 193:
+  case 194:
 
 /* Line 1455 of yacc.c  */
-#line 1526 "program_parse.y"
+#line 1543 "program_parse.y"
     {
           yyerror(& (yylsp[(1) - (4)]), state, "GL_ARB_matrix_palette not supported");
           YYERROR;
        ;}
     break;
 
-  case 194:
+  case 195:
 
 /* Line 1455 of yacc.c  */
-#line 1531 "program_parse.y"
+#line 1548 "program_parse.y"
     {
           (yyval.state)[0] = STATE_PROGRAM_MATRIX;
           (yyval.state)[1] = (yyvsp[(3) - (4)].integer);
        ;}
     break;
 
-  case 195:
+  case 196:
 
 /* Line 1455 of yacc.c  */
-#line 1538 "program_parse.y"
+#line 1555 "program_parse.y"
     {
           (yyval.integer) = 0;
        ;}
     break;
 
-  case 196:
+  case 197:
 
 /* Line 1455 of yacc.c  */
-#line 1542 "program_parse.y"
+#line 1559 "program_parse.y"
     {
           (yyval.integer) = (yyvsp[(1) - (1)].integer);
        ;}
     break;
 
-  case 197:
+  case 198:
 
 /* Line 1455 of yacc.c  */
-#line 1547 "program_parse.y"
+#line 1564 "program_parse.y"
     {
           /* Since GL_ARB_vertex_blend isn't supported, only modelview matrix
            * zero is valid.
@@ -3974,10 +3998,10 @@ yyreduce:
        ;}
     break;
 
-  case 198:
+  case 199:
 
 /* Line 1455 of yacc.c  */
-#line 1560 "program_parse.y"
+#line 1577 "program_parse.y"
     {
           /* Since GL_ARB_matrix_palette isn't supported, just let any value
            * through here.  The error will be generated later.
@@ -3986,10 +4010,10 @@ yyreduce:
        ;}
     break;
 
-  case 199:
+  case 200:
 
 /* Line 1455 of yacc.c  */
-#line 1568 "program_parse.y"
+#line 1585 "program_parse.y"
     {
           if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxProgramMatrices) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid program matrix selector");
@@ -4000,20 +4024,20 @@ yyreduce:
        ;}
     break;
 
-  case 200:
+  case 201:
 
 /* Line 1455 of yacc.c  */
-#line 1579 "program_parse.y"
+#line 1596 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = STATE_DEPTH_RANGE;
        ;}
     break;
 
-  case 205:
+  case 206:
 
 /* Line 1455 of yacc.c  */
-#line 1591 "program_parse.y"
+#line 1608 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = state->state_param_enum;
@@ -4023,30 +4047,30 @@ yyreduce:
        ;}
     break;
 
-  case 206:
+  case 207:
 
 /* Line 1455 of yacc.c  */
-#line 1601 "program_parse.y"
+#line 1618 "program_parse.y"
     {
           (yyval.state)[0] = (yyvsp[(1) - (1)].integer);
           (yyval.state)[1] = (yyvsp[(1) - (1)].integer);
        ;}
     break;
 
-  case 207:
+  case 208:
 
 /* Line 1455 of yacc.c  */
-#line 1606 "program_parse.y"
+#line 1623 "program_parse.y"
     {
           (yyval.state)[0] = (yyvsp[(1) - (3)].integer);
           (yyval.state)[1] = (yyvsp[(3) - (3)].integer);
        ;}
     break;
 
-  case 208:
+  case 209:
 
 /* Line 1455 of yacc.c  */
-#line 1613 "program_parse.y"
+#line 1630 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = state->state_param_enum;
@@ -4056,10 +4080,10 @@ yyreduce:
        ;}
     break;
 
-  case 209:
+  case 210:
 
 /* Line 1455 of yacc.c  */
-#line 1623 "program_parse.y"
+#line 1640 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = state->state_param_enum;
@@ -4069,30 +4093,30 @@ yyreduce:
        ;}
     break;
 
-  case 210:
+  case 211:
 
 /* Line 1455 of yacc.c  */
-#line 1632 "program_parse.y"
+#line 1649 "program_parse.y"
     {
           (yyval.state)[0] = (yyvsp[(1) - (1)].integer);
           (yyval.state)[1] = (yyvsp[(1) - (1)].integer);
        ;}
     break;
 
-  case 211:
+  case 212:
 
 /* Line 1455 of yacc.c  */
-#line 1637 "program_parse.y"
+#line 1654 "program_parse.y"
     {
           (yyval.state)[0] = (yyvsp[(1) - (3)].integer);
           (yyval.state)[1] = (yyvsp[(3) - (3)].integer);
        ;}
     break;
 
-  case 212:
+  case 213:
 
 /* Line 1455 of yacc.c  */
-#line 1644 "program_parse.y"
+#line 1661 "program_parse.y"
     {
           memset((yyval.state), 0, sizeof((yyval.state)));
           (yyval.state)[0] = state->state_param_enum;
@@ -4102,10 +4126,10 @@ yyreduce:
        ;}
     break;
 
-  case 213:
+  case 214:
 
 /* Line 1455 of yacc.c  */
-#line 1654 "program_parse.y"
+#line 1671 "program_parse.y"
     {
           if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxEnvParams) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid environment parameter reference");
@@ -4115,10 +4139,10 @@ yyreduce:
        ;}
     break;
 
-  case 214:
+  case 215:
 
 /* Line 1455 of yacc.c  */
-#line 1664 "program_parse.y"
+#line 1681 "program_parse.y"
     {
           if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxLocalParams) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid local parameter reference");
@@ -4128,10 +4152,10 @@ yyreduce:
        ;}
     break;
 
-  case 219:
+  case 220:
 
 /* Line 1455 of yacc.c  */
-#line 1679 "program_parse.y"
+#line 1696 "program_parse.y"
     {
           (yyval.vector).count = 4;
           (yyval.vector).data[0] = (yyvsp[(1) - (1)].real);
@@ -4141,10 +4165,10 @@ yyreduce:
        ;}
     break;
 
-  case 220:
+  case 221:
 
 /* Line 1455 of yacc.c  */
-#line 1689 "program_parse.y"
+#line 1706 "program_parse.y"
     {
           (yyval.vector).count = 1;
           (yyval.vector).data[0] = (yyvsp[(1) - (1)].real);
@@ -4154,10 +4178,10 @@ yyreduce:
        ;}
     break;
 
-  case 221:
+  case 222:
 
 /* Line 1455 of yacc.c  */
-#line 1697 "program_parse.y"
+#line 1714 "program_parse.y"
     {
           (yyval.vector).count = 1;
           (yyval.vector).data[0] = (float) (yyvsp[(1) - (1)].integer);
@@ -4167,10 +4191,10 @@ yyreduce:
        ;}
     break;
 
-  case 222:
+  case 223:
 
 /* Line 1455 of yacc.c  */
-#line 1707 "program_parse.y"
+#line 1724 "program_parse.y"
     {
           (yyval.vector).count = 4;
           (yyval.vector).data[0] = (yyvsp[(2) - (3)].real);
@@ -4180,10 +4204,10 @@ yyreduce:
        ;}
     break;
 
-  case 223:
+  case 224:
 
 /* Line 1455 of yacc.c  */
-#line 1715 "program_parse.y"
+#line 1732 "program_parse.y"
     {
           (yyval.vector).count = 4;
           (yyval.vector).data[0] = (yyvsp[(2) - (5)].real);
@@ -4193,10 +4217,10 @@ yyreduce:
        ;}
     break;
 
-  case 224:
+  case 225:
 
 /* Line 1455 of yacc.c  */
-#line 1724 "program_parse.y"
+#line 1741 "program_parse.y"
     {
           (yyval.vector).count = 4;
           (yyval.vector).data[0] = (yyvsp[(2) - (7)].real);
@@ -4206,10 +4230,10 @@ yyreduce:
        ;}
     break;
 
-  case 225:
+  case 226:
 
 /* Line 1455 of yacc.c  */
-#line 1733 "program_parse.y"
+#line 1750 "program_parse.y"
     {
           (yyval.vector).count = 4;
           (yyval.vector).data[0] = (yyvsp[(2) - (9)].real);
@@ -4219,63 +4243,63 @@ yyreduce:
        ;}
     break;
 
-  case 226:
+  case 227:
 
 /* Line 1455 of yacc.c  */
-#line 1743 "program_parse.y"
+#line 1760 "program_parse.y"
     {
           (yyval.real) = ((yyvsp[(1) - (2)].negate)) ? -(yyvsp[(2) - (2)].real) : (yyvsp[(2) - (2)].real);
        ;}
     break;
 
-  case 227:
+  case 228:
 
 /* Line 1455 of yacc.c  */
-#line 1747 "program_parse.y"
+#line 1764 "program_parse.y"
     {
           (yyval.real) = (float)(((yyvsp[(1) - (2)].negate)) ? -(yyvsp[(2) - (2)].integer) : (yyvsp[(2) - (2)].integer));
        ;}
     break;
 
-  case 228:
+  case 229:
 
 /* Line 1455 of yacc.c  */
-#line 1752 "program_parse.y"
+#line 1769 "program_parse.y"
     { (yyval.negate) = FALSE; ;}
     break;
 
-  case 229:
+  case 230:
 
 /* Line 1455 of yacc.c  */
-#line 1753 "program_parse.y"
+#line 1770 "program_parse.y"
     { (yyval.negate) = TRUE;  ;}
     break;
 
-  case 230:
+  case 231:
 
 /* Line 1455 of yacc.c  */
-#line 1754 "program_parse.y"
+#line 1771 "program_parse.y"
     { (yyval.negate) = FALSE; ;}
     break;
 
-  case 231:
+  case 232:
 
 /* Line 1455 of yacc.c  */
-#line 1757 "program_parse.y"
+#line 1774 "program_parse.y"
     { (yyval.integer) = (yyvsp[(1) - (1)].integer); ;}
     break;
 
-  case 233:
+  case 234:
 
 /* Line 1455 of yacc.c  */
-#line 1760 "program_parse.y"
+#line 1777 "program_parse.y"
     { (yyval.integer) = (yyvsp[(1) - (1)].integer); ;}
     break;
 
-  case 235:
+  case 236:
 
 /* Line 1455 of yacc.c  */
-#line 1764 "program_parse.y"
+#line 1781 "program_parse.y"
     {
           if (!declare_variable(state, (yyvsp[(3) - (3)].string), (yyvsp[(0) - (3)].integer), & (yylsp[(3) - (3)]))) {
              YYERROR;
@@ -4283,10 +4307,10 @@ yyreduce:
        ;}
     break;
 
-  case 236:
+  case 237:
 
 /* Line 1455 of yacc.c  */
-#line 1770 "program_parse.y"
+#line 1787 "program_parse.y"
     {
           if (!declare_variable(state, (yyvsp[(1) - (1)].string), (yyvsp[(0) - (1)].integer), & (yylsp[(1) - (1)]))) {
              YYERROR;
@@ -4294,10 +4318,10 @@ yyreduce:
        ;}
     break;
 
-  case 237:
+  case 238:
 
 /* Line 1455 of yacc.c  */
-#line 1778 "program_parse.y"
+#line 1795 "program_parse.y"
     {
           struct asm_symbol *const s =
              declare_variable(state, (yyvsp[(2) - (4)].string), at_output, & (yylsp[(2) - (4)]));
@@ -4310,10 +4334,10 @@ yyreduce:
        ;}
     break;
 
-  case 238:
+  case 239:
 
 /* Line 1455 of yacc.c  */
-#line 1791 "program_parse.y"
+#line 1808 "program_parse.y"
     {
           if (state->mode == ARB_vertex) {
              (yyval.result) = VERT_RESULT_HPOS;
@@ -4324,10 +4348,10 @@ yyreduce:
        ;}
     break;
 
-  case 239:
+  case 240:
 
 /* Line 1455 of yacc.c  */
-#line 1800 "program_parse.y"
+#line 1817 "program_parse.y"
     {
           if (state->mode == ARB_vertex) {
              (yyval.result) = VERT_RESULT_FOGC;
@@ -4338,19 +4362,19 @@ yyreduce:
        ;}
     break;
 
-  case 240:
+  case 241:
 
 /* Line 1455 of yacc.c  */
-#line 1809 "program_parse.y"
+#line 1826 "program_parse.y"
     {
           (yyval.result) = (yyvsp[(2) - (2)].result);
        ;}
     break;
 
-  case 241:
+  case 242:
 
 /* Line 1455 of yacc.c  */
-#line 1813 "program_parse.y"
+#line 1830 "program_parse.y"
     {
           if (state->mode == ARB_vertex) {
              (yyval.result) = VERT_RESULT_PSIZ;
@@ -4361,10 +4385,10 @@ yyreduce:
        ;}
     break;
 
-  case 242:
+  case 243:
 
 /* Line 1455 of yacc.c  */
-#line 1822 "program_parse.y"
+#line 1839 "program_parse.y"
     {
           if (state->mode == ARB_vertex) {
              (yyval.result) = VERT_RESULT_TEX0 + (yyvsp[(3) - (3)].integer);
@@ -4375,10 +4399,10 @@ yyreduce:
        ;}
     break;
 
-  case 243:
+  case 244:
 
 /* Line 1455 of yacc.c  */
-#line 1831 "program_parse.y"
+#line 1848 "program_parse.y"
     {
           if (state->mode == ARB_fragment) {
              (yyval.result) = FRAG_RESULT_DEPTH;
@@ -4389,19 +4413,19 @@ yyreduce:
        ;}
     break;
 
-  case 244:
+  case 245:
 
 /* Line 1455 of yacc.c  */
-#line 1842 "program_parse.y"
+#line 1859 "program_parse.y"
     {
           (yyval.result) = (yyvsp[(2) - (3)].integer) + (yyvsp[(3) - (3)].integer);
        ;}
     break;
 
-  case 245:
+  case 246:
 
 /* Line 1455 of yacc.c  */
-#line 1848 "program_parse.y"
+#line 1865 "program_parse.y"
     {
           (yyval.integer) = (state->mode == ARB_vertex)
              ? VERT_RESULT_COL0
@@ -4409,10 +4433,10 @@ yyreduce:
        ;}
     break;
 
-  case 246:
+  case 247:
 
 /* Line 1455 of yacc.c  */
-#line 1854 "program_parse.y"
+#line 1871 "program_parse.y"
     {
           if (state->mode == ARB_vertex) {
              (yyval.integer) = VERT_RESULT_COL0;
@@ -4423,10 +4447,10 @@ yyreduce:
        ;}
     break;
 
-  case 247:
+  case 248:
 
 /* Line 1455 of yacc.c  */
-#line 1863 "program_parse.y"
+#line 1880 "program_parse.y"
     {
           if (state->mode == ARB_vertex) {
              (yyval.integer) = VERT_RESULT_BFC0;
@@ -4437,19 +4461,19 @@ yyreduce:
        ;}
     break;
 
-  case 248:
+  case 249:
 
 /* Line 1455 of yacc.c  */
-#line 1874 "program_parse.y"
+#line 1891 "program_parse.y"
     {
           (yyval.integer) = 0; 
        ;}
     break;
 
-  case 249:
+  case 250:
 
 /* Line 1455 of yacc.c  */
-#line 1878 "program_parse.y"
+#line 1895 "program_parse.y"
     {
           if (state->mode == ARB_vertex) {
              (yyval.integer) = 0;
@@ -4460,10 +4484,10 @@ yyreduce:
        ;}
     break;
 
-  case 250:
+  case 251:
 
 /* Line 1455 of yacc.c  */
-#line 1887 "program_parse.y"
+#line 1904 "program_parse.y"
     {
           if (state->mode == ARB_vertex) {
              (yyval.integer) = 1;
@@ -4474,94 +4498,94 @@ yyreduce:
        ;}
     break;
 
-  case 251:
+  case 252:
 
 /* Line 1455 of yacc.c  */
-#line 1897 "program_parse.y"
+#line 1914 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
-  case 252:
+  case 253:
 
 /* Line 1455 of yacc.c  */
-#line 1898 "program_parse.y"
+#line 1915 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
-  case 253:
+  case 254:
 
 /* Line 1455 of yacc.c  */
-#line 1899 "program_parse.y"
+#line 1916 "program_parse.y"
     { (yyval.integer) = 1; ;}
     break;
 
-  case 254:
+  case 255:
 
 /* Line 1455 of yacc.c  */
-#line 1902 "program_parse.y"
+#line 1919 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
-  case 255:
+  case 256:
 
 /* Line 1455 of yacc.c  */
-#line 1903 "program_parse.y"
+#line 1920 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
-  case 256:
+  case 257:
 
 /* Line 1455 of yacc.c  */
-#line 1904 "program_parse.y"
+#line 1921 "program_parse.y"
     { (yyval.integer) = 1; ;}
     break;
 
-  case 257:
+  case 258:
 
 /* Line 1455 of yacc.c  */
-#line 1907 "program_parse.y"
+#line 1924 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
-  case 258:
+  case 259:
 
 /* Line 1455 of yacc.c  */
-#line 1908 "program_parse.y"
+#line 1925 "program_parse.y"
     { (yyval.integer) = (yyvsp[(2) - (3)].integer); ;}
     break;
 
-  case 259:
+  case 260:
 
 /* Line 1455 of yacc.c  */
-#line 1911 "program_parse.y"
+#line 1928 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
-  case 260:
+  case 261:
 
 /* Line 1455 of yacc.c  */
-#line 1912 "program_parse.y"
+#line 1929 "program_parse.y"
     { (yyval.integer) = (yyvsp[(2) - (3)].integer); ;}
     break;
 
-  case 261:
+  case 262:
 
 /* Line 1455 of yacc.c  */
-#line 1915 "program_parse.y"
+#line 1932 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
-  case 262:
+  case 263:
 
 /* Line 1455 of yacc.c  */
-#line 1916 "program_parse.y"
+#line 1933 "program_parse.y"
     { (yyval.integer) = (yyvsp[(2) - (3)].integer); ;}
     break;
 
-  case 263:
+  case 264:
 
 /* Line 1455 of yacc.c  */
-#line 1920 "program_parse.y"
+#line 1937 "program_parse.y"
     {
           if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxTextureCoordUnits) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid texture coordinate unit selector");
@@ -4572,10 +4596,10 @@ yyreduce:
        ;}
     break;
 
-  case 264:
+  case 265:
 
 /* Line 1455 of yacc.c  */
-#line 1931 "program_parse.y"
+#line 1948 "program_parse.y"
     {
           if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxTextureImageUnits) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid texture image unit selector");
@@ -4586,10 +4610,10 @@ yyreduce:
        ;}
     break;
 
-  case 265:
+  case 266:
 
 /* Line 1455 of yacc.c  */
-#line 1942 "program_parse.y"
+#line 1959 "program_parse.y"
     {
           if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxTextureUnits) {
              yyerror(& (yylsp[(1) - (1)]), state, "invalid texture unit selector");
@@ -4600,10 +4624,10 @@ yyreduce:
        ;}
     break;
 
-  case 266:
+  case 267:
 
 /* Line 1455 of yacc.c  */
-#line 1953 "program_parse.y"
+#line 1970 "program_parse.y"
     {
           struct asm_symbol *exist = (struct asm_symbol *)
              _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(2) - (4)].string));
@@ -4627,7 +4651,7 @@ yyreduce:
 
 
 /* Line 1455 of yacc.c  */
-#line 4631 "program_parse.tab.c"
+#line 4655 "program_parse.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
@@ -4846,7 +4870,7 @@ yyreturn:
 
 
 /* Line 1675 of yacc.c  */
-#line 1973 "program_parse.y"
+#line 1990 "program_parse.y"
 
 
 struct asm_instruction *
index 4cd459a096fc7d6a1f7039178294c115e6824e81..fa94f763c4d6cbec7c319a051715a44ea2663361 100644 (file)
@@ -534,6 +534,23 @@ scalarSrcReg: optionalSign srcReg scalarSuffix
           $$.Base.Swizzle = _mesa_combine_swizzles($$.Base.Swizzle,
                                                    $3.swizzle);
        }
+       | optionalSign paramConstScalarUse
+       {
+          struct asm_symbol temp_sym;
+
+          if (!state->option.NV_fragment) {
+             yyerror(& @2, state, "expected scalar suffix");
+             YYERROR;
+          }
+
+          memset(& temp_sym, 0, sizeof(temp_sym));
+          temp_sym.param_binding_begin = ~0;
+          initialize_symbol_from_const(state->prog, & temp_sym, & $2);
+
+          init_src_reg(& $$);
+          $$.Base.File = PROGRAM_CONSTANT;
+          $$.Base.Index = temp_sym.param_binding_begin;
+       }
        ;
 
 swizzleSrcReg: optionalSign srcReg swizzleSuffix