src/gallium/auxiliary/tgsi/tgsi_text.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "util/u_debug.h"
  29 #include "util/u_memory.h"
  30 #include "util/u_prim.h"
  31 #include "pipe/p_defines.h"
  32 #include "util/u_inlines.h"
  33 #include "tgsi_text.h"
  34 #include "tgsi_build.h"
  35 #include "tgsi_info.h"
  36 #include "tgsi_parse.h"
  37 #include "tgsi_sanity.h"
  38 #include "tgsi_strings.h"
  39 #include "tgsi_util.h"
  40 #include "tgsi_dump.h"
  41
  42 static boolean is_alpha_underscore( const char *cur )
  43 {
  44    return
  45       (*cur >= 'a' && *cur <= 'z') ||
  46       (*cur >= 'A' && *cur <= 'Z') ||
  47       *cur == '_';
  48 }
  49
  50 static boolean is_digit( const char *cur )
  51 {
  52    return *cur >= '0' && *cur <= '9';
  53 }
  54
  55 static boolean is_digit_alpha_underscore( const char *cur )
  56 {
  57    return is_digit( cur ) || is_alpha_underscore( cur );
  58 }
  59
  60 static char uprcase( char c )
  61 {
  62    if (c >= 'a' && c <= 'z')
  63       return c + 'A' - 'a';
  64    return c;
  65 }
  66
  67 /*
  68  * Ignore case of str1 and assume str1 is already uppercase.
  69  * Return TRUE iff str1 and str2 are equal.
  70  */
  71 static int
  72 streq_nocase_uprcase(const char *str1,
  73                      const char *str2)
  74 {
  75    while (*str1 && *str2) {
  76       if (*str1 != uprcase(*str2))
  77          return FALSE;
  78       str1++;
  79       str2++;
  80    }
  81    return *str1 == 0 && *str2 == 0;
  82 }
  83
  84 /* Return TRUE if both strings match.
  85  * The second string is terminated by zero.
  86  * The pointer to the first string is moved at end of the read word
  87  * on success.
  88  */
  89 static boolean str_match_no_case( const char **pcur, const char *str )
  90 {
  91    const char *cur = *pcur;
  92
  93    while (*str != '\0' && *str == uprcase( *cur )) {
  94       str++;
  95       cur++;
  96    }
  97    if (*str == '\0') {
  98       *pcur = cur;
  99       return TRUE;
 100    }
 101    return FALSE;
 102 }
 103
 104 /* Return TRUE if both strings match.
 105  * The first string is be terminated by a non-digit non-letter non-underscore
 106  * character, the second string is terminated by zero.
 107  * The pointer to the first string is moved at end of the read word
 108  * on success.
 109  */
 110 static boolean str_match_nocase_whole( const char **pcur, const char *str )
 111 {
 112    const char *cur = *pcur;
 113
 114    if (str_match_no_case(&cur, str) &&
 115        !is_digit_alpha_underscore(cur)) {
 116       *pcur = cur;
 117       return TRUE;
 118    }
 119    return FALSE;
 120 }
 121
 122 /* Eat zero or more whitespaces.
 123  */
 124 static void eat_opt_white( const char **pcur )
 125 {
 126    while (**pcur == ' ' || **pcur == '\t' || **pcur == '\n')
 127       (*pcur)++;
 128 }
 129
 130 /* Eat one or more whitespaces.
 131  * Return TRUE if at least one whitespace eaten.
 132  */
 133 static boolean eat_white( const char **pcur )
 134 {
 135    const char *cur = *pcur;
 136
 137    eat_opt_white( pcur );
 138    return *pcur > cur;
 139 }
 140
 141 /* Parse unsigned integer.
 142  * No checks for overflow.
 143  */
 144 static boolean parse_uint( const char **pcur, uint *val )
 145 {
 146    const char *cur = *pcur;
 147
 148    if (is_digit( cur )) {
 149       *val = *cur++ - '0';
 150       while (is_digit( cur ))
 151          *val = *val * 10 + *cur++ - '0';
 152       *pcur = cur;
 153       return TRUE;
 154    }
 155    return FALSE;
 156 }
 157
 158 static boolean parse_int( const char **pcur, int *val )
 159 {
 160    const char *cur = *pcur;
 161    int sign = (*cur == '-' ? -1 : 1);
 162
 163    if (*cur == '+' || *cur == '-')
 164       cur++;
 165
 166    if (parse_uint(&cur, (uint *)val)) {
 167       *val *= sign;
 168       *pcur = cur;
 169       return TRUE;
 170    }
 171
 172    return FALSE;
 173 }
 174
 175 static boolean parse_identifier( const char **pcur, char *ret )
 176 {
 177    const char *cur = *pcur;
 178    int i = 0;
 179    if (is_alpha_underscore( cur )) {
 180       ret[i++] = *cur++;
 181       while (is_alpha_underscore( cur ) || is_digit( cur ))
 182          ret[i++] = *cur++;
 183       ret[i++] = '\0';
 184       *pcur = cur;
 185       return TRUE;
 186    }
 187    return FALSE;
 188 }
 189
 190 /* Parse floating point.
 191  */
 192 static boolean parse_float( const char **pcur, float *val )
 193 {
 194    const char *cur = *pcur;
 195    boolean integral_part = FALSE;
 196    boolean fractional_part = FALSE;
 197
 198    *val = (float) atof( cur );
 199
 200    if (*cur == '-' || *cur == '+')
 201       cur++;
 202    if (is_digit( cur )) {
 203       cur++;
 204       integral_part = TRUE;
 205       while (is_digit( cur ))
 206          cur++;
 207    }
 208    if (*cur == '.') {
 209       cur++;
 210       if (is_digit( cur )) {
 211          cur++;
 212          fractional_part = TRUE;
 213          while (is_digit( cur ))
 214             cur++;
 215       }
 216    }
 217    if (!integral_part && !fractional_part)
 218       return FALSE;
 219    if (uprcase( *cur ) == 'E') {
 220       cur++;
 221       if (*cur == '-' || *cur == '+')
 222          cur++;
 223       if (is_digit( cur )) {
 224          cur++;
 225          while (is_digit( cur ))
 226             cur++;
 227       }
 228       else
 229          return FALSE;
 230    }
 231    *pcur = cur;
 232    return TRUE;
 233 }
 234
 235 struct translate_ctx
 236 {
 237    const char *text;
 238    const char *cur;
 239    struct tgsi_token *tokens;
 240    struct tgsi_token *tokens_cur;
 241    struct tgsi_token *tokens_end;
 242    struct tgsi_header *header;
 243    unsigned processor : 4;
 244    int implied_array_size : 5;
 245 };
 246
 247 static void report_error( struct translate_ctx *ctx, const char *msg )
 248 {
 249    int line = 1;
 250    int column = 1;
 251    const char *itr = ctx->text;
 252
 253    while (itr != ctx->cur) {
 254       if (*itr == '\n') {
 255          column = 1;
 256          ++line;
 257       }
 258       ++column;
 259       ++itr;
 260    }
 261
 262    debug_printf( "\nTGSI asm error: %s [%d : %d] \n", msg, line, column );
 263 }
 264
 265 /* Parse shader header.
 266  * Return TRUE for one of the following headers.
 267  *    FRAG
 268  *    GEOM
 269  *    VERT
 270  */
 271 static boolean parse_header( struct translate_ctx *ctx )
 272 {
 273    uint processor;
 274
 275    if (str_match_nocase_whole( &ctx->cur, "FRAG" ))
 276       processor = TGSI_PROCESSOR_FRAGMENT;
 277    else if (str_match_nocase_whole( &ctx->cur, "VERT" ))
 278       processor = TGSI_PROCESSOR_VERTEX;
 279    else if (str_match_nocase_whole( &ctx->cur, "GEOM" ))
 280       processor = TGSI_PROCESSOR_GEOMETRY;
 281    else if (str_match_nocase_whole( &ctx->cur, "COMP" ))
 282       processor = TGSI_PROCESSOR_COMPUTE;
 283    else {
 284       report_error( ctx, "Unknown header" );
 285       return FALSE;
 286    }
 287
 288    if (ctx->tokens_cur >= ctx->tokens_end)
 289       return FALSE;
 290    ctx->header = (struct tgsi_header *) ctx->tokens_cur++;
 291    *ctx->header = tgsi_build_header();
 292
 293    if (ctx->tokens_cur >= ctx->tokens_end)
 294       return FALSE;
 295    *(struct tgsi_processor *) ctx->tokens_cur++ = tgsi_build_processor( processor, ctx->header );
 296    ctx->processor = processor;
 297
 298    return TRUE;
 299 }
 300
 301 static boolean parse_label( struct translate_ctx *ctx, uint *val )
 302 {
 303    const char *cur = ctx->cur;
 304
 305    if (parse_uint( &cur, val )) {
 306       eat_opt_white( &cur );
 307       if (*cur == ':') {
 308          cur++;
 309          ctx->cur = cur;
 310          return TRUE;
 311       }
 312    }
 313    return FALSE;
 314 }
 315
 316 static boolean
 317 parse_file( const char **pcur, uint *file )
 318 {
 319    uint i;
 320
 321    for (i = 0; i < TGSI_FILE_COUNT; i++) {
 322       const char *cur = *pcur;
 323
 324       if (str_match_nocase_whole( &cur, tgsi_file_names[i] )) {
 325          *pcur = cur;
 326          *file = i;
 327          return TRUE;
 328       }
 329    }
 330    return FALSE;
 331 }
 332
 333 static boolean
 334 parse_opt_writemask(
 335    struct translate_ctx *ctx,
 336    uint *writemask )
 337 {
 338    const char *cur;
 339
 340    cur = ctx->cur;
 341    eat_opt_white( &cur );
 342    if (*cur == '.') {
 343       cur++;
 344       *writemask = TGSI_WRITEMASK_NONE;
 345       eat_opt_white( &cur );
 346       if (uprcase( *cur ) == 'X') {
 347          cur++;
 348          *writemask |= TGSI_WRITEMASK_X;
 349       }
 350       if (uprcase( *cur ) == 'Y') {
 351          cur++;
 352          *writemask |= TGSI_WRITEMASK_Y;
 353       }
 354       if (uprcase( *cur ) == 'Z') {
 355          cur++;
 356          *writemask |= TGSI_WRITEMASK_Z;
 357       }
 358       if (uprcase( *cur ) == 'W') {
 359          cur++;
 360          *writemask |= TGSI_WRITEMASK_W;
 361       }
 362
 363       if (*writemask == TGSI_WRITEMASK_NONE) {
 364          report_error( ctx, "Writemask expected" );
 365          return FALSE;
 366       }
 367
 368       ctx->cur = cur;
 369    }
 370    else {
 371       *writemask = TGSI_WRITEMASK_XYZW;
 372    }
 373    return TRUE;
 374 }
 375
 376
 377 /* <register_file_bracket> ::= <file> `['
 378  */
 379 static boolean
 380 parse_register_file_bracket(
 381    struct translate_ctx *ctx,
 382    uint *file )
 383 {
 384    if (!parse_file( &ctx->cur, file )) {
 385       report_error( ctx, "Unknown register file" );
 386       return FALSE;
 387    }
 388    eat_opt_white( &ctx->cur );
 389    if (*ctx->cur != '[') {
 390       report_error( ctx, "Expected `['" );
 391       return FALSE;
 392    }
 393    ctx->cur++;
 394    return TRUE;
 395 }
 396
 397 /* <register_file_bracket_index> ::= <register_file_bracket> <uint>
 398  */
 399 static boolean
 400 parse_register_file_bracket_index(
 401    struct translate_ctx *ctx,
 402    uint *file,
 403    int *index )
 404 {
 405    uint uindex;
 406
 407    if (!parse_register_file_bracket( ctx, file ))
 408       return FALSE;
 409    eat_opt_white( &ctx->cur );
 410    if (!parse_uint( &ctx->cur, &uindex )) {
 411       report_error( ctx, "Expected literal unsigned integer" );
 412       return FALSE;
 413    }
 414    *index = (int) uindex;
 415    return TRUE;
 416 }
 417
 418 /* Parse simple 1d register operand.
 419  *    <register_dst> ::= <register_file_bracket_index> `]'
 420  */
 421 static boolean
 422 parse_register_1d(struct translate_ctx *ctx,
 423                   uint *file,
 424                   int *index )
 425 {
 426    if (!parse_register_file_bracket_index( ctx, file, index ))
 427       return FALSE;
 428    eat_opt_white( &ctx->cur );
 429    if (*ctx->cur != ']') {
 430       report_error( ctx, "Expected `]'" );
 431       return FALSE;
 432    }
 433    ctx->cur++;
 434    return TRUE;
 435 }
 436
 437 struct parsed_bracket {
 438    int index;
 439
 440    uint ind_file;
 441    int ind_index;
 442    uint ind_comp;
 443 };
 444
 445
 446 static boolean
 447 parse_register_bracket(
 448    struct translate_ctx *ctx,
 449    struct parsed_bracket *brackets)
 450 {
 451    const char *cur;
 452    uint uindex;
 453
 454    memset(brackets, 0, sizeof(struct parsed_bracket));
 455
 456    eat_opt_white( &ctx->cur );
 457
 458    cur = ctx->cur;
 459    if (parse_file( &cur, &brackets->ind_file )) {
 460       if (!parse_register_1d( ctx, &brackets->ind_file,
 461                               &brackets->ind_index ))
 462          return FALSE;
 463       eat_opt_white( &ctx->cur );
 464
 465       if (*ctx->cur == '.') {
 466          ctx->cur++;
 467          eat_opt_white(&ctx->cur);
 468
 469          switch (uprcase(*ctx->cur)) {
 470          case 'X':
 471             brackets->ind_comp = TGSI_SWIZZLE_X;
 472             break;
 473          case 'Y':
 474             brackets->ind_comp = TGSI_SWIZZLE_Y;
 475             break;
 476          case 'Z':
 477             brackets->ind_comp = TGSI_SWIZZLE_Z;
 478             break;
 479          case 'W':
 480             brackets->ind_comp = TGSI_SWIZZLE_W;
 481             break;
 482          default:
 483             report_error(ctx, "Expected indirect register swizzle component `x', `y', `z' or `w'");
 484             return FALSE;
 485          }
 486          ctx->cur++;
 487          eat_opt_white(&ctx->cur);
 488       }
 489
 490       if (*ctx->cur == '+' || *ctx->cur == '-')
 491          parse_int( &ctx->cur, &brackets->index );
 492       else
 493          brackets->index = 0;
 494    }
 495    else {
 496       if (!parse_uint( &ctx->cur, &uindex )) {
 497          report_error( ctx, "Expected literal unsigned integer" );
 498          return FALSE;
 499       }
 500       brackets->index = (int) uindex;
 501       brackets->ind_file = TGSI_FILE_NULL;
 502       brackets->ind_index = 0;
 503    }
 504    eat_opt_white( &ctx->cur );
 505    if (*ctx->cur != ']') {
 506       report_error( ctx, "Expected `]'" );
 507       return FALSE;
 508    }
 509    ctx->cur++;
 510    return TRUE;
 511 }
 512
 513 static boolean
 514 parse_opt_register_src_bracket(
 515    struct translate_ctx *ctx,
 516    struct parsed_bracket *brackets,
 517    int *parsed_brackets)
 518 {
 519    const char *cur = ctx->cur;
 520
 521    *parsed_brackets = 0;
 522
 523    eat_opt_white( &cur );
 524    if (cur[0] == '[') {
 525       ++cur;
 526       ctx->cur = cur;
 527
 528       if (!parse_register_bracket(ctx, brackets))
 529          return FALSE;
 530
 531       *parsed_brackets = 1;
 532    }
 533
 534    return TRUE;
 535 }
 536
 537
 538 /* Parse source register operand.
 539  *    <register_src> ::= <register_file_bracket_index> `]' |
 540  *                       <register_file_bracket> <register_dst> [`.' (`x' | `y' | `z' | `w')] `]' |
 541  *                       <register_file_bracket> <register_dst> [`.' (`x' | `y' | `z' | `w')] `+' <uint> `]' |
 542  *                       <register_file_bracket> <register_dst> [`.' (`x' | `y' | `z' | `w')] `-' <uint> `]'
 543  */
 544 static boolean
 545 parse_register_src(
 546    struct translate_ctx *ctx,
 547    uint *file,
 548    struct parsed_bracket *brackets)
 549 {
 550    brackets->ind_comp = TGSI_SWIZZLE_X;
 551    if (!parse_register_file_bracket( ctx, file ))
 552       return FALSE;
 553    if (!parse_register_bracket( ctx, brackets ))
 554        return FALSE;
 555
 556    return TRUE;
 557 }
 558
 559 struct parsed_dcl_bracket {
 560    uint first;
 561    uint last;
 562 };
 563
 564 static boolean
 565 parse_register_dcl_bracket(
 566    struct translate_ctx *ctx,
 567    struct parsed_dcl_bracket *bracket)
 568 {
 569    uint uindex;
 570    memset(bracket, 0, sizeof(struct parsed_dcl_bracket));
 571
 572    eat_opt_white( &ctx->cur );
 573
 574    if (!parse_uint( &ctx->cur, &uindex )) {
 575       /* it can be an empty bracket [] which means its range
 576        * is from 0 to some implied size */
 577       if (ctx->cur[0] == ']' && ctx->implied_array_size != 0) {
 578          bracket->first = 0;
 579          bracket->last = ctx->implied_array_size - 1;
 580          goto cleanup;
 581       }
 582       report_error( ctx, "Expected literal unsigned integer" );
 583       return FALSE;
 584    }
 585    bracket->first = uindex;
 586
 587    eat_opt_white( &ctx->cur );
 588
 589    if (ctx->cur[0] == '.' && ctx->cur[1] == '.') {
 590       uint uindex;
 591
 592       ctx->cur += 2;
 593       eat_opt_white( &ctx->cur );
 594       if (!parse_uint( &ctx->cur, &uindex )) {
 595          report_error( ctx, "Expected literal integer" );
 596          return FALSE;
 597       }
 598       bracket->last = (int) uindex;
 599       eat_opt_white( &ctx->cur );
 600    }
 601    else {
 602       bracket->last = bracket->first;
 603    }
 604
 605 cleanup:
 606    if (*ctx->cur != ']') {
 607       report_error( ctx, "Expected `]' or `..'" );
 608       return FALSE;
 609    }
 610    ctx->cur++;
 611    return TRUE;
 612 }
 613
 614 /* Parse register declaration.
 615  *    <register_dcl> ::= <register_file_bracket_index> `]' |
 616  *                       <register_file_bracket_index> `..' <index> `]'
 617  */
 618 static boolean
 619 parse_register_dcl(
 620    struct translate_ctx *ctx,
 621    uint *file,
 622    struct parsed_dcl_bracket *brackets,
 623    int *num_brackets)
 624 {
 625    const char *cur;
 626
 627    *num_brackets = 0;
 628
 629    if (!parse_register_file_bracket( ctx, file ))
 630       return FALSE;
 631    if (!parse_register_dcl_bracket( ctx, &brackets[0] ))
 632       return FALSE;
 633
 634    *num_brackets = 1;
 635
 636    cur = ctx->cur;
 637    eat_opt_white( &cur );
 638
 639    if (cur[0] == '[') {
 640       ++cur;
 641       ctx->cur = cur;
 642       if (!parse_register_dcl_bracket( ctx, &brackets[1] ))
 643          return FALSE;
 644       /* for geometry shader we don't really care about
 645        * the first brackets it's always the size of the
 646        * input primitive. so we want to declare just
 647        * the index relevant to the semantics which is in
 648        * the second bracket */
 649       if (ctx->processor == TGSI_PROCESSOR_GEOMETRY && *file == TGSI_FILE_INPUT) {
 650          brackets[0] = brackets[1];
 651          *num_brackets = 1;
 652       } else {
 653          *num_brackets = 2;
 654       }
 655    }
 656
 657    return TRUE;
 658 }
 659
 660
 661 /* Parse destination register operand.*/
 662 static boolean
 663 parse_register_dst(
 664    struct translate_ctx *ctx,
 665    uint *file,
 666    struct parsed_bracket *brackets)
 667 {
 668    brackets->ind_comp = TGSI_SWIZZLE_X;
 669    if (!parse_register_file_bracket( ctx, file ))
 670       return FALSE;
 671    if (!parse_register_bracket( ctx, brackets ))
 672        return FALSE;
 673
 674    return TRUE;
 675 }
 676
 677 static boolean
 678 parse_dst_operand(
 679    struct translate_ctx *ctx,
 680    struct tgsi_full_dst_register *dst )
 681 {
 682    uint file;
 683    uint writemask;
 684    const char *cur;
 685    struct parsed_bracket bracket[2];
 686    int parsed_opt_brackets;
 687
 688    if (!parse_register_dst( ctx, &file, &bracket[0] ))
 689       return FALSE;
 690    if (!parse_opt_register_src_bracket(ctx, &bracket[1], &parsed_opt_brackets))
 691       return FALSE;
 692
 693    cur = ctx->cur;
 694    eat_opt_white( &cur );
 695
 696    if (!parse_opt_writemask( ctx, &writemask ))
 697       return FALSE;
 698
 699    dst->Register.File = file;
 700    if (parsed_opt_brackets) {
 701       dst->Register.Dimension = 1;
 702       dst->Dimension.Indirect = 0;
 703       dst->Dimension.Dimension = 0;
 704       dst->Dimension.Index = bracket[0].index;
 705       bracket[0] = bracket[1];
 706    }
 707    dst->Register.Index = bracket[0].index;
 708    dst->Register.WriteMask = writemask;
 709    if (bracket[0].ind_file != TGSI_FILE_NULL) {
 710       dst->Register.Indirect = 1;
 711       dst->Indirect.File = bracket[0].ind_file;
 712       dst->Indirect.Index = bracket[0].ind_index;
 713       dst->Indirect.SwizzleX = bracket[0].ind_comp;
 714       dst->Indirect.SwizzleY = bracket[0].ind_comp;
 715       dst->Indirect.SwizzleZ = bracket[0].ind_comp;
 716       dst->Indirect.SwizzleW = bracket[0].ind_comp;
 717    }
 718    return TRUE;
 719 }
 720
 721 static boolean
 722 parse_optional_swizzle(
 723    struct translate_ctx *ctx,
 724    uint swizzle[4],
 725    boolean *parsed_swizzle )
 726 {
 727    const char *cur = ctx->cur;
 728
 729    *parsed_swizzle = FALSE;
 730
 731    eat_opt_white( &cur );
 732    if (*cur == '.') {
 733       uint i;
 734
 735       cur++;
 736       eat_opt_white( &cur );
 737       for (i = 0; i < 4; i++) {
 738          if (uprcase( *cur ) == 'X')
 739             swizzle[i] = TGSI_SWIZZLE_X;
 740          else if (uprcase( *cur ) == 'Y')
 741             swizzle[i] = TGSI_SWIZZLE_Y;
 742          else if (uprcase( *cur ) == 'Z')
 743             swizzle[i] = TGSI_SWIZZLE_Z;
 744          else if (uprcase( *cur ) == 'W')
 745             swizzle[i] = TGSI_SWIZZLE_W;
 746          else {
 747             report_error( ctx, "Expected register swizzle component `x', `y', `z' or `w'" );
 748             return FALSE;
 749          }
 750          cur++;
 751       }
 752       *parsed_swizzle = TRUE;
 753       ctx->cur = cur;
 754    }
 755    return TRUE;
 756 }
 757
 758 static boolean
 759 parse_src_operand(
 760    struct translate_ctx *ctx,
 761    struct tgsi_full_src_register *src )
 762 {
 763    uint file;
 764    uint swizzle[4];
 765    boolean parsed_swizzle;
 766    struct parsed_bracket bracket[2];
 767    int parsed_opt_brackets;
 768
 769    if (*ctx->cur == '-') {
 770       ctx->cur++;
 771       eat_opt_white( &ctx->cur );
 772       src->Register.Negate = 1;
 773    }
 774
 775    if (*ctx->cur == '|') {
 776       ctx->cur++;
 777       eat_opt_white( &ctx->cur );
 778       src->Register.Absolute = 1;
 779    }
 780
 781    if (!parse_register_src(ctx, &file, &bracket[0]))
 782       return FALSE;
 783    if (!parse_opt_register_src_bracket(ctx, &bracket[1], &parsed_opt_brackets))
 784       return FALSE;
 785
 786    src->Register.File = file;
 787    if (parsed_opt_brackets) {
 788       src->Register.Dimension = 1;
 789       src->Dimension.Indirect = 0;
 790       src->Dimension.Dimension = 0;
 791       src->Dimension.Index = bracket[0].index;
 792       bracket[0] = bracket[1];
 793    }
 794    src->Register.Index = bracket[0].index;
 795    if (bracket[0].ind_file != TGSI_FILE_NULL) {
 796       src->Register.Indirect = 1;
 797       src->Indirect.File = bracket[0].ind_file;
 798       src->Indirect.Index = bracket[0].ind_index;
 799       src->Indirect.SwizzleX = bracket[0].ind_comp;
 800       src->Indirect.SwizzleY = bracket[0].ind_comp;
 801       src->Indirect.SwizzleZ = bracket[0].ind_comp;
 802       src->Indirect.SwizzleW = bracket[0].ind_comp;
 803    }
 804
 805    /* Parse optional swizzle.
 806     */
 807    if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle )) {
 808       if (parsed_swizzle) {
 809          src->Register.SwizzleX = swizzle[0];
 810          src->Register.SwizzleY = swizzle[1];
 811          src->Register.SwizzleZ = swizzle[2];
 812          src->Register.SwizzleW = swizzle[3];
 813       }
 814    }
 815
 816    if (src->Register.Absolute) {
 817       eat_opt_white( &ctx->cur );
 818       if (*ctx->cur != '|') {
 819          report_error( ctx, "Expected `|'" );
 820          return FALSE;
 821       }
 822       ctx->cur++;
 823    }
 824
 825
 826    return TRUE;
 827 }
 828
 829 static boolean
 830 match_inst(const char **pcur,
 831            unsigned *saturate,
 832            const struct tgsi_opcode_info *info)
 833 {
 834    const char *cur = *pcur;
 835
 836    /* simple case: the whole string matches the instruction name */
 837    if (str_match_nocase_whole(&cur, info->mnemonic)) {
 838       *pcur = cur;
 839       *saturate = TGSI_SAT_NONE;
 840       return TRUE;
 841    }
 842
 843    if (str_match_no_case(&cur, info->mnemonic)) {
 844       /* the instruction has a suffix, figure it out */
 845       if (str_match_nocase_whole(&cur, "_SAT")) {
 846          *pcur = cur;
 847          *saturate = TGSI_SAT_ZERO_ONE;
 848          return TRUE;
 849       }
 850
 851       if (str_match_nocase_whole(&cur, "_SATNV")) {
 852          *pcur = cur;
 853          *saturate = TGSI_SAT_MINUS_PLUS_ONE;
 854          return TRUE;
 855       }
 856    }
 857
 858    return FALSE;
 859 }
 860
 861 static boolean
 862 parse_instruction(
 863    struct translate_ctx *ctx,
 864    boolean has_label )
 865 {
 866    uint i;
 867    uint saturate = TGSI_SAT_NONE;
 868    const struct tgsi_opcode_info *info;
 869    struct tgsi_full_instruction inst;
 870    const char *cur;
 871    uint advance;
 872
 873    inst = tgsi_default_full_instruction();
 874
 875    /* Parse predicate.
 876     */
 877    eat_opt_white( &ctx->cur );
 878    if (*ctx->cur == '(') {
 879       uint file;
 880       int index;
 881       uint swizzle[4];
 882       boolean parsed_swizzle;
 883
 884       inst.Instruction.Predicate = 1;
 885
 886       ctx->cur++;
 887       if (*ctx->cur == '!') {
 888          ctx->cur++;
 889          inst.Predicate.Negate = 1;
 890       }
 891
 892       if (!parse_register_1d( ctx, &file, &index ))
 893          return FALSE;
 894
 895       if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle )) {
 896          if (parsed_swizzle) {
 897             inst.Predicate.SwizzleX = swizzle[0];
 898             inst.Predicate.SwizzleY = swizzle[1];
 899             inst.Predicate.SwizzleZ = swizzle[2];
 900             inst.Predicate.SwizzleW = swizzle[3];
 901          }
 902       }
 903
 904       if (*ctx->cur != ')') {
 905          report_error( ctx, "Expected `)'" );
 906          return FALSE;
 907       }
 908
 909       ctx->cur++;
 910    }
 911
 912    /* Parse instruction name.
 913     */
 914    eat_opt_white( &ctx->cur );
 915    for (i = 0; i < TGSI_OPCODE_LAST; i++) {
 916       cur = ctx->cur;
 917
 918       info = tgsi_get_opcode_info( i );
 919       if (match_inst(&cur, &saturate, info)) {
 920          if (info->num_dst + info->num_src + info->is_tex == 0) {
 921             ctx->cur = cur;
 922             break;
 923          }
 924          else if (*cur == '\0' || eat_white( &cur )) {
 925             ctx->cur = cur;
 926             break;
 927          }
 928       }
 929    }
 930    if (i == TGSI_OPCODE_LAST) {
 931       if (has_label)
 932          report_error( ctx, "Unknown opcode" );
 933       else
 934          report_error( ctx, "Expected `DCL', `IMM' or a label" );
 935       return FALSE;
 936    }
 937
 938    inst.Instruction.Opcode = i;
 939    inst.Instruction.Saturate = saturate;
 940    inst.Instruction.NumDstRegs = info->num_dst;
 941    inst.Instruction.NumSrcRegs = info->num_src;
 942
 943    /* Parse instruction operands.
 944     */
 945    for (i = 0; i < info->num_dst + info->num_src + info->is_tex; i++) {
 946       if (i > 0) {
 947          eat_opt_white( &ctx->cur );
 948          if (*ctx->cur != ',') {
 949             report_error( ctx, "Expected `,'" );
 950             return FALSE;
 951          }
 952          ctx->cur++;
 953          eat_opt_white( &ctx->cur );
 954       }
 955
 956       if (i < info->num_dst) {
 957          if (!parse_dst_operand( ctx, &inst.Dst[i] ))
 958             return FALSE;
 959       }
 960       else if (i < info->num_dst + info->num_src) {
 961          if (!parse_src_operand( ctx, &inst.Src[i - info->num_dst] ))
 962             return FALSE;
 963       }
 964       else {
 965          uint j;
 966
 967          for (j = 0; j < TGSI_TEXTURE_COUNT; j++) {
 968             if (str_match_nocase_whole( &ctx->cur, tgsi_texture_names[j] )) {
 969                inst.Instruction.Texture = 1;
 970                inst.Texture.Texture = j;
 971                break;
 972             }
 973          }
 974          if (j == TGSI_TEXTURE_COUNT) {
 975             report_error( ctx, "Expected texture target" );
 976             return FALSE;
 977          }
 978       }
 979    }
 980
 981    cur = ctx->cur;
 982    eat_opt_white( &cur );
 983    if (info->is_branch && *cur == ':') {
 984       uint target;
 985
 986       cur++;
 987       eat_opt_white( &cur );
 988       if (!parse_uint( &cur, &target )) {
 989          report_error( ctx, "Expected a label" );
 990          return FALSE;
 991       }
 992       inst.Instruction.Label = 1;
 993       inst.Label.Label = target;
 994       ctx->cur = cur;
 995    }
 996
 997    advance = tgsi_build_full_instruction(
 998       &inst,
 999       ctx->tokens_cur,
1000       ctx->header,
1001       (uint) (ctx->tokens_end - ctx->tokens_cur) );
1002    if (advance == 0)
1003       return FALSE;
1004    ctx->tokens_cur += advance;
1005
1006    return TRUE;
1007 }
1008
1009 /* parses a 4-touple of the form {x, y, z, w}
1010  * where x, y, z, w are numbers */
1011 static boolean parse_immediate_data(struct translate_ctx *ctx, unsigned type,
1012                                     union tgsi_immediate_data *values)
1013 {
1014    unsigned i;
1015    int ret;
1016
1017    eat_opt_white( &ctx->cur );
1018    if (*ctx->cur != '{') {
1019       report_error( ctx, "Expected `{'" );
1020       return FALSE;
1021    }
1022    ctx->cur++;
1023    for (i = 0; i < 4; i++) {
1024       eat_opt_white( &ctx->cur );
1025       if (i > 0) {
1026          if (*ctx->cur != ',') {
1027             report_error( ctx, "Expected `,'" );
1028             return FALSE;
1029          }
1030          ctx->cur++;
1031          eat_opt_white( &ctx->cur );
1032       }
1033
1034       switch (type) {
1035       case TGSI_IMM_FLOAT32:
1036          ret = parse_float(&ctx->cur, &values[i].Float);
1037          break;
1038       case TGSI_IMM_UINT32:
1039          ret = parse_uint(&ctx->cur, &values[i].Uint);
1040          break;
1041       case TGSI_IMM_INT32:
1042          ret = parse_int(&ctx->cur, &values[i].Int);
1043          break;
1044       default:
1045          assert(0);
1046          ret = FALSE;
1047          break;
1048       }
1049
1050       if (!ret) {
1051          report_error( ctx, "Expected immediate constant" );
1052          return FALSE;
1053       }
1054    }
1055    eat_opt_white( &ctx->cur );
1056    if (*ctx->cur != '}') {
1057       report_error( ctx, "Expected `}'" );
1058       return FALSE;
1059    }
1060    ctx->cur++;
1061
1062    return TRUE;
1063 }
1064
1065 static boolean parse_declaration( struct translate_ctx *ctx )
1066 {
1067    struct tgsi_full_declaration decl;
1068    uint file;
1069    struct parsed_dcl_bracket brackets[2];
1070    int num_brackets;
1071    uint writemask;
1072    const char *cur, *cur2;
1073    uint advance;
1074    boolean is_vs_input;
1075    boolean is_imm_array;
1076
1077    if (!eat_white( &ctx->cur )) {
1078       report_error( ctx, "Syntax error" );
1079       return FALSE;
1080    }
1081    if (!parse_register_dcl( ctx, &file, brackets, &num_brackets))
1082       return FALSE;
1083    if (!parse_opt_writemask( ctx, &writemask ))
1084       return FALSE;
1085
1086    decl = tgsi_default_full_declaration();
1087    decl.Declaration.File = file;
1088    decl.Declaration.UsageMask = writemask;
1089
1090    if (num_brackets == 1) {
1091       decl.Range.First = brackets[0].first;
1092       decl.Range.Last = brackets[0].last;
1093    } else {
1094       decl.Range.First = brackets[1].first;
1095       decl.Range.Last = brackets[1].last;
1096
1097       decl.Declaration.Dimension = 1;
1098       decl.Dim.Index2D = brackets[0].first;
1099    }
1100
1101    is_vs_input = (file == TGSI_FILE_INPUT &&
1102                   ctx->processor == TGSI_PROCESSOR_VERTEX);
1103    is_imm_array = (file == TGSI_FILE_IMMEDIATE_ARRAY);
1104
1105    cur = ctx->cur;
1106    eat_opt_white( &cur );
1107    if (*cur == ',' && !is_vs_input) {
1108       uint i, j;
1109
1110       cur++;
1111       eat_opt_white( &cur );
1112       if (file == TGSI_FILE_RESOURCE) {
1113          for (i = 0; i < TGSI_TEXTURE_COUNT; i++) {
1114             if (str_match_nocase_whole(&cur, tgsi_texture_names[i])) {
1115                decl.Resource.Resource = i;
1116                break;
1117             }
1118          }
1119          if (i == TGSI_TEXTURE_COUNT) {
1120             report_error(ctx, "Expected texture target");
1121             return FALSE;
1122          }
1123
1124          cur2 = cur;
1125          eat_opt_white(&cur2);
1126          while (*cur2 == ',') {
1127             cur2++;
1128             eat_opt_white(&cur2);
1129             if (str_match_nocase_whole(&cur2, "RAW")) {
1130                decl.Resource.Raw = 1;
1131
1132             } else if (str_match_nocase_whole(&cur2, "WR")) {
1133                decl.Resource.Writable = 1;
1134
1135             } else {
1136                break;
1137             }
1138             cur = cur2;
1139             eat_opt_white(&cur2);
1140          }
1141
1142          ctx->cur = cur;
1143
1144       } else if (file == TGSI_FILE_SAMPLER_VIEW) {
1145          for (i = 0; i < TGSI_TEXTURE_COUNT; i++) {
1146             if (str_match_nocase_whole(&cur, tgsi_texture_names[i])) {
1147                decl.SamplerView.Resource = i;
1148                break;
1149             }
1150          }
1151          if (i == TGSI_TEXTURE_COUNT) {
1152             report_error(ctx, "Expected texture target");
1153             return FALSE;
1154          }
1155          eat_opt_white( &cur );
1156          if (*cur != ',') {
1157             report_error( ctx, "Expected `,'" );
1158             return FALSE;
1159          }
1160          ++cur;
1161          eat_opt_white( &cur );
1162          for (j = 0; j < 4; ++j) {
1163             for (i = 0; i < PIPE_TYPE_COUNT; ++i) {
1164                if (str_match_nocase_whole(&cur, tgsi_type_names[i])) {
1165                   switch (j) {
1166                   case 0:
1167                      decl.SamplerView.ReturnTypeX = i;
1168                      break;
1169                   case 1:
1170                      decl.SamplerView.ReturnTypeY = i;
1171                      break;
1172                   case 2:
1173                      decl.SamplerView.ReturnTypeZ = i;
1174                      break;
1175                   case 3:
1176                      decl.SamplerView.ReturnTypeW = i;
1177                      break;
1178                   default:
1179                      assert(0);
1180                   }
1181                   break;
1182                }
1183             }
1184             if (i == PIPE_TYPE_COUNT) {
1185                if (j == 0 || j >  2) {
1186                   report_error(ctx, "Expected type name");
1187                   return FALSE;
1188                }
1189                break;
1190             } else {
1191                cur2 = cur;
1192                eat_opt_white( &cur2 );
1193                if (*cur2 == ',') {
1194                   cur2++;
1195                   eat_opt_white( &cur2 );
1196                   cur = cur2;
1197                   continue;
1198                } else
1199                   break;
1200             }
1201          }
1202          if (j < 4) {
1203             decl.SamplerView.ReturnTypeY =
1204                decl.SamplerView.ReturnTypeZ =
1205                decl.SamplerView.ReturnTypeW =
1206                decl.SamplerView.ReturnTypeX;
1207          }
1208          ctx->cur = cur;
1209       } else {
1210          if (str_match_nocase_whole(&cur, "LOCAL")) {
1211             decl.Declaration.Local = 1;
1212             ctx->cur = cur;
1213          }
1214
1215          cur = ctx->cur;
1216          eat_opt_white( &cur );
1217          if (*cur == ',') {
1218             cur++;
1219             eat_opt_white( &cur );
1220
1221             for (i = 0; i < TGSI_SEMANTIC_COUNT; i++) {
1222                if (str_match_nocase_whole(&cur, tgsi_semantic_names[i])) {
1223                   uint index;
1224
1225                   cur2 = cur;
1226                   eat_opt_white( &cur2 );
1227                   if (*cur2 == '[') {
1228                      cur2++;
1229                      eat_opt_white( &cur2 );
1230                      if (!parse_uint( &cur2, &index )) {
1231                         report_error( ctx, "Expected literal integer" );
1232                         return FALSE;
1233                      }
1234                      eat_opt_white( &cur2 );
1235                      if (*cur2 != ']') {
1236                         report_error( ctx, "Expected `]'" );
1237                         return FALSE;
1238                      }
1239                      cur2++;
1240
1241                      decl.Semantic.Index = index;
1242
1243                      cur = cur2;
1244                   }
1245
1246                   decl.Declaration.Semantic = 1;
1247                   decl.Semantic.Name = i;
1248
1249                   ctx->cur = cur;
1250                   break;
1251                }
1252             }
1253          }
1254       }
1255    } else if (is_imm_array) {
1256       unsigned i;
1257       union tgsi_immediate_data *vals_itr;
1258       /* we have our immediate data */
1259       if (*cur != '{') {
1260          report_error( ctx, "Immediate array without data" );
1261          return FALSE;
1262       }
1263       ++cur;
1264       ctx->cur = cur;
1265
1266       decl.ImmediateData.u =
1267          MALLOC(sizeof(union tgsi_immediate_data) * 4 *
1268                 (decl.Range.Last + 1));
1269       vals_itr = decl.ImmediateData.u;
1270       for (i = 0; i <= decl.Range.Last; ++i) {
1271          if (!parse_immediate_data(ctx, TGSI_IMM_FLOAT32, vals_itr)) {
1272             FREE(decl.ImmediateData.u);
1273             return FALSE;
1274          }
1275          vals_itr += 4;
1276          eat_opt_white( &ctx->cur );
1277          if (*ctx->cur != ',') {
1278             if (i !=  decl.Range.Last) {
1279                report_error( ctx, "Not enough data in immediate array!" );
1280                FREE(decl.ImmediateData.u);
1281                return FALSE;
1282             }
1283          } else
1284             ++ctx->cur;
1285       }
1286       eat_opt_white( &ctx->cur );
1287       if (*ctx->cur != '}') {
1288          FREE(decl.ImmediateData.u);
1289          report_error( ctx, "Immediate array data missing closing '}'" );
1290          return FALSE;
1291       }
1292       ++ctx->cur;
1293    }
1294
1295    cur = ctx->cur;
1296    eat_opt_white( &cur );
1297    if (*cur == ',' && !is_vs_input) {
1298       uint i;
1299
1300       cur++;
1301       eat_opt_white( &cur );
1302       for (i = 0; i < TGSI_INTERPOLATE_COUNT; i++) {
1303          if (str_match_nocase_whole( &cur, tgsi_interpolate_names[i] )) {
1304             decl.Declaration.Interpolate = 1;
1305             decl.Interp.Interpolate = i;
1306
1307             ctx->cur = cur;
1308             break;
1309          }
1310       }
1311       if (i == TGSI_INTERPOLATE_COUNT) {
1312          report_error( ctx, "Expected semantic or interpolate attribute" );
1313          return FALSE;
1314       }
1315    }
1316
1317    advance = tgsi_build_full_declaration(
1318       &decl,
1319       ctx->tokens_cur,
1320       ctx->header,
1321       (uint) (ctx->tokens_end - ctx->tokens_cur) );
1322
1323    if (is_imm_array)
1324       FREE(decl.ImmediateData.u);
1325
1326    if (advance == 0)
1327       return FALSE;
1328    ctx->tokens_cur += advance;
1329
1330    return TRUE;
1331 }
1332
1333 static boolean parse_immediate( struct translate_ctx *ctx )
1334 {
1335    struct tgsi_full_immediate imm;
1336    uint advance;
1337    int type;
1338
1339    if (!eat_white( &ctx->cur )) {
1340       report_error( ctx, "Syntax error" );
1341       return FALSE;
1342    }
1343    for (type = 0; type < Elements(tgsi_immediate_type_names); ++type) {
1344       if (str_match_nocase_whole(&ctx->cur, tgsi_immediate_type_names[type]))
1345          break;
1346    }
1347    if (type == Elements(tgsi_immediate_type_names)) {
1348       report_error( ctx, "Expected immediate type" );
1349       return FALSE;
1350    }
1351
1352    imm = tgsi_default_full_immediate();
1353    imm.Immediate.NrTokens += 4;
1354    imm.Immediate.DataType = type;
1355    parse_immediate_data(ctx, type, imm.u);
1356
1357    advance = tgsi_build_full_immediate(
1358       &imm,
1359       ctx->tokens_cur,
1360       ctx->header,
1361       (uint) (ctx->tokens_end - ctx->tokens_cur) );
1362    if (advance == 0)
1363       return FALSE;
1364    ctx->tokens_cur += advance;
1365
1366    return TRUE;
1367 }
1368
1369 static boolean
1370 parse_primitive( const char **pcur, uint *primitive )
1371 {
1372    uint i;
1373
1374    for (i = 0; i < PIPE_PRIM_MAX; i++) {
1375       const char *cur = *pcur;
1376
1377       if (str_match_nocase_whole( &cur, tgsi_primitive_names[i])) {
1378          *primitive = i;
1379          *pcur = cur;
1380          return TRUE;
1381       }
1382    }
1383    return FALSE;
1384 }
1385
1386 static boolean
1387 parse_fs_coord_origin( const char **pcur, uint *fs_coord_origin )
1388 {
1389    uint i;
1390
1391    for (i = 0; i < Elements(tgsi_fs_coord_origin_names); i++) {
1392       const char *cur = *pcur;
1393
1394       if (str_match_nocase_whole( &cur, tgsi_fs_coord_origin_names[i])) {
1395          *fs_coord_origin = i;
1396          *pcur = cur;
1397          return TRUE;
1398       }
1399    }
1400    return FALSE;
1401 }
1402
1403 static boolean
1404 parse_fs_coord_pixel_center( const char **pcur, uint *fs_coord_pixel_center )
1405 {
1406    uint i;
1407
1408    for (i = 0; i < Elements(tgsi_fs_coord_pixel_center_names); i++) {
1409       const char *cur = *pcur;
1410
1411       if (str_match_nocase_whole( &cur, tgsi_fs_coord_pixel_center_names[i])) {
1412          *fs_coord_pixel_center = i;
1413          *pcur = cur;
1414          return TRUE;
1415       }
1416    }
1417    return FALSE;
1418 }
1419
1420
1421 static boolean parse_property( struct translate_ctx *ctx )
1422 {
1423    struct tgsi_full_property prop;
1424    uint property_name;
1425    uint values[8];
1426    uint advance;
1427    char id[64];
1428
1429    if (!eat_white( &ctx->cur )) {
1430       report_error( ctx, "Syntax error" );
1431       return FALSE;
1432    }
1433    if (!parse_identifier( &ctx->cur, id )) {
1434       report_error( ctx, "Syntax error" );
1435       return FALSE;
1436    }
1437    for (property_name = 0; property_name < TGSI_PROPERTY_COUNT;
1438         ++property_name) {
1439       if (streq_nocase_uprcase(tgsi_property_names[property_name], id)) {
1440          break;
1441       }
1442    }
1443    if (property_name >= TGSI_PROPERTY_COUNT) {
1444       debug_printf( "\nError: Unknown property : '%s'", id );
1445       return FALSE;
1446    }
1447
1448    eat_opt_white( &ctx->cur );
1449    switch(property_name) {
1450    case TGSI_PROPERTY_GS_INPUT_PRIM:
1451    case TGSI_PROPERTY_GS_OUTPUT_PRIM:
1452       if (!parse_primitive(&ctx->cur, &values[0] )) {
1453          report_error( ctx, "Unknown primitive name as property!" );
1454          return FALSE;
1455       }
1456       if (property_name == TGSI_PROPERTY_GS_INPUT_PRIM &&
1457           ctx->processor == TGSI_PROCESSOR_GEOMETRY) {
1458          ctx->implied_array_size = u_vertices_per_prim(values[0]);
1459       }
1460       break;
1461    case TGSI_PROPERTY_FS_COORD_ORIGIN:
1462       if (!parse_fs_coord_origin(&ctx->cur, &values[0] )) {
1463          report_error( ctx, "Unknown coord origin as property: must be UPPER_LEFT or LOWER_LEFT!" );
1464          return FALSE;
1465       }
1466       break;
1467    case TGSI_PROPERTY_FS_COORD_PIXEL_CENTER:
1468       if (!parse_fs_coord_pixel_center(&ctx->cur, &values[0] )) {
1469          report_error( ctx, "Unknown coord pixel center as property: must be HALF_INTEGER or INTEGER!" );
1470          return FALSE;
1471       }
1472       break;
1473    case TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS:
1474    default:
1475       if (!parse_uint(&ctx->cur, &values[0] )) {
1476          report_error( ctx, "Expected unsigned integer as property!" );
1477          return FALSE;
1478       }
1479    }
1480
1481    prop = tgsi_default_full_property();
1482    prop.Property.PropertyName = property_name;
1483    prop.Property.NrTokens += 1;
1484    prop.u[0].Data = values[0];
1485
1486    advance = tgsi_build_full_property(
1487       &prop,
1488       ctx->tokens_cur,
1489       ctx->header,
1490       (uint) (ctx->tokens_end - ctx->tokens_cur) );
1491    if (advance == 0)
1492       return FALSE;
1493    ctx->tokens_cur += advance;
1494
1495    return TRUE;
1496 }
1497
1498
1499 static boolean translate( struct translate_ctx *ctx )
1500 {
1501    eat_opt_white( &ctx->cur );
1502    if (!parse_header( ctx ))
1503       return FALSE;
1504
1505    while (*ctx->cur != '\0') {
1506       uint label_val = 0;
1507       if (!eat_white( &ctx->cur )) {
1508          report_error( ctx, "Syntax error" );
1509          return FALSE;
1510       }
1511
1512       if (*ctx->cur == '\0')
1513          break;
1514       if (parse_label( ctx, &label_val )) {
1515          if (!parse_instruction( ctx, TRUE ))
1516             return FALSE;
1517       }
1518       else if (str_match_nocase_whole( &ctx->cur, "DCL" )) {
1519          if (!parse_declaration( ctx ))
1520             return FALSE;
1521       }
1522       else if (str_match_nocase_whole( &ctx->cur, "IMM" )) {
1523          if (!parse_immediate( ctx ))
1524             return FALSE;
1525       }
1526       else if (str_match_nocase_whole( &ctx->cur, "PROPERTY" )) {
1527          if (!parse_property( ctx ))
1528             return FALSE;
1529       }
1530       else if (!parse_instruction( ctx, FALSE )) {
1531          return FALSE;
1532       }
1533    }
1534
1535    return TRUE;
1536 }
1537
1538 boolean
1539 tgsi_text_translate(
1540    const char *text,
1541    struct tgsi_token *tokens,
1542    uint num_tokens )
1543 {
1544    struct translate_ctx ctx;
1545
1546    ctx.text = text;
1547    ctx.cur = text;
1548    ctx.tokens = tokens;
1549    ctx.tokens_cur = tokens;
1550    ctx.tokens_end = tokens + num_tokens;
1551
1552    if (!translate( &ctx ))
1553       return FALSE;
1554
1555    return tgsi_sanity_check( tokens );
1556 }