src/mesa/shader/slang/slang_print.c

   1
   2 /**
   3  * Dump/print a slang_operation tree
   4  */
   5
   6
   7 #include "imports.h"
   8 #include "slang_compile.h"
   9 #include "slang_print.h"
  10
  11
  12 static void
  13 spaces(int n)
  14 {
  15    while (n--)
  16       printf(" ");
  17 }
  18
  19
  20 static void
  21 print_type(const slang_fully_specified_type *t)
  22 {
  23    switch (t->qualifier) {
  24    case slang_qual_none:
  25       /*printf("");*/
  26       break;
  27    case slang_qual_const:
  28       printf("const ");
  29       break;
  30    case slang_qual_attribute:
  31       printf("attrib ");
  32       break;
  33    case slang_qual_varying:
  34       printf("varying ");
  35       break;
  36    case slang_qual_uniform:
  37       printf("uniform ");
  38       break;
  39    case slang_qual_out:
  40       printf("output ");
  41       break;
  42    case slang_qual_inout:
  43       printf("inout ");
  44       break;
  45    case slang_qual_fixedoutput:
  46       printf("fixedoutput");
  47       break;
  48    case slang_qual_fixedinput:
  49       printf("fixedinput");
  50       break;
  51    default:
  52       printf("unknown qualifer!");
  53    }
  54
  55    switch (t->specifier.type) {
  56    case slang_spec_void:
  57       printf("void");
  58       break;
  59    case slang_spec_bool:
  60       printf("bool");
  61       break;
  62    case slang_spec_bvec2:
  63       printf("bvec2");
  64       break;
  65    case slang_spec_bvec3:
  66       printf("bvec3");
  67       break;
  68    case slang_spec_bvec4:
  69       printf("bvec4");
  70       break;
  71    case slang_spec_int:
  72       printf("int");
  73       break;
  74    case slang_spec_ivec2:
  75       printf("ivec2");
  76       break;
  77    case slang_spec_ivec3:
  78       printf("ivec3");
  79       break;
  80    case slang_spec_ivec4:
  81       printf("ivec4");
  82       break;
  83    case slang_spec_float:
  84       printf("float");
  85       break;
  86    case slang_spec_vec2:
  87       printf("vec2");
  88       break;
  89    case slang_spec_vec3:
  90       printf("vec3");
  91       break;
  92    case slang_spec_vec4:
  93       printf("vec4");
  94       break;
  95    case slang_spec_mat2:
  96       printf("mat2");
  97       break;
  98    case slang_spec_mat3:
  99       printf("mat3");
 100       break;
 101    case slang_spec_mat4:
 102       printf("mat4");
 103       break;
 104    case slang_spec_sampler1D:
 105       printf("sampler1D");
 106       break;
 107    case slang_spec_sampler2D:
 108       printf("sampler2D");
 109       break;
 110    case slang_spec_sampler3D:
 111       printf("sampler3D");
 112       break;
 113    case slang_spec_samplerCube:
 114       printf("samplerCube");
 115       break;
 116    case slang_spec_sampler1DShadow:
 117       printf("sampler1DShadow");
 118       break;
 119    case slang_spec_sampler2DShadow:
 120       printf("sampler2DShadow");
 121       break;
 122    case slang_spec_struct:
 123       printf("struct");
 124       break;
 125    case slang_spec_array:
 126       printf("array");
 127       break;
 128    default:
 129       printf("unknown type");
 130    }
 131    /*printf("\n");*/
 132 }
 133
 134
 135 static void
 136 print_variable(const slang_variable *v, int indent)
 137 {
 138    spaces(indent);
 139    printf("VAR ");
 140    print_type(&v->type);
 141    printf(" %s", (char *) v->a_name);
 142    if (v->initializer) {
 143       printf(" :=\n");
 144       slang_print_tree(v->initializer, indent + 3);
 145    }
 146    else {
 147       printf(";\n");
 148    }
 149 }
 150
 151
 152 static void
 153 print_binary(const slang_operation *op, const char *oper, int indent)
 154 {
 155    assert(op->num_children == 2);
 156    slang_print_tree(&op->children[0], indent + 3);
 157    spaces(indent);
 158    printf("%s\n", oper);
 159    slang_print_tree(&op->children[1], indent + 3);
 160 }
 161
 162
 163 static void
 164 print_generic2(const slang_operation *op, const char *oper,
 165                const char *s, int indent)
 166 {
 167    int i;
 168    if (oper) {
 169       spaces(indent);
 170       printf("[%p locals %p] %s %s\n", (void*) op, (void*) op->locals, oper, s);
 171    }
 172    for (i = 0; i < op->num_children; i++) {
 173       spaces(indent);
 174       printf("//child %d:\n", i);
 175       slang_print_tree(&op->children[i], indent);
 176    }
 177 }
 178
 179 static void
 180 print_generic(const slang_operation *op, const char *oper, int indent)
 181 {
 182    print_generic2(op, oper, "", indent);
 183 }
 184
 185
 186 static const slang_variable_scope *
 187 find_scope(const slang_variable_scope *s, slang_atom name)
 188 {
 189    GLuint i;
 190    for (i = 0; i < s->num_variables; i++) {
 191       if (s->variables[i].a_name == name)
 192          return s;
 193    }
 194    if (s->outer_scope)
 195       return find_scope(s->outer_scope, name);
 196    else
 197       return NULL;
 198 }
 199
 200 static const slang_variable *
 201 find_var(const slang_variable_scope *s, slang_atom name)
 202 {
 203    GLuint i;
 204    for (i = 0; i < s->num_variables; i++) {
 205       if (s->variables[i].a_name == name)
 206          return &s->variables[i];
 207    }
 208    if (s->outer_scope)
 209       return find_var(s->outer_scope, name);
 210    else
 211       return NULL;
 212 }
 213
 214
 215 void
 216 slang_print_tree(const slang_operation *op, int indent)
 217 {
 218    int i;
 219
 220    switch (op->type) {
 221
 222    case slang_oper_none:
 223       spaces(indent);
 224       printf("slang_oper_none\n");
 225       break;
 226
 227    case slang_oper_block_no_new_scope:
 228       spaces(indent);
 229       printf("{ locals %p\n", (void*)op->locals);
 230       print_generic(op, NULL, indent+3);
 231       spaces(indent);
 232       printf("}\n");
 233       break;
 234
 235    case slang_oper_block_new_scope:
 236       spaces(indent);
 237       printf("{{ // new scope  locals %p\n", (void*)op->locals);
 238       print_generic(op, NULL, indent+3);
 239       spaces(indent);
 240       printf("}}\n");
 241       break;
 242
 243    case slang_oper_variable_decl:
 244       assert(op->num_children == 0 || op->num_children == 1);
 245       {
 246          slang_variable *v;
 247          v = _slang_locate_variable(op->locals, op->a_id, GL_TRUE);
 248          if (v) {
 249             spaces(indent);
 250             printf("DECL (locals=%p outer=%p) ", (void*)op->locals, (void*) op->locals->outer_scope);
 251             print_type(&v->type);
 252             printf(" %s (%p)", (char *) op->a_id,
 253                    (void *) find_var(op->locals, op->a_id));
 254
 255             printf(" (in scope %p) ",
 256                    (void *) find_scope(op->locals, op->a_id));
 257             if (op->num_children == 1) {
 258                printf(" :=\n");
 259                slang_print_tree(&op->children[0], indent + 3);
 260             }
 261             else if (v->initializer) {
 262                printf(" := INITIALIZER\n");
 263                slang_print_tree(v->initializer, indent + 3);
 264             }
 265             else {
 266                printf(";\n");
 267             }
 268             /*
 269             spaces(indent);
 270             printf("TYPE: ");
 271             print_type(&v->type);
 272             spaces(indent);
 273             printf("ADDR: %d  size: %d\n", v->address, v->size);
 274             */
 275          }
 276          else {
 277             abort();
 278             spaces(indent);
 279             printf("DECL %s (anonymous variable!!!!)\n", (char *) op->a_id);
 280             /*abort();*/
 281          }
 282       }
 283       break;
 284
 285    case slang_oper_asm:
 286       spaces(indent);
 287       printf("ASM: %s\n", (char*) op->a_id);
 288       print_generic(op, NULL, indent+3);
 289       break;
 290
 291    case slang_oper_break:
 292       spaces(indent);
 293       printf("BREAK\n");
 294       break;
 295
 296    case slang_oper_continue:
 297       spaces(indent);
 298       printf("CONTINUE\n");
 299       break;
 300
 301    case slang_oper_discard:
 302       spaces(indent);
 303       printf("DISCARD\n");
 304       break;
 305
 306    case slang_oper_return:
 307       spaces(indent);
 308       printf("RETURN\n");
 309       if (op->num_children > 0)
 310          slang_print_tree(&op->children[0], indent + 3);
 311       break;
 312
 313    case slang_oper_goto:
 314       spaces(indent);
 315       printf("GOTO %s\n", (char *) op->a_id);
 316       break;
 317
 318    case slang_oper_label:
 319       spaces(indent);
 320       printf("LABEL %s\n", (char *) op->a_id);
 321       break;
 322
 323    case slang_oper_expression:
 324       spaces(indent);
 325       printf("EXPR:  locals %p\n", (void*) op->locals);
 326       /*print_generic(op, "slang_oper_expression", indent);*/
 327       slang_print_tree(&op->children[0], indent + 3);
 328       break;
 329
 330    case slang_oper_if:
 331       spaces(indent);
 332       printf("IF\n");
 333       slang_print_tree(&op->children[0], indent + 3);
 334       spaces(indent);
 335       printf("THEN\n");
 336       slang_print_tree(&op->children[1], indent + 3);
 337       spaces(indent);
 338       printf("ELSE\n");
 339       slang_print_tree(&op->children[2], indent + 3);
 340       spaces(indent);
 341       printf("ENDIF\n");
 342       break;
 343
 344    case slang_oper_while:
 345       assert(op->num_children == 2);
 346       spaces(indent);
 347       printf("WHILE cond:\n");
 348       slang_print_tree(&op->children[0], indent + 3);
 349       spaces(indent);
 350       printf("WHILE body:\n");
 351       slang_print_tree(&op->children[1], indent + 3);
 352       break;
 353
 354    case slang_oper_do:
 355       spaces(indent);
 356       printf("DO body:\n");
 357       slang_print_tree(&op->children[0], indent + 3);
 358       spaces(indent);
 359       printf("DO cond:\n");
 360       slang_print_tree(&op->children[1], indent + 3);
 361       break;
 362
 363    case slang_oper_for:
 364       spaces(indent);
 365       printf("FOR init:\n");
 366       slang_print_tree(&op->children[0], indent + 3);
 367       spaces(indent);
 368       printf("FOR while:\n");
 369       slang_print_tree(&op->children[1], indent + 3);
 370       spaces(indent);
 371       printf("FOR step:\n");
 372       slang_print_tree(&op->children[2], indent + 3);
 373       spaces(indent);
 374       printf("FOR body:\n");
 375       slang_print_tree(&op->children[3], indent + 3);
 376       spaces(indent);
 377       printf("ENDFOR\n");
 378       /*
 379       print_generic(op, "FOR", indent + 3);
 380       */
 381       break;
 382
 383    case slang_oper_void:
 384       spaces(indent);
 385       printf("(oper-void)\n");
 386       break;
 387
 388    case slang_oper_literal_bool:
 389       spaces(indent);
 390       /*printf("slang_oper_literal_bool\n");*/
 391       printf("%s\n", op->literal[0] ? "TRUE" : "FALSE");
 392       break;
 393
 394    case slang_oper_literal_int:
 395       spaces(indent);
 396       /*printf("slang_oper_literal_int\n");*/
 397       printf("(%d %d %d %d)\n", (int) op->literal[0], (int) op->literal[1],
 398              (int) op->literal[2], (int) op->literal[3]);
 399       break;
 400
 401    case slang_oper_literal_float:
 402       spaces(indent);
 403       /*printf("slang_oper_literal_float\n");*/
 404       printf("(%f %f %f %f)\n", op->literal[0], op->literal[1], op->literal[2],
 405              op->literal[3]);
 406       break;
 407
 408    case slang_oper_identifier:
 409       spaces(indent);
 410       if (op->var && op->var->a_name)
 411          printf("VAR %s  (in scope %p)\n", (char *) op->var->a_name,
 412                 (void *) find_scope(op->locals, op->a_id));
 413       else
 414          printf("VAR' %s  (in scope %p)\n", (char *) op->a_id,
 415                 (void *) find_scope(op->locals, op->a_id));
 416       break;
 417
 418    case slang_oper_sequence:
 419       print_generic(op, "COMMA-SEQ", indent+3);
 420       break;
 421
 422    case slang_oper_assign:
 423       spaces(indent);
 424       printf("ASSIGNMENT  locals %p\n", (void*)op->locals);
 425       print_binary(op, ":=", indent);
 426       break;
 427
 428    case slang_oper_addassign:
 429       spaces(indent);
 430       printf("ASSIGN\n");
 431       print_binary(op, "+=", indent);
 432       break;
 433
 434    case slang_oper_subassign:
 435       spaces(indent);
 436       printf("ASSIGN\n");
 437       print_binary(op, "-=", indent);
 438       break;
 439
 440    case slang_oper_mulassign:
 441       spaces(indent);
 442       printf("ASSIGN\n");
 443       print_binary(op, "*=", indent);
 444       break;
 445
 446    case slang_oper_divassign:
 447       spaces(indent);
 448       printf("ASSIGN\n");
 449       print_binary(op, "/=", indent);
 450       break;
 451
 452         /*slang_oper_modassign,*/
 453         /*slang_oper_lshassign,*/
 454         /*slang_oper_rshassign,*/
 455         /*slang_oper_orassign,*/
 456         /*slang_oper_xorassign,*/
 457         /*slang_oper_andassign,*/
 458    case slang_oper_select:
 459       spaces(indent);
 460       printf("slang_oper_select n=%d\n", op->num_children);
 461       assert(op->num_children == 3);
 462       slang_print_tree(&op->children[0], indent+3);
 463       spaces(indent);
 464       printf("?\n");
 465       slang_print_tree(&op->children[1], indent+3);
 466       spaces(indent);
 467       printf(":\n");
 468       slang_print_tree(&op->children[2], indent+3);
 469       break;
 470
 471    case slang_oper_logicalor:
 472       print_binary(op, "||", indent);
 473       break;
 474
 475    case slang_oper_logicalxor:
 476       print_binary(op, "^^", indent);
 477       break;
 478
 479    case slang_oper_logicaland:
 480       print_binary(op, "&&", indent);
 481       break;
 482
 483    /*slang_oper_bitor*/
 484    /*slang_oper_bitxor*/
 485    /*slang_oper_bitand*/
 486    case slang_oper_equal:
 487       print_binary(op, "==", indent);
 488       break;
 489
 490    case slang_oper_notequal:
 491       print_binary(op, "!=", indent);
 492       break;
 493
 494    case slang_oper_less:
 495       print_binary(op, "<", indent);
 496       break;
 497
 498    case slang_oper_greater:
 499       print_binary(op, ">", indent);
 500       break;
 501
 502    case slang_oper_lessequal:
 503       print_binary(op, "<=", indent);
 504       break;
 505
 506    case slang_oper_greaterequal:
 507       print_binary(op, ">=", indent);
 508       break;
 509
 510    /*slang_oper_lshift*/
 511    /*slang_oper_rshift*/
 512    case slang_oper_add:
 513       print_binary(op, "+", indent);
 514       break;
 515
 516    case slang_oper_subtract:
 517       print_binary(op, "-", indent);
 518       break;
 519
 520    case slang_oper_multiply:
 521       print_binary(op, "*", indent);
 522       break;
 523
 524    case slang_oper_divide:
 525       print_binary(op, "/", indent);
 526       break;
 527
 528    /*slang_oper_modulus*/
 529    case slang_oper_preincrement:
 530       spaces(indent);
 531       printf("PRE++\n");
 532       slang_print_tree(&op->children[0], indent+3);
 533       break;
 534
 535    case slang_oper_predecrement:
 536       spaces(indent);
 537       printf("PRE--\n");
 538       slang_print_tree(&op->children[0], indent+3);
 539       break;
 540
 541    case slang_oper_plus:
 542       spaces(indent);
 543       printf("slang_oper_plus\n");
 544       break;
 545
 546    case slang_oper_minus:
 547       spaces(indent);
 548       printf("slang_oper_minus\n");
 549       break;
 550
 551    /*slang_oper_complement*/
 552    case slang_oper_not:
 553       spaces(indent);
 554       printf("NOT\n");
 555       slang_print_tree(&op->children[0], indent+3);
 556       break;
 557
 558    case slang_oper_subscript:
 559       spaces(indent);
 560       printf("slang_oper_subscript\n");
 561       print_generic(op, NULL, indent+3);
 562       break;
 563
 564    case slang_oper_call:
 565 #if 0
 566          slang_function *fun
 567             = _slang_locate_function(A->space.funcs, oper->a_id,
 568                                      oper->children,
 569                                      oper->num_children, &A->space, A->atoms);
 570 #endif
 571       spaces(indent);
 572       printf("CALL %s(\n", (char *) op->a_id);
 573       for (i = 0; i < op->num_children; i++) {
 574          slang_print_tree(&op->children[i], indent+3);
 575          if (i + 1 < op->num_children) {
 576             spaces(indent + 3);
 577             printf(",\n");
 578          }
 579       }
 580       spaces(indent);
 581       printf(")\n");
 582       break;
 583
 584    case slang_oper_field:
 585       spaces(indent);
 586       printf("FIELD %s of\n", (char*) op->a_id);
 587       slang_print_tree(&op->children[0], indent+3);
 588       break;
 589
 590    case slang_oper_postincrement:
 591       spaces(indent);
 592       printf("POST++\n");
 593       slang_print_tree(&op->children[0], indent+3);
 594       break;
 595
 596    case slang_oper_postdecrement:
 597       spaces(indent);
 598       printf("POST--\n");
 599       slang_print_tree(&op->children[0], indent+3);
 600       break;
 601
 602    default:
 603       printf("unknown op->type %d\n", (int) op->type);
 604    }
 605
 606 }
 607
 608
 609
 610 void
 611 slang_print_function(const slang_function *f, GLboolean body)
 612 {
 613    int i;
 614
 615 #if 0
 616    if (_mesa_strcmp((char *) f->header.a_name, "main") != 0)
 617      return;
 618 #endif
 619
 620    printf("FUNCTION %s (\n",
 621           (char *) f->header.a_name);
 622
 623    for (i = 0; i < f->param_count; i++) {
 624       print_variable(&f->parameters->variables[i], 3);
 625    }
 626
 627    printf(")\n");
 628    if (body && f->body)
 629       slang_print_tree(f->body, 0);
 630 }
 631
 632
 633
 634
 635 /* operation */
 636 #define OP_END 0
 637 #define OP_BLOCK_BEGIN_NO_NEW_SCOPE 1
 638 #define OP_BLOCK_BEGIN_NEW_SCOPE 2
 639 #define OP_DECLARE 3
 640 #define OP_ASM 4
 641 #define OP_BREAK 5
 642 #define OP_CONTINUE 6
 643 #define OP_DISCARD 7
 644 #define OP_RETURN 8
 645 #define OP_EXPRESSION 9
 646 #define OP_IF 10
 647 #define OP_WHILE 11
 648 #define OP_DO 12
 649 #define OP_FOR 13
 650 #define OP_PUSH_VOID 14
 651 #define OP_PUSH_BOOL 15
 652 #define OP_PUSH_INT 16
 653 #define OP_PUSH_FLOAT 17
 654 #define OP_PUSH_IDENTIFIER 18
 655 #define OP_SEQUENCE 19
 656 #define OP_ASSIGN 20
 657 #define OP_ADDASSIGN 21
 658 #define OP_SUBASSIGN 22
 659 #define OP_MULASSIGN 23
 660 #define OP_DIVASSIGN 24
 661 /*#define OP_MODASSIGN 25*/
 662 /*#define OP_LSHASSIGN 26*/
 663 /*#define OP_RSHASSIGN 27*/
 664 /*#define OP_ORASSIGN 28*/
 665 /*#define OP_XORASSIGN 29*/
 666 /*#define OP_ANDASSIGN 30*/
 667 #define OP_SELECT 31
 668 #define OP_LOGICALOR 32
 669 #define OP_LOGICALXOR 33
 670 #define OP_LOGICALAND 34
 671 /*#define OP_BITOR 35*/
 672 /*#define OP_BITXOR 36*/
 673 /*#define OP_BITAND 37*/
 674 #define OP_EQUAL 38
 675 #define OP_NOTEQUAL 39
 676 #define OP_LESS 40
 677 #define OP_GREATER 41
 678 #define OP_LESSEQUAL 42
 679 #define OP_GREATEREQUAL 43
 680 /*#define OP_LSHIFT 44*/
 681 /*#define OP_RSHIFT 45*/
 682 #define OP_ADD 46
 683 #define OP_SUBTRACT 47
 684 #define OP_MULTIPLY 48
 685 #define OP_DIVIDE 49
 686 /*#define OP_MODULUS 50*/
 687 #define OP_PREINCREMENT 51
 688 #define OP_PREDECREMENT 52
 689 #define OP_PLUS 53
 690 #define OP_MINUS 54
 691 /*#define OP_COMPLEMENT 55*/
 692 #define OP_NOT 56
 693 #define OP_SUBSCRIPT 57
 694 #define OP_CALL 58
 695 #define OP_FIELD 59
 696 #define OP_POSTINCREMENT 60
 697 #define OP_POSTDECREMENT 61
 698
 699
 700 void
 701 slang_print_opcode(unsigned int opcode)
 702 {
 703    switch (opcode) {
 704    case OP_PUSH_VOID:
 705       printf("OP_PUSH_VOID\n");
 706       break;
 707    case OP_PUSH_BOOL:
 708       printf("OP_PUSH_BOOL\n");
 709       break;
 710    case OP_PUSH_INT:
 711       printf("OP_PUSH_INT\n");
 712       break;
 713    case OP_PUSH_FLOAT:
 714       printf("OP_PUSH_FLOAT\n");
 715       break;
 716    case OP_PUSH_IDENTIFIER:
 717       printf("OP_PUSH_IDENTIFIER\n");
 718       break;
 719    case OP_SEQUENCE:
 720       printf("OP_SEQUENCE\n");
 721       break;
 722    case OP_ASSIGN:
 723       printf("OP_ASSIGN\n");
 724       break;
 725    case OP_ADDASSIGN:
 726       printf("OP_ADDASSIGN\n");
 727       break;
 728    case OP_SUBASSIGN:
 729       printf("OP_SUBASSIGN\n");
 730       break;
 731    case OP_MULASSIGN:
 732       printf("OP_MULASSIGN\n");
 733       break;
 734    case OP_DIVASSIGN:
 735       printf("OP_DIVASSIGN\n");
 736       break;
 737    /*case OP_MODASSIGN:*/
 738    /*case OP_LSHASSIGN:*/
 739    /*case OP_RSHASSIGN:*/
 740    /*case OP_ORASSIGN:*/
 741    /*case OP_XORASSIGN:*/
 742    /*case OP_ANDASSIGN:*/
 743    case OP_SELECT:
 744       printf("OP_SELECT\n");
 745       break;
 746    case OP_LOGICALOR:
 747       printf("OP_LOGICALOR\n");
 748       break;
 749    case OP_LOGICALXOR:
 750       printf("OP_LOGICALXOR\n");
 751       break;
 752    case OP_LOGICALAND:
 753       printf("OP_LOGICALAND\n");
 754       break;
 755    /*case OP_BITOR:*/
 756    /*case OP_BITXOR:*/
 757    /*case OP_BITAND:*/
 758    case OP_EQUAL:
 759       printf("OP_EQUAL\n");
 760       break;
 761    case OP_NOTEQUAL:
 762       printf("OP_NOTEQUAL\n");
 763       break;
 764    case OP_LESS:
 765       printf("OP_LESS\n");
 766       break;
 767    case OP_GREATER:
 768       printf("OP_GREATER\n");
 769       break;
 770    case OP_LESSEQUAL:
 771       printf("OP_LESSEQUAL\n");
 772       break;
 773    case OP_GREATEREQUAL:
 774       printf("OP_GREATEREQUAL\n");
 775       break;
 776    /*case OP_LSHIFT:*/
 777    /*case OP_RSHIFT:*/
 778    case OP_ADD:
 779       printf("OP_ADD\n");
 780       break;
 781    case OP_SUBTRACT:
 782       printf("OP_SUBTRACT\n");
 783       break;
 784    case OP_MULTIPLY:
 785       printf("OP_MULTIPLY\n");
 786       break;
 787    case OP_DIVIDE:
 788       printf("OP_DIVIDE\n");
 789       break;
 790    /*case OP_MODULUS:*/
 791    case OP_PREINCREMENT:
 792       printf("OP_PREINCREMENT\n");
 793       break;
 794    case OP_PREDECREMENT:
 795       printf("OP_PREDECREMENT\n");
 796       break;
 797    case OP_PLUS:
 798       printf("OP_PLUS\n");
 799       break;
 800    case OP_MINUS:
 801       printf("OP_MINUS\n");
 802       break;
 803    case OP_NOT:
 804       printf("OP_NOT\n");
 805       break;
 806    /*case OP_COMPLEMENT:*/
 807    case OP_SUBSCRIPT:
 808       printf("OP_SUBSCRIPT\n");
 809       break;
 810    case OP_CALL:
 811       printf("OP_CALL\n");
 812       break;
 813    case OP_FIELD:
 814       printf("OP_FIELD\n");
 815       break;
 816    case OP_POSTINCREMENT:
 817       printf("OP_POSTINCREMENT\n");
 818       break;
 819    case OP_POSTDECREMENT:
 820       printf("OP_POSTDECREMENT\n");
 821       break;
 822    default:
 823       printf("UNKNOWN OP %d\n", opcode);
 824    }
 825 }
 826
 827
 828
 829 const char *
 830 slang_asm_string(slang_assembly_type t)
 831 {
 832    switch (t) {
 833       /* core */
 834    case slang_asm_none:
 835       return "none";
 836    case slang_asm_float_copy:
 837       return "float_copy";
 838    case slang_asm_float_move:
 839       return "float_move";
 840    case slang_asm_float_push:
 841       return "float_push";
 842    case slang_asm_float_deref:
 843       return "float_deref";
 844    case slang_asm_float_add:
 845       return "float_add";
 846    case slang_asm_float_multiply:
 847       return "float_multiply";
 848    case slang_asm_float_divide:
 849       return "float_divide";
 850    case slang_asm_float_negate:
 851       return "float_negate";
 852    case slang_asm_float_less:
 853       return "float_less";
 854    case slang_asm_float_equal_exp:
 855       return "float_equal";
 856    case slang_asm_float_equal_int:
 857       return "float_equal";
 858    case slang_asm_float_to_int:
 859       return "float_to_int";
 860    case slang_asm_float_sine:
 861       return "float_sine";
 862    case slang_asm_float_arcsine:
 863       return "float_arcsine";
 864    case slang_asm_float_arctan:
 865       return "float_arctan";
 866    case slang_asm_float_power:
 867       return "float_power";
 868    case slang_asm_float_log2:
 869       return "float_log2";
 870    case slang_asm_vec4_floor:
 871       return "vec4_floor";
 872    case slang_asm_float_ceil:
 873       return "float_ceil";
 874    case slang_asm_float_noise1:
 875       return "float_noise1";
 876    case slang_asm_float_noise2:
 877       return "float_noise2";
 878    case slang_asm_float_noise3:
 879       return "float_noise3";
 880    case slang_asm_float_noise4:
 881       return "float_noise4";
 882    case slang_asm_int_copy:
 883       return "int_copy";
 884    case slang_asm_int_move:
 885       return "int_move";
 886    case slang_asm_int_push:
 887       return "int_push";
 888    case slang_asm_int_deref:
 889       return "int_deref";
 890    case slang_asm_int_to_float:
 891       return "int_to_float";
 892    case slang_asm_int_to_addr:
 893       return "int_to_addr";
 894    case slang_asm_bool_copy:
 895       return "bool_copy";
 896    case slang_asm_bool_move:
 897       return "bool_move";
 898    case slang_asm_bool_push:
 899       return "bool_push";
 900    case slang_asm_bool_deref:
 901       return "bool_deref";
 902    case slang_asm_addr_copy:
 903       return "addr_copy";
 904    case slang_asm_addr_push:
 905       return "addr_push";
 906    case slang_asm_addr_deref:
 907       return "addr_deref";
 908    case slang_asm_addr_add:
 909       return "addr_add";
 910    case slang_asm_addr_multiply:
 911       return "addr_multiply";
 912    case slang_asm_vec4_tex1d:
 913       return "vec4_tex1d";
 914    case slang_asm_vec4_tex2d:
 915       return "vec4_tex2d";
 916    case slang_asm_vec4_tex3d:
 917       return "vec4_tex3d";
 918    case slang_asm_vec4_texcube:
 919       return "vec4_texcube";
 920    case slang_asm_vec4_shad1d:
 921       return "vec4_shad1d";
 922    case slang_asm_vec4_shad2d:
 923       return "vec4_shad2d";
 924    case slang_asm_jump:
 925       return "jump";
 926    case slang_asm_jump_if_zero:
 927       return "jump_if_zero";
 928    case slang_asm_enter:
 929       return "enter";
 930    case slang_asm_leave:
 931       return "leave";
 932    case slang_asm_local_alloc:
 933       return "local_alloc";
 934    case slang_asm_local_free:
 935       return "local_free";
 936    case slang_asm_local_addr:
 937       return "local_addr";
 938    case slang_asm_global_addr:
 939       return "global_addr";
 940    case slang_asm_call:
 941       return "call";
 942    case slang_asm_return:
 943       return "return";
 944    case slang_asm_discard:
 945       return "discard";
 946    case slang_asm_exit:
 947       return "exit";
 948       /* GL_MESA_shader_debug */
 949    case slang_asm_float_print:
 950       return "float_print";
 951    case slang_asm_int_print:
 952       return "int_print";
 953    case slang_asm_bool_print:
 954       return "bool_print";
 955       /* vec4 */
 956    case slang_asm_float_to_vec4:
 957       return "float_to_vec4";
 958    case slang_asm_vec4_add:
 959       return "vec4_add";
 960    case slang_asm_vec4_subtract:
 961       return "vec4_subtract";
 962    case slang_asm_vec4_multiply:
 963       return "vec4_multiply";
 964    case slang_asm_vec4_divide:
 965       return "vec4_divide";
 966    case slang_asm_vec4_negate:
 967       return "vec4_negate";
 968    case slang_asm_vec4_dot:
 969       return "vec4_dot";
 970    case slang_asm_vec4_copy:
 971       return "vec4_copy";
 972    case slang_asm_vec4_deref:
 973       return "vec4_deref";
 974    case slang_asm_vec4_equal_int:
 975       return "vec4_equal";
 976    default:
 977       return "??asm??";
 978    }
 979 }
 980
 981
 982 const char *
 983 slang_type_qual_string(slang_type_qualifier q)
 984 {
 985    switch (q) {
 986    case slang_qual_none:
 987       return "none";
 988    case slang_qual_const:
 989       return "const";
 990    case slang_qual_attribute:
 991       return "attribute";
 992    case slang_qual_varying:
 993       return "varying";
 994    case slang_qual_uniform:
 995       return "uniform";
 996    case slang_qual_out:
 997       return "out";
 998    case slang_qual_inout:
 999       return "inout";
1000    case slang_qual_fixedoutput:
1001       return "fixedoutput";
1002    case slang_qual_fixedinput:
1003       return "fixedinputk";
1004    default:
1005       return "qual?";
1006    }
1007 }
1008
1009
1010 static const char *
1011 slang_type_string(slang_type_specifier_type t)
1012 {
1013    switch (t) {
1014    case slang_spec_void:
1015       return "void";
1016    case slang_spec_bool:
1017       return "bool";
1018    case slang_spec_bvec2:
1019       return "bvec2";
1020    case slang_spec_bvec3:
1021       return "bvec3";
1022    case slang_spec_bvec4:
1023       return "bvec4";
1024    case slang_spec_int:
1025       return "int";
1026    case slang_spec_ivec2:
1027       return "ivec2";
1028    case slang_spec_ivec3:
1029       return "ivec3";
1030    case slang_spec_ivec4:
1031       return "ivec4";
1032    case slang_spec_float:
1033       return "float";
1034    case slang_spec_vec2:
1035       return "vec2";
1036    case slang_spec_vec3:
1037       return "vec3";
1038    case slang_spec_vec4:
1039       return "vec4";
1040    case slang_spec_mat2:
1041       return "mat2";
1042    case slang_spec_mat3:
1043       return "mat3";
1044    case slang_spec_mat4:
1045       return "mat4";
1046    case slang_spec_sampler1D:
1047       return "sampler1D";
1048    case slang_spec_sampler2D:
1049       return "sampler2D";
1050    case slang_spec_sampler3D:
1051       return "sampler3D";
1052    case slang_spec_samplerCube:
1053       return "samplerCube";
1054    case slang_spec_sampler1DShadow:
1055       return "sampler1DShadow";
1056    case slang_spec_sampler2DShadow:
1057       return "sampler2DShadow";
1058    case slang_spec_struct:
1059       return "struct";
1060    case slang_spec_array:
1061       return "array";
1062    default:
1063       return "type?";
1064    }
1065 }
1066
1067
1068 static const char *
1069 slang_fq_type_string(const slang_fully_specified_type *t)
1070 {
1071    static char str[1000];
1072    sprintf(str, "%s %s", slang_type_qual_string(t->qualifier),
1073       slang_type_string(t->specifier.type));
1074    return str;
1075 }
1076
1077
1078 void
1079 slang_print_type(const slang_fully_specified_type *t)
1080 {
1081    printf("%s %s", slang_type_qual_string(t->qualifier),
1082       slang_type_string(t->specifier.type));
1083 }
1084
1085
1086 static char *
1087 slang_var_string(const slang_variable *v)
1088 {
1089    static char str[1000];
1090    sprintf(str, "%s : %s",
1091            (char *) v->a_name,
1092            slang_fq_type_string(&v->type));
1093    return str;
1094 }
1095
1096
1097 void
1098 slang_print_variable(const slang_variable *v)
1099 {
1100    printf("Name: %s\n", (char *) v->a_name);
1101    printf("Type: %s\n", slang_fq_type_string(&v->type));
1102 }
1103
1104
1105 void
1106 _slang_print_var_scope(const slang_variable_scope *vars, int indent)
1107 {
1108    GLuint i;
1109
1110    spaces(indent);
1111    printf("Var scope %p  %d vars\n", (void *) vars, vars->num_variables);
1112    for (i = 0; i < vars->num_variables; i++) {
1113       spaces(indent + 3);
1114       printf("%s\n", (char *) vars->variables[i].a_name);
1115    }
1116
1117    if (vars->outer_scope) {
1118       spaces(indent + 3);
1119       printf("outer_scope = %p\n", (void*) vars->outer_scope);
1120       _slang_print_var_scope(vars->outer_scope, indent + 3);
1121    }
1122 }
1123
1124
1125
1126 int
1127 slang_checksum_tree(const slang_operation *op)
1128 {
1129    int s = op->num_children;
1130    int i;
1131
1132    for (i = 0; i < op->num_children; i++) {
1133       s += slang_checksum_tree(&op->children[i]);
1134    }
1135    return s;
1136 }