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  outer %p\n", (void*)op->locals, (void*)op->locals->outer_scope);
 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 #if 0
 635
 636 const char *
 637 slang_asm_string(slang_assembly_type t)
 638 {
 639    switch (t) {
 640       /* core */
 641    case slang_asm_none:
 642       return "none";
 643    case slang_asm_float_copy:
 644       return "float_copy";
 645    case slang_asm_float_move:
 646       return "float_move";
 647    case slang_asm_float_push:
 648       return "float_push";
 649    case slang_asm_float_deref:
 650       return "float_deref";
 651    case slang_asm_float_add:
 652       return "float_add";
 653    case slang_asm_float_multiply:
 654       return "float_multiply";
 655    case slang_asm_float_divide:
 656       return "float_divide";
 657    case slang_asm_float_negate:
 658       return "float_negate";
 659    case slang_asm_float_less:
 660       return "float_less";
 661    case slang_asm_float_equal_exp:
 662       return "float_equal";
 663    case slang_asm_float_equal_int:
 664       return "float_equal";
 665    case slang_asm_float_to_int:
 666       return "float_to_int";
 667    case slang_asm_float_sine:
 668       return "float_sine";
 669    case slang_asm_float_arcsine:
 670       return "float_arcsine";
 671    case slang_asm_float_arctan:
 672       return "float_arctan";
 673    case slang_asm_float_power:
 674       return "float_power";
 675    case slang_asm_float_log2:
 676       return "float_log2";
 677    case slang_asm_vec4_floor:
 678       return "vec4_floor";
 679    case slang_asm_float_ceil:
 680       return "float_ceil";
 681    case slang_asm_float_noise1:
 682       return "float_noise1";
 683    case slang_asm_float_noise2:
 684       return "float_noise2";
 685    case slang_asm_float_noise3:
 686       return "float_noise3";
 687    case slang_asm_float_noise4:
 688       return "float_noise4";
 689    case slang_asm_int_copy:
 690       return "int_copy";
 691    case slang_asm_int_move:
 692       return "int_move";
 693    case slang_asm_int_push:
 694       return "int_push";
 695    case slang_asm_int_deref:
 696       return "int_deref";
 697    case slang_asm_int_to_float:
 698       return "int_to_float";
 699    case slang_asm_int_to_addr:
 700       return "int_to_addr";
 701    case slang_asm_bool_copy:
 702       return "bool_copy";
 703    case slang_asm_bool_move:
 704       return "bool_move";
 705    case slang_asm_bool_push:
 706       return "bool_push";
 707    case slang_asm_bool_deref:
 708       return "bool_deref";
 709    case slang_asm_addr_copy:
 710       return "addr_copy";
 711    case slang_asm_addr_push:
 712       return "addr_push";
 713    case slang_asm_addr_deref:
 714       return "addr_deref";
 715    case slang_asm_addr_add:
 716       return "addr_add";
 717    case slang_asm_addr_multiply:
 718       return "addr_multiply";
 719    case slang_asm_vec4_tex1d:
 720       return "vec4_tex1d";
 721    case slang_asm_vec4_tex2d:
 722       return "vec4_tex2d";
 723    case slang_asm_vec4_tex3d:
 724       return "vec4_tex3d";
 725    case slang_asm_vec4_texcube:
 726       return "vec4_texcube";
 727    case slang_asm_vec4_shad1d:
 728       return "vec4_shad1d";
 729    case slang_asm_vec4_shad2d:
 730       return "vec4_shad2d";
 731    case slang_asm_jump:
 732       return "jump";
 733    case slang_asm_jump_if_zero:
 734       return "jump_if_zero";
 735    case slang_asm_enter:
 736       return "enter";
 737    case slang_asm_leave:
 738       return "leave";
 739    case slang_asm_local_alloc:
 740       return "local_alloc";
 741    case slang_asm_local_free:
 742       return "local_free";
 743    case slang_asm_local_addr:
 744       return "local_addr";
 745    case slang_asm_global_addr:
 746       return "global_addr";
 747    case slang_asm_call:
 748       return "call";
 749    case slang_asm_return:
 750       return "return";
 751    case slang_asm_discard:
 752       return "discard";
 753    case slang_asm_exit:
 754       return "exit";
 755       /* GL_MESA_shader_debug */
 756    case slang_asm_float_print:
 757       return "float_print";
 758    case slang_asm_int_print:
 759       return "int_print";
 760    case slang_asm_bool_print:
 761       return "bool_print";
 762       /* vec4 */
 763    case slang_asm_float_to_vec4:
 764       return "float_to_vec4";
 765    case slang_asm_vec4_add:
 766       return "vec4_add";
 767    case slang_asm_vec4_subtract:
 768       return "vec4_subtract";
 769    case slang_asm_vec4_multiply:
 770       return "vec4_multiply";
 771    case slang_asm_vec4_divide:
 772       return "vec4_divide";
 773    case slang_asm_vec4_negate:
 774       return "vec4_negate";
 775    case slang_asm_vec4_dot:
 776       return "vec4_dot";
 777    case slang_asm_vec4_copy:
 778       return "vec4_copy";
 779    case slang_asm_vec4_deref:
 780       return "vec4_deref";
 781    case slang_asm_vec4_equal_int:
 782       return "vec4_equal";
 783    default:
 784       return "??asm??";
 785    }
 786 }
 787 #endif
 788
 789
 790 const char *
 791 slang_type_qual_string(slang_type_qualifier q)
 792 {
 793    switch (q) {
 794    case slang_qual_none:
 795       return "none";
 796    case slang_qual_const:
 797       return "const";
 798    case slang_qual_attribute:
 799       return "attribute";
 800    case slang_qual_varying:
 801       return "varying";
 802    case slang_qual_uniform:
 803       return "uniform";
 804    case slang_qual_out:
 805       return "out";
 806    case slang_qual_inout:
 807       return "inout";
 808    case slang_qual_fixedoutput:
 809       return "fixedoutput";
 810    case slang_qual_fixedinput:
 811       return "fixedinputk";
 812    default:
 813       return "qual?";
 814    }
 815 }
 816
 817
 818 static const char *
 819 slang_type_string(slang_type_specifier_type t)
 820 {
 821    switch (t) {
 822    case slang_spec_void:
 823       return "void";
 824    case slang_spec_bool:
 825       return "bool";
 826    case slang_spec_bvec2:
 827       return "bvec2";
 828    case slang_spec_bvec3:
 829       return "bvec3";
 830    case slang_spec_bvec4:
 831       return "bvec4";
 832    case slang_spec_int:
 833       return "int";
 834    case slang_spec_ivec2:
 835       return "ivec2";
 836    case slang_spec_ivec3:
 837       return "ivec3";
 838    case slang_spec_ivec4:
 839       return "ivec4";
 840    case slang_spec_float:
 841       return "float";
 842    case slang_spec_vec2:
 843       return "vec2";
 844    case slang_spec_vec3:
 845       return "vec3";
 846    case slang_spec_vec4:
 847       return "vec4";
 848    case slang_spec_mat2:
 849       return "mat2";
 850    case slang_spec_mat3:
 851       return "mat3";
 852    case slang_spec_mat4:
 853       return "mat4";
 854    case slang_spec_sampler1D:
 855       return "sampler1D";
 856    case slang_spec_sampler2D:
 857       return "sampler2D";
 858    case slang_spec_sampler3D:
 859       return "sampler3D";
 860    case slang_spec_samplerCube:
 861       return "samplerCube";
 862    case slang_spec_sampler1DShadow:
 863       return "sampler1DShadow";
 864    case slang_spec_sampler2DShadow:
 865       return "sampler2DShadow";
 866    case slang_spec_struct:
 867       return "struct";
 868    case slang_spec_array:
 869       return "array";
 870    default:
 871       return "type?";
 872    }
 873 }
 874
 875
 876 static const char *
 877 slang_fq_type_string(const slang_fully_specified_type *t)
 878 {
 879    static char str[1000];
 880    sprintf(str, "%s %s", slang_type_qual_string(t->qualifier),
 881       slang_type_string(t->specifier.type));
 882    return str;
 883 }
 884
 885
 886 void
 887 slang_print_type(const slang_fully_specified_type *t)
 888 {
 889    printf("%s %s", slang_type_qual_string(t->qualifier),
 890       slang_type_string(t->specifier.type));
 891 }
 892
 893
 894 #if 0
 895 static char *
 896 slang_var_string(const slang_variable *v)
 897 {
 898    static char str[1000];
 899    sprintf(str, "%s : %s",
 900            (char *) v->a_name,
 901            slang_fq_type_string(&v->type));
 902    return str;
 903 }
 904 #endif
 905
 906
 907 void
 908 slang_print_variable(const slang_variable *v)
 909 {
 910    printf("Name: %s\n", (char *) v->a_name);
 911    printf("Type: %s\n", slang_fq_type_string(&v->type));
 912 }
 913
 914
 915 void
 916 _slang_print_var_scope(const slang_variable_scope *vars, int indent)
 917 {
 918    GLuint i;
 919
 920    spaces(indent);
 921    printf("Var scope %p  %d vars:\n", (void *) vars, vars->num_variables);
 922    for (i = 0; i < vars->num_variables; i++) {
 923       spaces(indent + 3);
 924       printf("%s (at %p)\n", (char *) vars->variables[i]->a_name, (void*) (vars->variables + i));
 925    }
 926    spaces(indent + 3);
 927    printf("outer_scope = %p\n", (void*) vars->outer_scope);
 928
 929    if (vars->outer_scope) {
 930       /*spaces(indent + 3);*/
 931       _slang_print_var_scope(vars->outer_scope, indent + 3);
 932    }
 933 }
 934
 935
 936
 937 int
 938 slang_checksum_tree(const slang_operation *op)
 939 {
 940    int s = op->num_children;
 941    int i;
 942
 943    for (i = 0; i < op->num_children; i++) {
 944       s += slang_checksum_tree(&op->children[i]);
 945    }
 946    return s;
 947 }