src/mesa/slang/slang_print.c

   1
   2 /**
   3  * Dump/print a slang_operation tree
   4  */
   5
   6
   7 #include "main/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_MAT23:
 105       printf("mat2x3");
 106       break;
 107    case SLANG_SPEC_MAT32:
 108       printf("mat3x2");
 109       break;
 110    case SLANG_SPEC_MAT24:
 111       printf("mat2x4");
 112       break;
 113    case SLANG_SPEC_MAT42:
 114       printf("mat4x2");
 115       break;
 116    case SLANG_SPEC_MAT34:
 117       printf("mat3x4");
 118       break;
 119    case SLANG_SPEC_MAT43:
 120       printf("mat4x3");
 121       break;
 122    case SLANG_SPEC_SAMPLER_1D:
 123       printf("sampler1D");
 124       break;
 125    case SLANG_SPEC_SAMPLER_2D:
 126       printf("sampler2D");
 127       break;
 128    case SLANG_SPEC_SAMPLER_3D:
 129       printf("sampler3D");
 130       break;
 131    case SLANG_SPEC_SAMPLER_CUBE:
 132       printf("samplerCube");
 133       break;
 134    case SLANG_SPEC_SAMPLER_1D_SHADOW:
 135       printf("sampler1DShadow");
 136       break;
 137    case SLANG_SPEC_SAMPLER_2D_SHADOW:
 138       printf("sampler2DShadow");
 139       break;
 140    case SLANG_SPEC_STRUCT:
 141       printf("struct");
 142       break;
 143    case SLANG_SPEC_ARRAY:
 144       printf("array");
 145       break;
 146    default:
 147       printf("unknown type");
 148    }
 149    /*printf("\n");*/
 150 }
 151
 152
 153 static void
 154 print_variable(const slang_variable *v, int indent)
 155 {
 156    spaces(indent);
 157    printf("VAR ");
 158    print_type(&v->type);
 159    printf(" %s (at %p)", (char *) v->a_name, (void *) v);
 160    if (v->initializer) {
 161       printf(" :=\n");
 162       slang_print_tree(v->initializer, indent + 3);
 163    }
 164    else {
 165       printf(";\n");
 166    }
 167 }
 168
 169
 170 static void
 171 print_binary(const slang_operation *op, const char *oper, int indent)
 172 {
 173    assert(op->num_children == 2);
 174 #if 0
 175    printf("binary at %p locals=%p outer=%p\n",
 176           (void *) op,
 177           (void *) op->locals,
 178           (void *) op->locals->outer_scope);
 179 #endif
 180    slang_print_tree(&op->children[0], indent + 3);
 181    spaces(indent);
 182    printf("%s at %p locals=%p outer=%p\n",
 183           oper, (void *) op, (void *) op->locals,
 184           (void *) op->locals->outer_scope);
 185    slang_print_tree(&op->children[1], indent + 3);
 186 }
 187
 188
 189 static void
 190 print_generic2(const slang_operation *op, const char *oper,
 191                const char *s, int indent)
 192 {
 193    GLuint i;
 194    if (oper) {
 195       spaces(indent);
 196       printf("%s %s at %p locals=%p outer=%p\n",
 197              oper, s, (void *) op, (void *) op->locals,
 198              (void *) op->locals->outer_scope);
 199    }
 200    for (i = 0; i < op->num_children; i++) {
 201       spaces(indent);
 202       printf("//child %u of %u:\n", i, op->num_children);
 203       slang_print_tree(&op->children[i], indent);
 204    }
 205 }
 206
 207 static void
 208 print_generic(const slang_operation *op, const char *oper, int indent)
 209 {
 210    print_generic2(op, oper, "", indent);
 211 }
 212
 213
 214 static const slang_variable_scope *
 215 find_scope(const slang_variable_scope *s, slang_atom name)
 216 {
 217    GLuint i;
 218    for (i = 0; i < s->num_variables; i++) {
 219       if (s->variables[i]->a_name == name)
 220          return s;
 221    }
 222    if (s->outer_scope)
 223       return find_scope(s->outer_scope, name);
 224    else
 225       return NULL;
 226 }
 227
 228 static const slang_variable *
 229 find_var(const slang_variable_scope *s, slang_atom name)
 230 {
 231    GLuint i;
 232    for (i = 0; i < s->num_variables; i++) {
 233       if (s->variables[i]->a_name == name)
 234          return s->variables[i];
 235    }
 236    if (s->outer_scope)
 237       return find_var(s->outer_scope, name);
 238    else
 239       return NULL;
 240 }
 241
 242
 243 void
 244 slang_print_tree(const slang_operation *op, int indent)
 245 {
 246    GLuint i;
 247
 248    switch (op->type) {
 249
 250    case SLANG_OPER_NONE:
 251       spaces(indent);
 252       printf("SLANG_OPER_NONE\n");
 253       break;
 254
 255    case SLANG_OPER_BLOCK_NO_NEW_SCOPE:
 256       spaces(indent);
 257       printf("{ locals=%p  outer=%p\n", (void*)op->locals, (void*)op->locals->outer_scope);
 258       print_generic(op, NULL, indent+3);
 259       spaces(indent);
 260       printf("}\n");
 261       break;
 262
 263    case SLANG_OPER_BLOCK_NEW_SCOPE:
 264    case SLANG_OPER_NON_INLINED_CALL:
 265       spaces(indent);
 266       printf("{{ // new scope  locals=%p outer=%p: ",
 267              (void *) op->locals,
 268              (void *) op->locals->outer_scope);
 269       for (i = 0; i < op->locals->num_variables; i++) {
 270          printf("%s ", (char *) op->locals->variables[i]->a_name);
 271       }
 272       printf("\n");
 273       print_generic(op, NULL, indent+3);
 274       spaces(indent);
 275       printf("}}\n");
 276       break;
 277
 278    case SLANG_OPER_VARIABLE_DECL:
 279       assert(op->num_children == 0 || op->num_children == 1);
 280       {
 281          slang_variable *v;
 282          v = _slang_variable_locate(op->locals, op->a_id, GL_TRUE);
 283          if (v) {
 284             const slang_variable_scope *scope;
 285             spaces(indent);
 286             printf("DECL (locals=%p outer=%p) ", (void*)op->locals, (void*) op->locals->outer_scope);
 287             print_type(&v->type);
 288             printf(" %s (%p)", (char *) op->a_id,
 289                    (void *) find_var(op->locals, op->a_id));
 290
 291             scope = find_scope(op->locals, op->a_id);
 292             printf(" (in scope %p) ", (void *) scope);
 293             assert(scope);
 294             if (op->num_children == 1) {
 295                printf(" :=\n");
 296                slang_print_tree(&op->children[0], indent + 3);
 297             }
 298             else if (v->initializer) {
 299                printf(" := INITIALIZER\n");
 300                slang_print_tree(v->initializer, indent + 3);
 301             }
 302             else {
 303                printf(";\n");
 304             }
 305             /*
 306             spaces(indent);
 307             printf("TYPE: ");
 308             print_type(&v->type);
 309             spaces(indent);
 310             printf("ADDR: %d  size: %d\n", v->address, v->size);
 311             */
 312          }
 313          else {
 314             spaces(indent);
 315             printf("DECL %s (anonymous variable!!!!)\n", (char *) op->a_id);
 316          }
 317       }
 318       break;
 319
 320    case SLANG_OPER_ASM:
 321       spaces(indent);
 322       printf("ASM: %s at %p locals=%p outer=%p\n",
 323              (char *) op->a_id,
 324              (void *) op,
 325              (void *) op->locals,
 326              (void *) op->locals->outer_scope);
 327       print_generic(op, "ASM", indent+3);
 328       break;
 329
 330    case SLANG_OPER_BREAK:
 331       spaces(indent);
 332       printf("BREAK\n");
 333       break;
 334
 335    case SLANG_OPER_CONTINUE:
 336       spaces(indent);
 337       printf("CONTINUE\n");
 338       break;
 339
 340    case SLANG_OPER_DISCARD:
 341       spaces(indent);
 342       printf("DISCARD\n");
 343       break;
 344
 345    case SLANG_OPER_RETURN:
 346       spaces(indent);
 347       printf("RETURN\n");
 348       if (op->num_children > 0)
 349          slang_print_tree(&op->children[0], indent + 3);
 350       break;
 351
 352    case SLANG_OPER_RETURN_INLINED:
 353       spaces(indent);
 354       printf("RETURN_INLINED\n");
 355       if (op->num_children > 0)
 356          slang_print_tree(&op->children[0], indent + 3);
 357       break;
 358
 359    case SLANG_OPER_LABEL:
 360       spaces(indent);
 361       printf("LABEL %s\n", (char *) op->a_id);
 362       break;
 363
 364    case SLANG_OPER_EXPRESSION:
 365       spaces(indent);
 366       printf("EXPR:  locals=%p outer=%p\n",
 367              (void *) op->locals,
 368              (void *) op->locals->outer_scope);
 369       /*print_generic(op, "SLANG_OPER_EXPRESSION", indent);*/
 370       slang_print_tree(&op->children[0], indent + 3);
 371       break;
 372
 373    case SLANG_OPER_IF:
 374       spaces(indent);
 375       printf("IF\n");
 376       slang_print_tree(&op->children[0], indent + 3);
 377       spaces(indent);
 378       printf("THEN\n");
 379       slang_print_tree(&op->children[1], indent + 3);
 380       spaces(indent);
 381       printf("ELSE\n");
 382       slang_print_tree(&op->children[2], indent + 3);
 383       spaces(indent);
 384       printf("ENDIF\n");
 385       break;
 386
 387    case SLANG_OPER_WHILE:
 388       assert(op->num_children == 2);
 389       spaces(indent);
 390       printf("WHILE LOOP: locals = %p\n", (void *) op->locals);
 391       indent += 3;
 392       spaces(indent);
 393       printf("WHILE cond:\n");
 394       slang_print_tree(&op->children[0], indent + 3);
 395       spaces(indent);
 396       printf("WHILE body:\n");
 397       slang_print_tree(&op->children[1], indent + 3);
 398       indent -= 3;
 399       spaces(indent);
 400       printf("END WHILE LOOP\n");
 401       break;
 402
 403    case SLANG_OPER_DO:
 404       spaces(indent);
 405       printf("DO LOOP: locals = %p\n", (void *) op->locals);
 406       indent += 3;
 407       spaces(indent);
 408       printf("DO body:\n");
 409       slang_print_tree(&op->children[0], indent + 3);
 410       spaces(indent);
 411       printf("DO cond:\n");
 412       slang_print_tree(&op->children[1], indent + 3);
 413       indent -= 3;
 414       spaces(indent);
 415       printf("END DO LOOP\n");
 416       break;
 417
 418    case SLANG_OPER_FOR:
 419       spaces(indent);
 420       printf("FOR LOOP: locals = %p\n", (void *) op->locals);
 421       indent += 3;
 422       spaces(indent);
 423       printf("FOR init:\n");
 424       slang_print_tree(&op->children[0], indent + 3);
 425       spaces(indent);
 426       printf("FOR condition:\n");
 427       slang_print_tree(&op->children[1], indent + 3);
 428       spaces(indent);
 429       printf("FOR step:\n");
 430       slang_print_tree(&op->children[2], indent + 3);
 431       spaces(indent);
 432       printf("FOR body:\n");
 433       slang_print_tree(&op->children[3], indent + 3);
 434       indent -= 3;
 435       spaces(indent);
 436       printf("ENDFOR\n");
 437       /*
 438       print_generic(op, "FOR", indent + 3);
 439       */
 440       break;
 441
 442    case SLANG_OPER_VOID:
 443       spaces(indent);
 444       printf("(oper-void)\n");
 445       break;
 446
 447    case SLANG_OPER_LITERAL_BOOL:
 448       spaces(indent);
 449       printf("LITERAL (");
 450       for (i = 0; i < op->literal_size; i++)
 451          printf("%s ", op->literal[0] ? "TRUE" : "FALSE");
 452       printf(")\n");
 453
 454       break;
 455
 456    case SLANG_OPER_LITERAL_INT:
 457       spaces(indent);
 458       printf("LITERAL (");
 459       for (i = 0; i < op->literal_size; i++)
 460          printf("%d ", (int) op->literal[i]);
 461       printf(")\n");
 462       break;
 463
 464    case SLANG_OPER_LITERAL_FLOAT:
 465       spaces(indent);
 466       printf("LITERAL (");
 467       for (i = 0; i < op->literal_size; i++)
 468          printf("%f ", op->literal[i]);
 469       printf(")\n");
 470       break;
 471
 472    case SLANG_OPER_IDENTIFIER:
 473       {
 474          const slang_variable_scope *scope;
 475          spaces(indent);
 476          if (op->var && op->var->a_name) {
 477             scope = find_scope(op->locals, op->var->a_name);
 478             printf("VAR %s  (in scope %p)\n", (char *) op->var->a_name,
 479                    (void *) scope);
 480             assert(scope);
 481          }
 482          else {
 483             scope = find_scope(op->locals, op->a_id);
 484             printf("VAR' %s  (in scope %p) locals=%p outer=%p\n",
 485                    (char *) op->a_id,
 486                    (void *) scope,
 487                    (void *) op->locals,
 488                    (void *) op->locals->outer_scope);
 489             /*assert(scope);*/
 490          }
 491       }
 492       break;
 493
 494    case SLANG_OPER_SEQUENCE:
 495       print_generic(op, "COMMA-SEQ", indent+3);
 496       break;
 497
 498    case SLANG_OPER_ASSIGN:
 499       spaces(indent);
 500       printf("ASSIGNMENT  locals=%p outer=%p\n",
 501              (void *) op->locals,
 502              (void *) op->locals->outer_scope);
 503       print_binary(op, ":=", indent);
 504       break;
 505
 506    case SLANG_OPER_ADDASSIGN:
 507       spaces(indent);
 508       printf("ASSIGN\n");
 509       print_binary(op, "+=", indent);
 510       break;
 511
 512    case SLANG_OPER_SUBASSIGN:
 513       spaces(indent);
 514       printf("ASSIGN\n");
 515       print_binary(op, "-=", indent);
 516       break;
 517
 518    case SLANG_OPER_MULASSIGN:
 519       spaces(indent);
 520       printf("ASSIGN\n");
 521       print_binary(op, "*=", indent);
 522       break;
 523
 524    case SLANG_OPER_DIVASSIGN:
 525       spaces(indent);
 526       printf("ASSIGN\n");
 527       print_binary(op, "/=", indent);
 528       break;
 529
 530         /*SLANG_OPER_MODASSIGN,*/
 531         /*SLANG_OPER_LSHASSIGN,*/
 532         /*SLANG_OPER_RSHASSIGN,*/
 533         /*SLANG_OPER_ORASSIGN,*/
 534         /*SLANG_OPER_XORASSIGN,*/
 535         /*SLANG_OPER_ANDASSIGN,*/
 536    case SLANG_OPER_SELECT:
 537       spaces(indent);
 538       printf("SLANG_OPER_SELECT n=%d\n", op->num_children);
 539       assert(op->num_children == 3);
 540       slang_print_tree(&op->children[0], indent+3);
 541       spaces(indent);
 542       printf("?\n");
 543       slang_print_tree(&op->children[1], indent+3);
 544       spaces(indent);
 545       printf(":\n");
 546       slang_print_tree(&op->children[2], indent+3);
 547       break;
 548
 549    case SLANG_OPER_LOGICALOR:
 550       print_binary(op, "||", indent);
 551       break;
 552
 553    case SLANG_OPER_LOGICALXOR:
 554       print_binary(op, "^^", indent);
 555       break;
 556
 557    case SLANG_OPER_LOGICALAND:
 558       print_binary(op, "&&", indent);
 559       break;
 560
 561    /*SLANG_OPER_BITOR*/
 562    /*SLANG_OPER_BITXOR*/
 563    /*SLANG_OPER_BITAND*/
 564    case SLANG_OPER_EQUAL:
 565       print_binary(op, "==", indent);
 566       break;
 567
 568    case SLANG_OPER_NOTEQUAL:
 569       print_binary(op, "!=", indent);
 570       break;
 571
 572    case SLANG_OPER_LESS:
 573       print_binary(op, "<", indent);
 574       break;
 575
 576    case SLANG_OPER_GREATER:
 577       print_binary(op, ">", indent);
 578       break;
 579
 580    case SLANG_OPER_LESSEQUAL:
 581       print_binary(op, "<=", indent);
 582       break;
 583
 584    case SLANG_OPER_GREATEREQUAL:
 585       print_binary(op, ">=", indent);
 586       break;
 587
 588    /*SLANG_OPER_LSHIFT*/
 589    /*SLANG_OPER_RSHIFT*/
 590    case SLANG_OPER_ADD:
 591       print_binary(op, "+", indent);
 592       break;
 593
 594    case SLANG_OPER_SUBTRACT:
 595       print_binary(op, "-", indent);
 596       break;
 597
 598    case SLANG_OPER_MULTIPLY:
 599       print_binary(op, "*", indent);
 600       break;
 601
 602    case SLANG_OPER_DIVIDE:
 603       print_binary(op, "/", indent);
 604       break;
 605
 606    /*SLANG_OPER_MODULUS*/
 607    case SLANG_OPER_PREINCREMENT:
 608       spaces(indent);
 609       printf("PRE++\n");
 610       slang_print_tree(&op->children[0], indent+3);
 611       break;
 612
 613    case SLANG_OPER_PREDECREMENT:
 614       spaces(indent);
 615       printf("PRE--\n");
 616       slang_print_tree(&op->children[0], indent+3);
 617       break;
 618
 619    case SLANG_OPER_PLUS:
 620       spaces(indent);
 621       printf("SLANG_OPER_PLUS\n");
 622       break;
 623
 624    case SLANG_OPER_MINUS:
 625       spaces(indent);
 626       printf("SLANG_OPER_MINUS\n");
 627       break;
 628
 629    /*SLANG_OPER_COMPLEMENT*/
 630    case SLANG_OPER_NOT:
 631       spaces(indent);
 632       printf("NOT\n");
 633       slang_print_tree(&op->children[0], indent+3);
 634       break;
 635
 636    case SLANG_OPER_SUBSCRIPT:
 637       spaces(indent);
 638       printf("SLANG_OPER_SUBSCRIPT locals=%p outer=%p\n",
 639              (void *) op->locals,
 640              (void *) op->locals->outer_scope);
 641       print_generic(op, NULL, indent+3);
 642       break;
 643
 644    case SLANG_OPER_CALL:
 645 #if 0
 646          slang_function *fun
 647             = _slang_function_locate(A->space.funcs, oper->a_id,
 648                                      oper->children,
 649                                      oper->num_children, &A->space, A->atoms);
 650 #endif
 651       spaces(indent);
 652       printf("CALL %s(\n", (char *) op->a_id);
 653       for (i = 0; i < op->num_children; i++) {
 654          slang_print_tree(&op->children[i], indent+3);
 655          if (i + 1 < op->num_children) {
 656             spaces(indent + 3);
 657             printf(",\n");
 658          }
 659       }
 660       spaces(indent);
 661       printf(")\n");
 662       break;
 663
 664    case SLANG_OPER_METHOD:
 665       spaces(indent);
 666       printf("METHOD CALL %s.%s\n", (char *) op->a_obj, (char *) op->a_id);
 667       break;
 668
 669    case SLANG_OPER_FIELD:
 670       spaces(indent);
 671       printf("FIELD %s of\n", (char*) op->a_id);
 672       slang_print_tree(&op->children[0], indent+3);
 673       break;
 674
 675    case SLANG_OPER_POSTINCREMENT:
 676       spaces(indent);
 677       printf("POST++\n");
 678       slang_print_tree(&op->children[0], indent+3);
 679       break;
 680
 681    case SLANG_OPER_POSTDECREMENT:
 682       spaces(indent);
 683       printf("POST--\n");
 684       slang_print_tree(&op->children[0], indent+3);
 685       break;
 686
 687    default:
 688       printf("unknown op->type %d\n", (int) op->type);
 689    }
 690
 691 }
 692
 693
 694
 695 void
 696 slang_print_function(const slang_function *f, GLboolean body)
 697 {
 698    GLuint i;
 699
 700 #if 0
 701    if (strcmp((char *) f->header.a_name, "main") != 0)
 702      return;
 703 #endif
 704
 705    printf("FUNCTION %s ( scope=%p\n",
 706           (char *) f->header.a_name, (void *) f->parameters);
 707
 708    for (i = 0; i < f->param_count; i++) {
 709       print_variable(f->parameters->variables[i], 3);
 710    }
 711
 712    printf(") param scope = %p\n", (void *) f->parameters);
 713
 714    if (body && f->body)
 715       slang_print_tree(f->body, 0);
 716 }
 717
 718
 719
 720
 721
 722 const char *
 723 slang_type_qual_string(slang_type_qualifier q)
 724 {
 725    switch (q) {
 726    case SLANG_QUAL_NONE:
 727       return "none";
 728    case SLANG_QUAL_CONST:
 729       return "const";
 730    case SLANG_QUAL_ATTRIBUTE:
 731       return "attribute";
 732    case SLANG_QUAL_VARYING:
 733       return "varying";
 734    case SLANG_QUAL_UNIFORM:
 735       return "uniform";
 736    case SLANG_QUAL_OUT:
 737       return "out";
 738    case SLANG_QUAL_INOUT:
 739       return "inout";
 740    case SLANG_QUAL_FIXEDOUTPUT:
 741       return "fixedoutput";
 742    case SLANG_QUAL_FIXEDINPUT:
 743       return "fixedinputk";
 744    default:
 745       return "qual?";
 746    }
 747 }
 748
 749
 750 static const char *
 751 slang_type_string(slang_type_specifier_type t)
 752 {
 753    switch (t) {
 754    case SLANG_SPEC_VOID:
 755       return "void";
 756    case SLANG_SPEC_BOOL:
 757       return "bool";
 758    case SLANG_SPEC_BVEC2:
 759       return "bvec2";
 760    case SLANG_SPEC_BVEC3:
 761       return "bvec3";
 762    case SLANG_SPEC_BVEC4:
 763       return "bvec4";
 764    case SLANG_SPEC_INT:
 765       return "int";
 766    case SLANG_SPEC_IVEC2:
 767       return "ivec2";
 768    case SLANG_SPEC_IVEC3:
 769       return "ivec3";
 770    case SLANG_SPEC_IVEC4:
 771       return "ivec4";
 772    case SLANG_SPEC_FLOAT:
 773       return "float";
 774    case SLANG_SPEC_VEC2:
 775       return "vec2";
 776    case SLANG_SPEC_VEC3:
 777       return "vec3";
 778    case SLANG_SPEC_VEC4:
 779       return "vec4";
 780    case SLANG_SPEC_MAT2:
 781       return "mat2";
 782    case SLANG_SPEC_MAT3:
 783       return "mat3";
 784    case SLANG_SPEC_MAT4:
 785       return "mat4";
 786    case SLANG_SPEC_SAMPLER_1D:
 787       return "sampler1D";
 788    case SLANG_SPEC_SAMPLER_2D:
 789       return "sampler2D";
 790    case SLANG_SPEC_SAMPLER_3D:
 791       return "sampler3D";
 792    case SLANG_SPEC_SAMPLER_CUBE:
 793       return "samplerCube";
 794    case SLANG_SPEC_SAMPLER_1D_SHADOW:
 795       return "sampler1DShadow";
 796    case SLANG_SPEC_SAMPLER_2D_SHADOW:
 797       return "sampler2DShadow";
 798    case SLANG_SPEC_SAMPLER_RECT:
 799       return "sampler2DRect";
 800    case SLANG_SPEC_SAMPLER_RECT_SHADOW:
 801       return "sampler2DRectShadow";
 802    case SLANG_SPEC_STRUCT:
 803       return "struct";
 804    case SLANG_SPEC_ARRAY:
 805       return "array";
 806    default:
 807       return "type?";
 808    }
 809 }
 810
 811
 812 static const char *
 813 slang_fq_type_string(const slang_fully_specified_type *t)
 814 {
 815    static char str[1000];
 816    _mesa_snprintf(str, sizeof(str), "%s %s", slang_type_qual_string(t->qualifier),
 817       slang_type_string(t->specifier.type));
 818    return str;
 819 }
 820
 821
 822 void
 823 slang_print_type(const slang_fully_specified_type *t)
 824 {
 825    printf("%s %s", slang_type_qual_string(t->qualifier),
 826       slang_type_string(t->specifier.type));
 827 }
 828
 829
 830 #if 0
 831 static char *
 832 slang_var_string(const slang_variable *v)
 833 {
 834    static char str[1000];
 835    _mesa_snprintf(str, sizeof(str), "%s : %s",
 836                   (char *) v->a_name,
 837                   slang_fq_type_string(&v->type));
 838    return str;
 839 }
 840 #endif
 841
 842
 843 void
 844 slang_print_variable(const slang_variable *v)
 845 {
 846    printf("Name: %s\n", (char *) v->a_name);
 847    printf("Type: %s\n", slang_fq_type_string(&v->type));
 848 }
 849
 850
 851 void
 852 _slang_print_var_scope(const slang_variable_scope *vars, int indent)
 853 {
 854    GLuint i;
 855
 856    spaces(indent);
 857    printf("Var scope %p  %d vars:\n", (void *) vars, vars->num_variables);
 858    for (i = 0; i < vars->num_variables; i++) {
 859       spaces(indent + 3);
 860       printf("%s (at %p)\n", (char *) vars->variables[i]->a_name, (void*) (vars->variables + i));
 861    }
 862    spaces(indent + 3);
 863    printf("outer_scope = %p\n", (void*) vars->outer_scope);
 864
 865    if (vars->outer_scope) {
 866       /*spaces(indent + 3);*/
 867       _slang_print_var_scope(vars->outer_scope, indent + 3);
 868    }
 869 }
 870
 871
 872
 873 int
 874 slang_checksum_tree(const slang_operation *op)
 875 {
 876    int s = op->num_children;
 877    GLuint i;
 878
 879    for (i = 0; i < op->num_children; i++) {
 880       s += slang_checksum_tree(&op->children[i]);
 881    }
 882    return s;
 883 }