src/mesa/shader/program_lexer.l

   1 %{
   2 /*
   3  * Copyright © 2009 Intel Corporation
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24 #include "main/glheader.h"
  25 #include "prog_instruction.h"
  26 #include "prog_statevars.h"
  27
  28 #include "program_parser.h"
  29 #include "program_parse.tab.h"
  30
  31 #define require_ARB_vp (yyextra->mode == ARB_vertex)
  32 #define require_ARB_fp (yyextra->mode == ARB_fragment)
  33 #define require_shadow (yyextra->option.Shadow)
  34 #define require_rect   (yyextra->option.TexRect)
  35 #define require_texarray        (yyextra->option.TexArray)
  36
  37 #ifndef HAVE_UNISTD_H
  38 #define YY_NO_UNISTD_H
  39 #endif
  40
  41 #define return_token_or_IDENTIFIER(condition, token)    \
  42    do {                                                 \
  43       if (condition) {                                  \
  44          return token;                                  \
  45       } else {                                          \
  46          yylval->string = strdup(yytext);               \
  47          return IDENTIFIER;                             \
  48       }                                                 \
  49    } while (0)
  50
  51 #define return_token_or_DOT(condition, token)           \
  52    do {                                                 \
  53       if (condition) {                                  \
  54          return token;                                  \
  55       } else {                                          \
  56          yyless(1);                                     \
  57          return DOT;                                    \
  58       }                                                 \
  59    } while (0)
  60
  61
  62 #define return_opcode(condition, token, opcode, sat)    \
  63    do {                                                 \
  64       if (condition) {                                  \
  65          yylval->temp_inst.Opcode = OPCODE_ ## opcode;  \
  66          yylval->temp_inst.SaturateMode = SATURATE_ ## sat; \
  67          return token;                                  \
  68       } else {                                          \
  69          yylval->string = strdup(yytext);               \
  70          return IDENTIFIER;                             \
  71       }                                                 \
  72    } while (0)
  73
  74 #define SWIZZLE_INVAL  MAKE_SWIZZLE4(SWIZZLE_NIL, SWIZZLE_NIL, \
  75                                      SWIZZLE_NIL, SWIZZLE_NIL)
  76
  77 static unsigned
  78 mask_from_char(char c)
  79 {
  80    switch (c) {
  81    case 'x':
  82    case 'r':
  83       return WRITEMASK_X;
  84    case 'y':
  85    case 'g':
  86       return WRITEMASK_Y;
  87    case 'z':
  88    case 'b':
  89       return WRITEMASK_Z;
  90    case 'w':
  91    case 'a':
  92       return WRITEMASK_W;
  93    }
  94
  95    return 0;
  96 }
  97
  98 static unsigned
  99 swiz_from_char(char c)
 100 {
 101    switch (c) {
 102    case 'x':
 103    case 'r':
 104       return SWIZZLE_X;
 105    case 'y':
 106    case 'g':
 107       return SWIZZLE_Y;
 108    case 'z':
 109    case 'b':
 110       return SWIZZLE_Z;
 111    case 'w':
 112    case 'a':
 113       return SWIZZLE_W;
 114    }
 115
 116    return 0;
 117 }
 118
 119 #define YY_USER_ACTION                                                  \
 120    do {                                                                 \
 121       yylloc->first_column = yylloc->last_column;                       \
 122       yylloc->last_column += yyleng;                                    \
 123       if ((yylloc->first_line == 1)                                     \
 124           && (yylloc->first_column == 1)) {                             \
 125          yylloc->position = 1;                                          \
 126       } else {                                                          \
 127          yylloc->position += yylloc->last_column - yylloc->first_column; \
 128       }                                                                 \
 129    } while(0);
 130
 131 #define YY_EXTRA_TYPE struct asm_parser_state *
 132 %}
 133
 134 num    [0-9]+
 135 exp    [Ee][-+]?[0-9]+
 136 frac   "."[0-9]+
 137 dot    "."[ \t]*
 138
 139 %option bison-bridge bison-locations reentrant noyywrap
 140 %%
 141
 142 "!!ARBvp1.0"              { return ARBvp_10; }
 143 "!!ARBfp1.0"              { return ARBfp_10; }
 144 ADDRESS                   {
 145    yylval->integer = at_address;
 146    return_token_or_IDENTIFIER(require_ARB_vp, ADDRESS);
 147 }
 148 ALIAS                     { return ALIAS; }
 149 ATTRIB                    { return ATTRIB; }
 150 END                       { return END; }
 151 OPTION                    { return OPTION; }
 152 OUTPUT                    { return OUTPUT; }
 153 PARAM                     { return PARAM; }
 154 TEMP                      { yylval->integer = at_temp; return TEMP; }
 155
 156 ABS       { return_opcode(             1, VECTOR_OP, ABS, OFF); }
 157 ABS_SAT   { return_opcode(require_ARB_fp, VECTOR_OP, ABS, ZERO_ONE); }
 158 ADD       { return_opcode(             1, BIN_OP, ADD, OFF); }
 159 ADD_SAT   { return_opcode(require_ARB_fp, BIN_OP, ADD, ZERO_ONE); }
 160 ARL       { return_opcode(require_ARB_vp, ARL, ARL, OFF); }
 161
 162 CMP       { return_opcode(require_ARB_fp, TRI_OP, CMP, OFF); }
 163 CMP_SAT   { return_opcode(require_ARB_fp, TRI_OP, CMP, ZERO_ONE); }
 164 COS       { return_opcode(require_ARB_fp, SCALAR_OP, COS, OFF); }
 165 COS_SAT   { return_opcode(require_ARB_fp, SCALAR_OP, COS, ZERO_ONE); }
 166
 167 DP3       { return_opcode(             1, BIN_OP, DP3, OFF); }
 168 DP3_SAT   { return_opcode(require_ARB_fp, BIN_OP, DP3, ZERO_ONE); }
 169 DP4       { return_opcode(             1, BIN_OP, DP4, OFF); }
 170 DP4_SAT   { return_opcode(require_ARB_fp, BIN_OP, DP4, ZERO_ONE); }
 171 DPH       { return_opcode(             1, BIN_OP, DPH, OFF); }
 172 DPH_SAT   { return_opcode(require_ARB_fp, BIN_OP, DPH, ZERO_ONE); }
 173 DST       { return_opcode(             1, BIN_OP, DST, OFF); }
 174 DST_SAT   { return_opcode(require_ARB_fp, BIN_OP, DST, ZERO_ONE); }
 175
 176 EX2       { return_opcode(             1, SCALAR_OP, EX2, OFF); }
 177 EX2_SAT   { return_opcode(require_ARB_fp, SCALAR_OP, EX2, ZERO_ONE); }
 178 EXP       { return_opcode(require_ARB_vp, SCALAR_OP, EXP, OFF); }
 179
 180 FLR       { return_opcode(             1, VECTOR_OP, FLR, OFF); }
 181 FLR_SAT   { return_opcode(require_ARB_fp, VECTOR_OP, FLR, ZERO_ONE); }
 182 FRC       { return_opcode(             1, VECTOR_OP, FRC, OFF); }
 183 FRC_SAT   { return_opcode(require_ARB_fp, VECTOR_OP, FRC, ZERO_ONE); }
 184
 185 KIL       { return_opcode(require_ARB_fp, KIL, KIL, OFF); }
 186
 187 LIT       { return_opcode(             1, VECTOR_OP, LIT, OFF); }
 188 LIT_SAT   { return_opcode(require_ARB_fp, VECTOR_OP, LIT, ZERO_ONE); }
 189 LG2       { return_opcode(             1, SCALAR_OP, LG2, OFF); }
 190 LG2_SAT   { return_opcode(require_ARB_fp, SCALAR_OP, LG2, ZERO_ONE); }
 191 LOG       { return_opcode(require_ARB_vp, SCALAR_OP, LOG, OFF); }
 192 LRP       { return_opcode(require_ARB_fp, TRI_OP, LRP, OFF); }
 193 LRP_SAT   { return_opcode(require_ARB_fp, TRI_OP, LRP, ZERO_ONE); }
 194
 195 MAD       { return_opcode(             1, TRI_OP, MAD, OFF); }
 196 MAD_SAT   { return_opcode(require_ARB_fp, TRI_OP, MAD, ZERO_ONE); }
 197 MAX       { return_opcode(             1, BIN_OP, MAX, OFF); }
 198 MAX_SAT   { return_opcode(require_ARB_fp, BIN_OP, MAX, ZERO_ONE); }
 199 MIN       { return_opcode(             1, BIN_OP, MIN, OFF); }
 200 MIN_SAT   { return_opcode(require_ARB_fp, BIN_OP, MIN, ZERO_ONE); }
 201 MOV       { return_opcode(             1, VECTOR_OP, MOV, OFF); }
 202 MOV_SAT   { return_opcode(require_ARB_fp, VECTOR_OP, MOV, ZERO_ONE); }
 203 MUL       { return_opcode(             1, BIN_OP, MUL, OFF); }
 204 MUL_SAT   { return_opcode(require_ARB_fp, BIN_OP, MUL, ZERO_ONE); }
 205
 206 POW       { return_opcode(             1, BINSC_OP, POW, OFF); }
 207 POW_SAT   { return_opcode(require_ARB_fp, BINSC_OP, POW, ZERO_ONE); }
 208
 209 RCP       { return_opcode(             1, SCALAR_OP, RCP, OFF); }
 210 RCP_SAT   { return_opcode(require_ARB_fp, SCALAR_OP, RCP, ZERO_ONE); }
 211 RSQ       { return_opcode(             1, SCALAR_OP, RSQ, OFF); }
 212 RSQ_SAT   { return_opcode(require_ARB_fp, SCALAR_OP, RSQ, ZERO_ONE); }
 213
 214 SCS       { return_opcode(require_ARB_fp, SCALAR_OP, SCS, OFF); }
 215 SCS_SAT   { return_opcode(require_ARB_fp, SCALAR_OP, SCS, ZERO_ONE); }
 216 SGE       { return_opcode(             1, BIN_OP, SGE, OFF); }
 217 SGE_SAT   { return_opcode(require_ARB_fp, BIN_OP, SGE, ZERO_ONE); }
 218 SIN       { return_opcode(require_ARB_fp, SCALAR_OP, SIN, OFF); }
 219 SIN_SAT   { return_opcode(require_ARB_fp, SCALAR_OP, SIN, ZERO_ONE); }
 220 SLT       { return_opcode(             1, BIN_OP, SLT, OFF); }
 221 SLT_SAT   { return_opcode(require_ARB_fp, BIN_OP, SLT, ZERO_ONE); }
 222 SUB       { return_opcode(             1, BIN_OP, SUB, OFF); }
 223 SUB_SAT   { return_opcode(require_ARB_fp, BIN_OP, SUB, ZERO_ONE); }
 224 SWZ       { return_opcode(             1, SWZ, SWZ, OFF); }
 225 SWZ_SAT   { return_opcode(require_ARB_fp, SWZ, SWZ, ZERO_ONE); }
 226
 227 TEX       { return_opcode(require_ARB_fp, SAMPLE_OP, TEX, OFF); }
 228 TEX_SAT   { return_opcode(require_ARB_fp, SAMPLE_OP, TEX, ZERO_ONE); }
 229 TXB       { return_opcode(require_ARB_fp, SAMPLE_OP, TXB, OFF); }
 230 TXB_SAT   { return_opcode(require_ARB_fp, SAMPLE_OP, TXB, ZERO_ONE); }
 231 TXP       { return_opcode(require_ARB_fp, SAMPLE_OP, TXP, OFF); }
 232 TXP_SAT   { return_opcode(require_ARB_fp, SAMPLE_OP, TXP, ZERO_ONE); }
 233
 234 XPD       { return_opcode(             1, BIN_OP, XPD, OFF); }
 235 XPD_SAT   { return_opcode(require_ARB_fp, BIN_OP, XPD, ZERO_ONE); }
 236
 237 vertex                    { return_token_or_IDENTIFIER(require_ARB_vp, VERTEX); }
 238 fragment                  { return_token_or_IDENTIFIER(require_ARB_fp, FRAGMENT); }
 239 program                   { return PROGRAM; }
 240 state                     { return STATE; }
 241 result                    { return RESULT; }
 242
 243 {dot}ambient              { return AMBIENT; }
 244 {dot}attenuation          { return ATTENUATION; }
 245 {dot}back                 { return BACK; }
 246 {dot}clip                 { return_token_or_DOT(require_ARB_vp, CLIP); }
 247 {dot}color                { return COLOR; }
 248 {dot}depth                { return_token_or_DOT(require_ARB_fp, DEPTH); }
 249 {dot}diffuse              { return DIFFUSE; }
 250 {dot}direction            { return DIRECTION; }
 251 {dot}emission             { return EMISSION; }
 252 {dot}env                  { return ENV; }
 253 {dot}eye                  { return EYE; }
 254 {dot}fogcoord             { return FOGCOORD; }
 255 {dot}fog                  { return FOG; }
 256 {dot}front                { return FRONT; }
 257 {dot}half                 { return HALF; }
 258 {dot}inverse              { return INVERSE; }
 259 {dot}invtrans             { return INVTRANS; }
 260 {dot}light                { return LIGHT; }
 261 {dot}lightmodel           { return LIGHTMODEL; }
 262 {dot}lightprod            { return LIGHTPROD; }
 263 {dot}local                { return LOCAL; }
 264 {dot}material             { return MATERIAL; }
 265 {dot}program              { return MAT_PROGRAM; }
 266 {dot}matrix               { return MATRIX; }
 267 {dot}matrixindex          { return_token_or_DOT(require_ARB_vp, MATRIXINDEX); }
 268 {dot}modelview            { return MODELVIEW; }
 269 {dot}mvp                  { return MVP; }
 270 {dot}normal               { return_token_or_DOT(require_ARB_vp, NORMAL); }
 271 {dot}object               { return OBJECT; }
 272 {dot}palette              { return PALETTE; }
 273 {dot}params               { return PARAMS; }
 274 {dot}plane                { return PLANE; }
 275 {dot}point                { return_token_or_DOT(require_ARB_vp, POINT_TOK); }
 276 {dot}pointsize            { return_token_or_DOT(require_ARB_vp, POINTSIZE); }
 277 {dot}position             { return POSITION; }
 278 {dot}primary              { return PRIMARY; }
 279 {dot}projection           { return PROJECTION; }
 280 {dot}range                { return_token_or_DOT(require_ARB_fp, RANGE); }
 281 {dot}row                  { return ROW; }
 282 {dot}scenecolor           { return SCENECOLOR; }
 283 {dot}secondary            { return SECONDARY; }
 284 {dot}shininess            { return SHININESS; }
 285 {dot}size                 { return_token_or_DOT(require_ARB_vp, SIZE_TOK); }
 286 {dot}specular             { return SPECULAR; }
 287 {dot}spot                 { return SPOT; }
 288 {dot}texcoord             { return TEXCOORD; }
 289 {dot}texenv               { return_token_or_DOT(require_ARB_fp, TEXENV); }
 290 {dot}texgen               { return_token_or_DOT(require_ARB_vp, TEXGEN); }
 291 {dot}q                    { return_token_or_DOT(require_ARB_vp, TEXGEN_Q); }
 292 {dot}s                    { return_token_or_DOT(require_ARB_vp, TEXGEN_S); }
 293 {dot}t                    { return_token_or_DOT(require_ARB_vp, TEXGEN_T); }
 294 {dot}texture              { return TEXTURE; }
 295 {dot}transpose            { return TRANSPOSE; }
 296 {dot}attrib               { return_token_or_DOT(require_ARB_vp, VTXATTRIB); }
 297 {dot}weight               { return_token_or_DOT(require_ARB_vp, WEIGHT); }
 298
 299 texture                   { return_token_or_IDENTIFIER(require_ARB_fp, TEXTURE_UNIT); }
 300 1D                        { return_token_or_IDENTIFIER(require_ARB_fp, TEX_1D); }
 301 2D                        { return_token_or_IDENTIFIER(require_ARB_fp, TEX_2D); }
 302 3D                        { return_token_or_IDENTIFIER(require_ARB_fp, TEX_3D); }
 303 CUBE                      { return_token_or_IDENTIFIER(require_ARB_fp, TEX_CUBE); }
 304 RECT                      { return_token_or_IDENTIFIER(require_ARB_fp && require_rect, TEX_RECT); }
 305 SHADOW1D                  { return_token_or_IDENTIFIER(require_ARB_fp && require_shadow, TEX_SHADOW1D); }
 306 SHADOW2D                  { return_token_or_IDENTIFIER(require_ARB_fp && require_shadow, TEX_SHADOW2D); }
 307 SHADOWRECT                { return_token_or_IDENTIFIER(require_ARB_fp && require_shadow && require_rect, TEX_SHADOWRECT); }
 308 ARRAY1D                   { return_token_or_IDENTIFIER(require_ARB_fp && require_texarray, TEX_ARRAY1D); }
 309 ARRAY2D                   { return_token_or_IDENTIFIER(require_ARB_fp && require_texarray, TEX_ARRAY2D); }
 310 ARRAYSHADOW1D             { return_token_or_IDENTIFIER(require_ARB_fp && require_shadow && require_texarray, TEX_ARRAYSHADOW1D); }
 311 ARRAYSHADOW2D             { return_token_or_IDENTIFIER(require_ARB_fp && require_shadow && require_texarray, TEX_ARRAYSHADOW2D); }
 312
 313 [_a-zA-Z$][_a-zA-Z0-9$]*  {
 314    yylval->string = strdup(yytext);
 315    return IDENTIFIER;
 316 }
 317
 318 ".."                      { return DOT_DOT; }
 319
 320 {num}                     {
 321    yylval->integer = strtol(yytext, NULL, 10);
 322    return INTEGER;
 323 }
 324 {num}?{frac}{exp}?        {
 325    yylval->real = strtod(yytext, NULL);
 326    return REAL;
 327 }
 328 {num}"."/[^.]             {
 329    yylval->real = strtod(yytext, NULL);
 330    return REAL;
 331 }
 332 {num}{exp}                {
 333    yylval->real = strtod(yytext, NULL);
 334    return REAL;
 335 }
 336 {num}"."{exp}             {
 337    yylval->real = strtod(yytext, NULL);
 338    return REAL;
 339 }
 340
 341 ".xyzw"                   {
 342    yylval->swiz_mask.swizzle = SWIZZLE_NOOP;
 343    yylval->swiz_mask.mask = WRITEMASK_XYZW;
 344    return MASK4;
 345 }
 346
 347 ".xy"[zw]                 {
 348    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 349    yylval->swiz_mask.mask = WRITEMASK_XY
 350       | mask_from_char(yytext[3]);
 351    return MASK3;
 352 }
 353 ".xzw"                    {
 354    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 355    yylval->swiz_mask.mask = WRITEMASK_XZW;
 356    return MASK3;
 357 }
 358 ".yzw"                    {
 359    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 360    yylval->swiz_mask.mask = WRITEMASK_YZW;
 361    return MASK3;
 362 }
 363
 364 ".x"[yzw]                 {
 365    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 366    yylval->swiz_mask.mask = WRITEMASK_X
 367       | mask_from_char(yytext[2]);
 368    return MASK2;
 369 }
 370 ".y"[zw]                  {
 371    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 372    yylval->swiz_mask.mask = WRITEMASK_Y
 373       | mask_from_char(yytext[2]);
 374    return MASK2;
 375 }
 376 ".zw"                     {
 377    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 378    yylval->swiz_mask.mask = WRITEMASK_ZW;
 379    return MASK2;
 380 }
 381
 382 "."[xyzw]                 {
 383    const unsigned s = swiz_from_char(yytext[1]);
 384    yylval->swiz_mask.swizzle = MAKE_SWIZZLE4(s, s, s, s);
 385    yylval->swiz_mask.mask = mask_from_char(yytext[1]);
 386    return MASK1;
 387 }
 388
 389 "."[xyzw]{4}              {
 390    yylval->swiz_mask.swizzle = MAKE_SWIZZLE4(swiz_from_char(yytext[1]),
 391                                             swiz_from_char(yytext[2]),
 392                                             swiz_from_char(yytext[3]),
 393                                             swiz_from_char(yytext[4]));
 394    yylval->swiz_mask.mask = 0;
 395    return SWIZZLE;
 396 }
 397
 398 ".rgba"                   {
 399    yylval->swiz_mask.swizzle = SWIZZLE_NOOP;
 400    yylval->swiz_mask.mask = WRITEMASK_XYZW;
 401    return_token_or_DOT(require_ARB_fp, MASK4);
 402 }
 403
 404 ".rg"[ba]                 {
 405    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 406    yylval->swiz_mask.mask = WRITEMASK_XY
 407       | mask_from_char(yytext[3]);
 408    return_token_or_DOT(require_ARB_fp, MASK3);
 409 }
 410 ".rba"                    {
 411    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 412    yylval->swiz_mask.mask = WRITEMASK_XZW;
 413    return_token_or_DOT(require_ARB_fp, MASK3);
 414 }
 415 ".gba"                    {
 416    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 417    yylval->swiz_mask.mask = WRITEMASK_YZW;
 418    return_token_or_DOT(require_ARB_fp, MASK3);
 419 }
 420
 421 ".r"[gba]                 {
 422    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 423    yylval->swiz_mask.mask = WRITEMASK_X
 424       | mask_from_char(yytext[2]);
 425    return_token_or_DOT(require_ARB_fp, MASK2);
 426 }
 427 ".g"[ba]                  {
 428    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 429    yylval->swiz_mask.mask = WRITEMASK_Y
 430       | mask_from_char(yytext[2]);
 431    return_token_or_DOT(require_ARB_fp, MASK2);
 432 }
 433 ".ba"                     {
 434    yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
 435    yylval->swiz_mask.mask = WRITEMASK_ZW;
 436    return_token_or_DOT(require_ARB_fp, MASK2);
 437 }
 438
 439 "."[gba]                  {
 440    const unsigned s = swiz_from_char(yytext[1]);
 441    yylval->swiz_mask.swizzle = MAKE_SWIZZLE4(s, s, s, s);
 442    yylval->swiz_mask.mask = mask_from_char(yytext[1]);
 443    return_token_or_DOT(require_ARB_fp, MASK1);
 444 }
 445
 446
 447 ".r"                      {
 448    if (require_ARB_vp) {
 449       return TEXGEN_R;
 450    } else {
 451       yylval->swiz_mask.swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X,
 452                                                 SWIZZLE_X, SWIZZLE_X);
 453       yylval->swiz_mask.mask = WRITEMASK_X;
 454       return MASK1;
 455    }
 456 }
 457
 458 "."[rgba]{4}              {
 459    yylval->swiz_mask.swizzle = MAKE_SWIZZLE4(swiz_from_char(yytext[1]),
 460                                             swiz_from_char(yytext[2]),
 461                                             swiz_from_char(yytext[3]),
 462                                             swiz_from_char(yytext[4]));
 463    yylval->swiz_mask.mask = 0;
 464    return_token_or_DOT(require_ARB_fp, SWIZZLE);
 465 }
 466
 467 "."                       { return DOT; }
 468
 469 \n                        {
 470    yylloc->first_line++;
 471    yylloc->first_column = 1;
 472    yylloc->last_line++;
 473    yylloc->last_column = 1;
 474    yylloc->position++;
 475 }
 476 [ \t\r]+                  /* eat whitespace */ ;
 477 #.*$                      /* eat comments */ ;
 478 .                         { return yytext[0]; }
 479 %%
 480
 481 void
 482 _mesa_program_lexer_ctor(void **scanner, struct asm_parser_state *state,
 483                          const char *string, size_t len)
 484 {
 485    yylex_init_extra(state, scanner);
 486    yy_scan_bytes(string, len, *scanner);
 487 }
 488
 489 void
 490 _mesa_program_lexer_dtor(void *scanner)
 491 {
 492    yylex_destroy(scanner);
 493 }