src/mesa/shader/shader_api.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.6
   4  *
   5  * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
   6  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions 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 MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /**
  27  * \file shader_api.c
  28  * Implementation of GLSL-related API functions
  29  * \author Brian Paul
  30  */
  31
  32 /**
  33  * XXX things to do:
  34  * 1. Check that the right error code is generated for all _mesa_error() calls.
  35  * 2. Insert FLUSH_VERTICES calls in various places
  36  */
  37
  38
  39 #include "main/glheader.h"
  40 #include "main/context.h"
  41 #include "main/hash.h"
  42 #include "shader/program.h"
  43 #include "shader/prog_parameter.h"
  44 #include "shader/prog_statevars.h"
  45 #include "shader/prog_uniform.h"
  46 #include "shader/shader_api.h"
  47 #include "shader/slang/slang_compile.h"
  48 #include "shader/slang/slang_link.h"
  49 #include "main/dispatch.h"
  50
  51
  52 /**
  53  * Allocate a new gl_shader_program object, initialize it.
  54  */
  55 static struct gl_shader_program *
  56 _mesa_new_shader_program(GLcontext *ctx, GLuint name)
  57 {
  58    struct gl_shader_program *shProg;
  59    shProg = CALLOC_STRUCT(gl_shader_program);
  60    if (shProg) {
  61       shProg->Type = GL_SHADER_PROGRAM_MESA;
  62       shProg->Name = name;
  63       shProg->RefCount = 1;
  64       shProg->Attributes = _mesa_new_parameter_list();
  65    }
  66    return shProg;
  67 }
  68
  69
  70 /**
  71  * Clear (free) the shader program state that gets produced by linking.
  72  */
  73 void
  74 _mesa_clear_shader_program_data(GLcontext *ctx,
  75                                 struct gl_shader_program *shProg)
  76 {
  77    _mesa_reference_vertprog(ctx, &shProg->VertexProgram, NULL);
  78    _mesa_reference_fragprog(ctx, &shProg->FragmentProgram, NULL);
  79
  80    if (shProg->Uniforms) {
  81       _mesa_free_uniform_list(shProg->Uniforms);
  82       shProg->Uniforms = NULL;
  83    }
  84
  85    if (shProg->Varying) {
  86       _mesa_free_parameter_list(shProg->Varying);
  87       shProg->Varying = NULL;
  88    }
  89 }
  90
  91
  92 /**
  93  * Free all the data that hangs off a shader program object, but not the
  94  * object itself.
  95  */
  96 void
  97 _mesa_free_shader_program_data(GLcontext *ctx,
  98                                struct gl_shader_program *shProg)
  99 {
 100    GLuint i;
 101
 102    assert(shProg->Type == GL_SHADER_PROGRAM_MESA);
 103
 104    _mesa_clear_shader_program_data(ctx, shProg);
 105
 106    if (shProg->Attributes) {
 107       _mesa_free_parameter_list(shProg->Attributes);
 108       shProg->Attributes = NULL;
 109    }
 110
 111    /* detach shaders */
 112    for (i = 0; i < shProg->NumShaders; i++) {
 113       _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
 114    }
 115    shProg->NumShaders = 0;
 116
 117    if (shProg->Shaders) {
 118       free(shProg->Shaders);
 119       shProg->Shaders = NULL;
 120    }
 121
 122    if (shProg->InfoLog) {
 123       free(shProg->InfoLog);
 124       shProg->InfoLog = NULL;
 125    }
 126
 127    /* Transform feedback varying vars */
 128    for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
 129       free(shProg->TransformFeedback.VaryingNames[i]);
 130    }
 131    free(shProg->TransformFeedback.VaryingNames);
 132    shProg->TransformFeedback.VaryingNames = NULL;
 133    shProg->TransformFeedback.NumVarying = 0;
 134 }
 135
 136
 137 /**
 138  * Free/delete a shader program object.
 139  */
 140 void
 141 _mesa_free_shader_program(GLcontext *ctx, struct gl_shader_program *shProg)
 142 {
 143    _mesa_free_shader_program_data(ctx, shProg);
 144
 145    free(shProg);
 146 }
 147
 148
 149 /**
 150  * Set ptr to point to shProg.
 151  * If ptr is pointing to another object, decrement its refcount (and delete
 152  * if refcount hits zero).
 153  * Then set ptr to point to shProg, incrementing its refcount.
 154  */
 155 /* XXX this could be static */
 156 void
 157 _mesa_reference_shader_program(GLcontext *ctx,
 158                                struct gl_shader_program **ptr,
 159                                struct gl_shader_program *shProg)
 160 {
 161    assert(ptr);
 162    if (*ptr == shProg) {
 163       /* no-op */
 164       return;
 165    }
 166    if (*ptr) {
 167       /* Unreference the old shader program */
 168       GLboolean deleteFlag = GL_FALSE;
 169       struct gl_shader_program *old = *ptr;
 170
 171       ASSERT(old->RefCount > 0);
 172       old->RefCount--;
 173 #if 0
 174       printf("ShaderProgram %p ID=%u  RefCount-- to %d\n",
 175              (void *) old, old->Name, old->RefCount);
 176 #endif
 177       deleteFlag = (old->RefCount == 0);
 178
 179       if (deleteFlag) {
 180          _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
 181          _mesa_free_shader_program(ctx, old);
 182       }
 183
 184       *ptr = NULL;
 185    }
 186    assert(!*ptr);
 187
 188    if (shProg) {
 189       shProg->RefCount++;
 190 #if 0
 191       printf("ShaderProgram %p ID=%u  RefCount++ to %d\n",
 192              (void *) shProg, shProg->Name, shProg->RefCount);
 193 #endif
 194       *ptr = shProg;
 195    }
 196 }
 197
 198
 199 /**
 200  * Lookup a GLSL program object.
 201  */
 202 struct gl_shader_program *
 203 _mesa_lookup_shader_program(GLcontext *ctx, GLuint name)
 204 {
 205    struct gl_shader_program *shProg;
 206    if (name) {
 207       shProg = (struct gl_shader_program *)
 208          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
 209       /* Note that both gl_shader and gl_shader_program objects are kept
 210        * in the same hash table.  Check the object's type to be sure it's
 211        * what we're expecting.
 212        */
 213       if (shProg && shProg->Type != GL_SHADER_PROGRAM_MESA) {
 214          return NULL;
 215       }
 216       return shProg;
 217    }
 218    return NULL;
 219 }
 220
 221
 222 /**
 223  * As above, but record an error if program is not found.
 224  */
 225 static struct gl_shader_program *
 226 _mesa_lookup_shader_program_err(GLcontext *ctx, GLuint name,
 227                                 const char *caller)
 228 {
 229    if (!name) {
 230       _mesa_error(ctx, GL_INVALID_VALUE, caller);
 231       return NULL;
 232    }
 233    else {
 234       struct gl_shader_program *shProg = (struct gl_shader_program *)
 235          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
 236       if (!shProg) {
 237          _mesa_error(ctx, GL_INVALID_VALUE, caller);
 238          return NULL;
 239       }
 240       if (shProg->Type != GL_SHADER_PROGRAM_MESA) {
 241          _mesa_error(ctx, GL_INVALID_OPERATION, caller);
 242          return NULL;
 243       }
 244       return shProg;
 245    }
 246 }
 247
 248
 249
 250
 251 /**
 252  * Allocate a new gl_shader object, initialize it.
 253  */
 254 struct gl_shader *
 255 _mesa_new_shader(GLcontext *ctx, GLuint name, GLenum type)
 256 {
 257    struct gl_shader *shader;
 258    assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER);
 259    shader = CALLOC_STRUCT(gl_shader);
 260    if (shader) {
 261       shader->Type = type;
 262       shader->Name = name;
 263       shader->RefCount = 1;
 264    }
 265    return shader;
 266 }
 267
 268
 269 void
 270 _mesa_free_shader(GLcontext *ctx, struct gl_shader *sh)
 271 {
 272    if (sh->Source)
 273       free((void *) sh->Source);
 274    if (sh->InfoLog)
 275       free(sh->InfoLog);
 276    _mesa_reference_program(ctx, &sh->Program, NULL);
 277    free(sh);
 278 }
 279
 280
 281 /**
 282  * Set ptr to point to sh.
 283  * If ptr is pointing to another shader, decrement its refcount (and delete
 284  * if refcount hits zero).
 285  * Then set ptr to point to sh, incrementing its refcount.
 286  */
 287 /* XXX this could be static */
 288 void
 289 _mesa_reference_shader(GLcontext *ctx, struct gl_shader **ptr,
 290                        struct gl_shader *sh)
 291 {
 292    assert(ptr);
 293    if (*ptr == sh) {
 294       /* no-op */
 295       return;
 296    }
 297    if (*ptr) {
 298       /* Unreference the old shader */
 299       GLboolean deleteFlag = GL_FALSE;
 300       struct gl_shader *old = *ptr;
 301
 302       ASSERT(old->RefCount > 0);
 303       old->RefCount--;
 304       /*printf("SHADER DECR %p (%d) to %d\n",
 305         (void*) old, old->Name, old->RefCount);*/
 306       deleteFlag = (old->RefCount == 0);
 307
 308       if (deleteFlag) {
 309          _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
 310          _mesa_free_shader(ctx, old);
 311       }
 312
 313       *ptr = NULL;
 314    }
 315    assert(!*ptr);
 316
 317    if (sh) {
 318       /* reference new */
 319       sh->RefCount++;
 320       /*printf("SHADER INCR %p (%d) to %d\n",
 321         (void*) sh, sh->Name, sh->RefCount);*/
 322       *ptr = sh;
 323    }
 324 }
 325
 326
 327 /**
 328  * Lookup a GLSL shader object.
 329  */
 330 struct gl_shader *
 331 _mesa_lookup_shader(GLcontext *ctx, GLuint name)
 332 {
 333    if (name) {
 334       struct gl_shader *sh = (struct gl_shader *)
 335          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
 336       /* Note that both gl_shader and gl_shader_program objects are kept
 337        * in the same hash table.  Check the object's type to be sure it's
 338        * what we're expecting.
 339        */
 340       if (sh && sh->Type == GL_SHADER_PROGRAM_MESA) {
 341          return NULL;
 342       }
 343       return sh;
 344    }
 345    return NULL;
 346 }
 347
 348
 349 /**
 350  * As above, but record an error if shader is not found.
 351  */
 352 static struct gl_shader *
 353 _mesa_lookup_shader_err(GLcontext *ctx, GLuint name, const char *caller)
 354 {
 355    if (!name) {
 356       _mesa_error(ctx, GL_INVALID_VALUE, caller);
 357       return NULL;
 358    }
 359    else {
 360       struct gl_shader *sh = (struct gl_shader *)
 361          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
 362       if (!sh) {
 363          _mesa_error(ctx, GL_INVALID_VALUE, caller);
 364          return NULL;
 365       }
 366       if (sh->Type == GL_SHADER_PROGRAM_MESA) {
 367          _mesa_error(ctx, GL_INVALID_OPERATION, caller);
 368          return NULL;
 369       }
 370       return sh;
 371    }
 372 }
 373
 374
 375 /**
 376  * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
 377  */
 378 static GLbitfield
 379 get_shader_flags(void)
 380 {
 381    GLbitfield flags = 0x0;
 382    const char *env = _mesa_getenv("MESA_GLSL");
 383
 384    if (env) {
 385       if (strstr(env, "dump"))
 386          flags |= GLSL_DUMP;
 387       if (strstr(env, "log"))
 388          flags |= GLSL_LOG;
 389       if (strstr(env, "nopvert"))
 390          flags |= GLSL_NOP_VERT;
 391       if (strstr(env, "nopfrag"))
 392          flags |= GLSL_NOP_FRAG;
 393       if (strstr(env, "nopt"))
 394          flags |= GLSL_NO_OPT;
 395       else if (strstr(env, "opt"))
 396          flags |= GLSL_OPT;
 397       if (strstr(env, "uniform"))
 398          flags |= GLSL_UNIFORMS;
 399       if (strstr(env, "useprog"))
 400          flags |= GLSL_USE_PROG;
 401    }
 402
 403    return flags;
 404 }
 405
 406
 407 /**
 408  * Find the length of the longest transform feedback varying name
 409  * which was specified with glTransformFeedbackVaryings().
 410  */
 411 static GLint
 412 longest_feedback_varying_name(const struct gl_shader_program *shProg)
 413 {
 414    GLuint i;
 415    GLint max = 0;
 416    for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
 417       GLint len = strlen(shProg->TransformFeedback.VaryingNames[i]);
 418       if (len > max)
 419          max = len;
 420    }
 421    return max;
 422 }
 423
 424
 425
 426 /**
 427  * Initialize context's shader state.
 428  */
 429 void
 430 _mesa_init_shader_state(GLcontext * ctx)
 431 {
 432    /* Device drivers may override these to control what kind of instructions
 433     * are generated by the GLSL compiler.
 434     */
 435    ctx->Shader.EmitHighLevelInstructions = GL_TRUE;
 436    ctx->Shader.EmitContReturn = GL_TRUE;
 437    ctx->Shader.EmitCondCodes = GL_FALSE;
 438    ctx->Shader.EmitComments = GL_FALSE;
 439    ctx->Shader.Flags = get_shader_flags();
 440
 441    /* Default pragma settings */
 442    ctx->Shader.DefaultPragmas.IgnoreOptimize = GL_FALSE;
 443    ctx->Shader.DefaultPragmas.IgnoreDebug = GL_FALSE;
 444    ctx->Shader.DefaultPragmas.Optimize = GL_TRUE;
 445    ctx->Shader.DefaultPragmas.Debug = GL_FALSE;
 446 }
 447
 448
 449 /**
 450  * Free the per-context shader-related state.
 451  */
 452 void
 453 _mesa_free_shader_state(GLcontext *ctx)
 454 {
 455    _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, NULL);
 456 }
 457
 458
 459 /**
 460  * Copy string from <src> to <dst>, up to maxLength characters, returning
 461  * length of <dst> in <length>.
 462  * \param src  the strings source
 463  * \param maxLength  max chars to copy
 464  * \param length  returns number of chars copied
 465  * \param dst  the string destination
 466  */
 467 void
 468 _mesa_copy_string(GLchar *dst, GLsizei maxLength,
 469                   GLsizei *length, const GLchar *src)
 470 {
 471    GLsizei len;
 472    for (len = 0; len < maxLength - 1 && src && src[len]; len++)
 473       dst[len] = src[len];
 474    if (maxLength > 0)
 475       dst[len] = 0;
 476    if (length)
 477       *length = len;
 478 }
 479
 480
 481 static GLboolean
 482 _mesa_is_program(GLcontext *ctx, GLuint name)
 483 {
 484    struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
 485    return shProg ? GL_TRUE : GL_FALSE;
 486 }
 487
 488
 489 static GLboolean
 490 _mesa_is_shader(GLcontext *ctx, GLuint name)
 491 {
 492    struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
 493    return shader ? GL_TRUE : GL_FALSE;
 494 }
 495
 496
 497 /**
 498  * Called via ctx->Driver.AttachShader()
 499  */
 500 static void
 501 _mesa_attach_shader(GLcontext *ctx, GLuint program, GLuint shader)
 502 {
 503    struct gl_shader_program *shProg;
 504    struct gl_shader *sh;
 505    GLuint i, n;
 506
 507    shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");
 508    if (!shProg)
 509       return;
 510
 511    sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");
 512    if (!sh) {
 513       return;
 514    }
 515
 516    n = shProg->NumShaders;
 517    for (i = 0; i < n; i++) {
 518       if (shProg->Shaders[i] == sh) {
 519          /* The shader is already attched to this program.  The
 520           * GL_ARB_shader_objects spec says:
 521           *
 522           *     "The error INVALID_OPERATION is generated by AttachObjectARB
 523           *     if <obj> is already attached to <containerObj>."
 524           */
 525          _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
 526          return;
 527       }
 528    }
 529
 530    /* grow list */
 531    shProg->Shaders = (struct gl_shader **)
 532       _mesa_realloc(shProg->Shaders,
 533                     n * sizeof(struct gl_shader *),
 534                     (n + 1) * sizeof(struct gl_shader *));
 535    if (!shProg->Shaders) {
 536       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
 537       return;
 538    }
 539
 540    /* append */
 541    shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
 542    _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
 543    shProg->NumShaders++;
 544 }
 545
 546
 547 static GLint
 548 _mesa_get_attrib_location(GLcontext *ctx, GLuint program,
 549                           const GLchar *name)
 550 {
 551    struct gl_shader_program *shProg
 552       = _mesa_lookup_shader_program_err(ctx, program, "glGetAttribLocation");
 553
 554    if (!shProg) {
 555       return -1;
 556    }
 557
 558    if (!shProg->LinkStatus) {
 559       _mesa_error(ctx, GL_INVALID_OPERATION,
 560                   "glGetAttribLocation(program not linked)");
 561       return -1;
 562    }
 563
 564    if (!name)
 565       return -1;
 566
 567    if (shProg->VertexProgram) {
 568       const struct gl_program_parameter_list *attribs =
 569          shProg->VertexProgram->Base.Attributes;
 570       if (attribs) {
 571          GLint i = _mesa_lookup_parameter_index(attribs, -1, name);
 572          if (i >= 0) {
 573             return attribs->Parameters[i].StateIndexes[0];
 574          }
 575       }
 576    }
 577    return -1;
 578 }
 579
 580
 581 static void
 582 _mesa_bind_attrib_location(GLcontext *ctx, GLuint program, GLuint index,
 583                            const GLchar *name)
 584 {
 585    struct gl_shader_program *shProg;
 586    const GLint size = -1; /* unknown size */
 587    GLint i, oldIndex;
 588    GLenum datatype = GL_FLOAT_VEC4;
 589
 590    shProg = _mesa_lookup_shader_program_err(ctx, program,
 591                                             "glBindAttribLocation");
 592    if (!shProg) {
 593       return;
 594    }
 595
 596    if (!name)
 597       return;
 598
 599    if (strncmp(name, "gl_", 3) == 0) {
 600       _mesa_error(ctx, GL_INVALID_OPERATION,
 601                   "glBindAttribLocation(illegal name)");
 602       return;
 603    }
 604
 605    if (index >= ctx->Const.VertexProgram.MaxAttribs) {
 606       _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(index)");
 607       return;
 608    }
 609
 610    if (shProg->LinkStatus) {
 611       /* get current index/location for the attribute */
 612       oldIndex = _mesa_get_attrib_location(ctx, program, name);
 613    }
 614    else {
 615       oldIndex = -1;
 616    }
 617
 618    /* this will replace the current value if it's already in the list */
 619    i = _mesa_add_attribute(shProg->Attributes, name, size, datatype, index);
 620    if (i < 0) {
 621       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");
 622       return;
 623    }
 624
 625    /*
 626     * Note that this attribute binding won't go into effect until
 627     * glLinkProgram is called again.
 628     */
 629 }
 630
 631
 632 static GLuint
 633 _mesa_create_shader(GLcontext *ctx, GLenum type)
 634 {
 635    struct gl_shader *sh;
 636    GLuint name;
 637
 638    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 639
 640    switch (type) {
 641    case GL_FRAGMENT_SHADER:
 642    case GL_VERTEX_SHADER:
 643       sh = _mesa_new_shader(ctx, name, type);
 644       break;
 645    default:
 646       _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
 647       return 0;
 648    }
 649
 650    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
 651
 652    return name;
 653 }
 654
 655
 656 static GLuint
 657 _mesa_create_program(GLcontext *ctx)
 658 {
 659    GLuint name;
 660    struct gl_shader_program *shProg;
 661
 662    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 663    shProg = _mesa_new_shader_program(ctx, name);
 664
 665    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);
 666
 667    assert(shProg->RefCount == 1);
 668
 669    return name;
 670 }
 671
 672
 673 /**
 674  * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
 675  * DeleteProgramARB.
 676  */
 677 static void
 678 _mesa_delete_program2(GLcontext *ctx, GLuint name)
 679 {
 680    /*
 681     * NOTE: deleting shaders/programs works a bit differently than
 682     * texture objects (and buffer objects, etc).  Shader/program
 683     * handles/IDs exist in the hash table until the object is really
 684     * deleted (refcount==0).  With texture objects, the handle/ID is
 685     * removed from the hash table in glDeleteTextures() while the tex
 686     * object itself might linger until its refcount goes to zero.
 687     */
 688    struct gl_shader_program *shProg;
 689
 690    shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
 691    if (!shProg)
 692       return;
 693
 694    shProg->DeletePending = GL_TRUE;
 695
 696    /* effectively, decr shProg's refcount */
 697    _mesa_reference_shader_program(ctx, &shProg, NULL);
 698 }
 699
 700
 701 static void
 702 _mesa_delete_shader(GLcontext *ctx, GLuint shader)
 703 {
 704    struct gl_shader *sh;
 705
 706    sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
 707    if (!sh)
 708       return;
 709
 710    sh->DeletePending = GL_TRUE;
 711
 712    /* effectively, decr sh's refcount */
 713    _mesa_reference_shader(ctx, &sh, NULL);
 714 }
 715
 716
 717 static void
 718 _mesa_detach_shader(GLcontext *ctx, GLuint program, GLuint shader)
 719 {
 720    struct gl_shader_program *shProg;
 721    GLuint n;
 722    GLuint i, j;
 723
 724    shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
 725    if (!shProg)
 726       return;
 727
 728    n = shProg->NumShaders;
 729
 730    for (i = 0; i < n; i++) {
 731       if (shProg->Shaders[i]->Name == shader) {
 732          /* found it */
 733          struct gl_shader **newList;
 734
 735          /* release */
 736          _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
 737
 738          /* alloc new, smaller array */
 739          newList = (struct gl_shader **)
 740             malloc((n - 1) * sizeof(struct gl_shader *));
 741          if (!newList) {
 742             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
 743             return;
 744          }
 745          for (j = 0; j < i; j++) {
 746             newList[j] = shProg->Shaders[j];
 747          }
 748          while (++i < n)
 749             newList[j++] = shProg->Shaders[i];
 750          free(shProg->Shaders);
 751
 752          shProg->Shaders = newList;
 753          shProg->NumShaders = n - 1;
 754
 755 #ifdef DEBUG
 756          /* sanity check */
 757          {
 758             for (j = 0; j < shProg->NumShaders; j++) {
 759                assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
 760                       shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
 761                assert(shProg->Shaders[j]->RefCount > 0);
 762             }
 763          }
 764 #endif
 765
 766          return;
 767       }
 768    }
 769
 770    /* not found */
 771    {
 772       GLenum err;
 773       if (_mesa_is_shader(ctx, shader))
 774          err = GL_INVALID_OPERATION;
 775       else if (_mesa_is_program(ctx, shader))
 776          err = GL_INVALID_OPERATION;
 777       else
 778          err = GL_INVALID_VALUE;
 779       _mesa_error(ctx, err, "glDetachProgram(shader)");
 780       return;
 781    }
 782 }
 783
 784
 785 /**
 786  * Return the size of the given GLSL datatype, in floats (components).
 787  */
 788 GLint
 789 _mesa_sizeof_glsl_type(GLenum type)
 790 {
 791    switch (type) {
 792    case GL_FLOAT:
 793    case GL_INT:
 794    case GL_BOOL:
 795    case GL_SAMPLER_1D:
 796    case GL_SAMPLER_2D:
 797    case GL_SAMPLER_3D:
 798    case GL_SAMPLER_CUBE:
 799    case GL_SAMPLER_1D_SHADOW:
 800    case GL_SAMPLER_2D_SHADOW:
 801    case GL_SAMPLER_2D_RECT_ARB:
 802    case GL_SAMPLER_2D_RECT_SHADOW_ARB:
 803    case GL_SAMPLER_1D_ARRAY_EXT:
 804    case GL_SAMPLER_2D_ARRAY_EXT:
 805    case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:
 806    case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:
 807    case GL_SAMPLER_CUBE_SHADOW_EXT:
 808       return 1;
 809    case GL_FLOAT_VEC2:
 810    case GL_INT_VEC2:
 811    case GL_BOOL_VEC2:
 812       return 2;
 813    case GL_FLOAT_VEC3:
 814    case GL_INT_VEC3:
 815    case GL_BOOL_VEC3:
 816       return 3;
 817    case GL_FLOAT_VEC4:
 818    case GL_INT_VEC4:
 819    case GL_BOOL_VEC4:
 820       return 4;
 821    case GL_FLOAT_MAT2:
 822    case GL_FLOAT_MAT2x3:
 823    case GL_FLOAT_MAT2x4:
 824       return 8; /* two float[4] vectors */
 825    case GL_FLOAT_MAT3:
 826    case GL_FLOAT_MAT3x2:
 827    case GL_FLOAT_MAT3x4:
 828       return 12; /* three float[4] vectors */
 829    case GL_FLOAT_MAT4:
 830    case GL_FLOAT_MAT4x2:
 831    case GL_FLOAT_MAT4x3:
 832       return 16;  /* four float[4] vectors */
 833    default:
 834       _mesa_problem(NULL, "Invalid type in _mesa_sizeof_glsl_type()");
 835       return 1;
 836    }
 837 }
 838
 839
 840 static GLboolean
 841 is_boolean_type(GLenum type)
 842 {
 843    switch (type) {
 844    case GL_BOOL:
 845    case GL_BOOL_VEC2:
 846    case GL_BOOL_VEC3:
 847    case GL_BOOL_VEC4:
 848       return GL_TRUE;
 849    default:
 850       return GL_FALSE;
 851    }
 852 }
 853
 854
 855 static GLboolean
 856 is_integer_type(GLenum type)
 857 {
 858    switch (type) {
 859    case GL_INT:
 860    case GL_INT_VEC2:
 861    case GL_INT_VEC3:
 862    case GL_INT_VEC4:
 863       return GL_TRUE;
 864    default:
 865       return GL_FALSE;
 866    }
 867 }
 868
 869
 870 static GLboolean
 871 is_sampler_type(GLenum type)
 872 {
 873    switch (type) {
 874    case GL_SAMPLER_1D:
 875    case GL_SAMPLER_2D:
 876    case GL_SAMPLER_3D:
 877    case GL_SAMPLER_CUBE:
 878    case GL_SAMPLER_1D_SHADOW:
 879    case GL_SAMPLER_2D_SHADOW:
 880    case GL_SAMPLER_2D_RECT_ARB:
 881    case GL_SAMPLER_2D_RECT_SHADOW_ARB:
 882    case GL_SAMPLER_1D_ARRAY_EXT:
 883    case GL_SAMPLER_2D_ARRAY_EXT:
 884    case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:
 885    case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:
 886       return GL_TRUE;
 887    default:
 888       return GL_FALSE;
 889    }
 890 }
 891
 892
 893 static void
 894 _mesa_get_active_attrib(GLcontext *ctx, GLuint program, GLuint index,
 895                         GLsizei maxLength, GLsizei *length, GLint *size,
 896                         GLenum *type, GLchar *nameOut)
 897 {
 898    const struct gl_program_parameter_list *attribs = NULL;
 899    struct gl_shader_program *shProg;
 900
 901    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");
 902    if (!shProg)
 903       return;
 904
 905    if (shProg->VertexProgram)
 906       attribs = shProg->VertexProgram->Base.Attributes;
 907
 908    if (!attribs || index >= attribs->NumParameters) {
 909       _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
 910       return;
 911    }
 912
 913    _mesa_copy_string(nameOut, maxLength, length,
 914                      attribs->Parameters[index].Name);
 915
 916    if (size)
 917       *size = attribs->Parameters[index].Size
 918          / _mesa_sizeof_glsl_type(attribs->Parameters[index].DataType);
 919
 920    if (type)
 921       *type = attribs->Parameters[index].DataType;
 922 }
 923
 924
 925 static struct gl_program_parameter *
 926 get_uniform_parameter(const struct gl_shader_program *shProg, GLuint index)
 927 {
 928    const struct gl_program *prog = NULL;
 929    GLint progPos;
 930
 931    progPos = shProg->Uniforms->Uniforms[index].VertPos;
 932    if (progPos >= 0) {
 933       prog = &shProg->VertexProgram->Base;
 934    }
 935    else {
 936       progPos = shProg->Uniforms->Uniforms[index].FragPos;
 937       if (progPos >= 0) {
 938          prog = &shProg->FragmentProgram->Base;
 939       }
 940    }
 941
 942    if (!prog || progPos < 0)
 943       return NULL; /* should never happen */
 944
 945    return &prog->Parameters->Parameters[progPos];
 946 }
 947
 948
 949 /**
 950  * Called via ctx->Driver.GetActiveUniform().
 951  */
 952 static void
 953 _mesa_get_active_uniform(GLcontext *ctx, GLuint program, GLuint index,
 954                          GLsizei maxLength, GLsizei *length, GLint *size,
 955                          GLenum *type, GLchar *nameOut)
 956 {
 957    const struct gl_shader_program *shProg;
 958    const struct gl_program *prog = NULL;
 959    const struct gl_program_parameter *param;
 960    GLint progPos;
 961
 962    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");
 963    if (!shProg)
 964       return;
 965
 966    if (!shProg->Uniforms || index >= shProg->Uniforms->NumUniforms) {
 967       _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
 968       return;
 969    }
 970
 971    progPos = shProg->Uniforms->Uniforms[index].VertPos;
 972    if (progPos >= 0) {
 973       prog = &shProg->VertexProgram->Base;
 974    }
 975    else {
 976       progPos = shProg->Uniforms->Uniforms[index].FragPos;
 977       if (progPos >= 0) {
 978          prog = &shProg->FragmentProgram->Base;
 979       }
 980    }
 981
 982    if (!prog || progPos < 0)
 983       return; /* should never happen */
 984
 985    ASSERT(progPos < prog->Parameters->NumParameters);
 986    param = &prog->Parameters->Parameters[progPos];
 987
 988    if (nameOut) {
 989       _mesa_copy_string(nameOut, maxLength, length, param->Name);
 990    }
 991
 992    if (size) {
 993       GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
 994       if ((GLint) param->Size > typeSize) {
 995          /* This is an array.
 996           * Array elements are placed on vector[4] boundaries so they're
 997           * a multiple of four floats.  We round typeSize up to next multiple
 998           * of four to get the right size below.
 999           */
1000          typeSize = (typeSize + 3) & ~3;
1001       }
1002       /* Note that the returned size is in units of the <type>, not bytes */
1003       *size = param->Size / typeSize;
1004    }
1005
1006    if (type) {
1007       *type = param->DataType;
1008    }
1009 }
1010
1011
1012 /**
1013  * Called via ctx->Driver.GetAttachedShaders().
1014  */
1015 static void
1016 _mesa_get_attached_shaders(GLcontext *ctx, GLuint program, GLsizei maxCount,
1017                            GLsizei *count, GLuint *obj)
1018 {
1019    struct gl_shader_program *shProg =
1020       _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
1021    if (shProg) {
1022       GLuint i;
1023       for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {
1024          obj[i] = shProg->Shaders[i]->Name;
1025       }
1026       if (count)
1027          *count = i;
1028    }
1029 }
1030
1031
1032 static GLuint
1033 _mesa_get_handle(GLcontext *ctx, GLenum pname)
1034 {
1035    GLint handle = 0;
1036
1037    if (pname == GL_PROGRAM_OBJECT_ARB) {
1038       CALL_GetIntegerv(ctx->Exec, (GL_CURRENT_PROGRAM, &handle));
1039    } else {
1040       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
1041    }
1042
1043    return handle;
1044 }
1045
1046
1047 static void
1048 _mesa_get_programiv(GLcontext *ctx, GLuint program,
1049                     GLenum pname, GLint *params)
1050 {
1051    const struct gl_program_parameter_list *attribs;
1052    struct gl_shader_program *shProg
1053       = _mesa_lookup_shader_program(ctx, program);
1054
1055    if (!shProg) {
1056       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
1057       return;
1058    }
1059
1060    if (shProg->VertexProgram)
1061       attribs = shProg->VertexProgram->Base.Attributes;
1062    else
1063       attribs = NULL;
1064
1065    switch (pname) {
1066    case GL_DELETE_STATUS:
1067       *params = shProg->DeletePending;
1068       break;
1069    case GL_LINK_STATUS:
1070       *params = shProg->LinkStatus;
1071       break;
1072    case GL_VALIDATE_STATUS:
1073       *params = shProg->Validated;
1074       break;
1075    case GL_INFO_LOG_LENGTH:
1076       *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
1077       break;
1078    case GL_ATTACHED_SHADERS:
1079       *params = shProg->NumShaders;
1080       break;
1081    case GL_ACTIVE_ATTRIBUTES:
1082       *params = attribs ? attribs->NumParameters : 0;
1083       break;
1084    case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
1085       *params = _mesa_longest_parameter_name(attribs, PROGRAM_INPUT) + 1;
1086       break;
1087    case GL_ACTIVE_UNIFORMS:
1088       *params = shProg->Uniforms ? shProg->Uniforms->NumUniforms : 0;
1089       break;
1090    case GL_ACTIVE_UNIFORM_MAX_LENGTH:
1091       *params = _mesa_longest_uniform_name(shProg->Uniforms);
1092       if (*params > 0)
1093          (*params)++;  /* add one for terminating zero */
1094       break;
1095    case GL_PROGRAM_BINARY_LENGTH_OES:
1096       *params = 0;
1097       break;
1098 #if FEATURE_EXT_transform_feedback
1099    case GL_TRANSFORM_FEEDBACK_VARYINGS:
1100       *params = shProg->TransformFeedback.NumVarying;
1101       break;
1102    case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
1103       *params = longest_feedback_varying_name(shProg) + 1;
1104       break;
1105    case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
1106       *params = shProg->TransformFeedback.BufferMode;
1107       break;
1108 #endif
1109    default:
1110       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");
1111       return;
1112    }
1113 }
1114
1115
1116 static void
1117 _mesa_get_shaderiv(GLcontext *ctx, GLuint name, GLenum pname, GLint *params)
1118 {
1119    struct gl_shader *shader = _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
1120
1121    if (!shader) {
1122       return;
1123    }
1124
1125    switch (pname) {
1126    case GL_SHADER_TYPE:
1127       *params = shader->Type;
1128       break;
1129    case GL_DELETE_STATUS:
1130       *params = shader->DeletePending;
1131       break;
1132    case GL_COMPILE_STATUS:
1133       *params = shader->CompileStatus;
1134       break;
1135    case GL_INFO_LOG_LENGTH:
1136       *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
1137       break;
1138    case GL_SHADER_SOURCE_LENGTH:
1139       *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
1140       break;
1141    default:
1142       _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
1143       return;
1144    }
1145 }
1146
1147
1148 static void
1149 _mesa_get_program_info_log(GLcontext *ctx, GLuint program, GLsizei bufSize,
1150                            GLsizei *length, GLchar *infoLog)
1151 {
1152    struct gl_shader_program *shProg
1153       = _mesa_lookup_shader_program(ctx, program);
1154    if (!shProg) {
1155       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
1156       return;
1157    }
1158    _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);
1159 }
1160
1161
1162 static void
1163 _mesa_get_shader_info_log(GLcontext *ctx, GLuint shader, GLsizei bufSize,
1164                           GLsizei *length, GLchar *infoLog)
1165 {
1166    struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
1167    if (!sh) {
1168       _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
1169       return;
1170    }
1171    _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);
1172 }
1173
1174
1175 /**
1176  * Called via ctx->Driver.GetShaderSource().
1177  */
1178 static void
1179 _mesa_get_shader_source(GLcontext *ctx, GLuint shader, GLsizei maxLength,
1180                         GLsizei *length, GLchar *sourceOut)
1181 {
1182    struct gl_shader *sh;
1183    sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
1184    if (!sh) {
1185       return;
1186    }
1187    _mesa_copy_string(sourceOut, maxLength, length, sh->Source);
1188 }
1189
1190
1191 static void
1192 get_matrix_dims(GLenum type, GLint *rows, GLint *cols)
1193 {
1194    switch (type) {
1195    case GL_FLOAT_MAT2:
1196       *rows = *cols = 2;
1197       break;
1198    case GL_FLOAT_MAT2x3:
1199       *rows = 3;
1200       *cols = 2;
1201       break;
1202    case GL_FLOAT_MAT2x4:
1203       *rows = 4;
1204       *cols = 2;
1205       break;
1206    case GL_FLOAT_MAT3:
1207       *rows = 3;
1208       *cols = 3;
1209       break;
1210    case GL_FLOAT_MAT3x2:
1211       *rows = 2;
1212       *cols = 3;
1213       break;
1214    case GL_FLOAT_MAT3x4:
1215       *rows = 4;
1216       *cols = 3;
1217       break;
1218    case GL_FLOAT_MAT4:
1219       *rows = 4;
1220       *cols = 4;
1221       break;
1222    case GL_FLOAT_MAT4x2:
1223       *rows = 2;
1224       *cols = 4;
1225       break;
1226    case GL_FLOAT_MAT4x3:
1227       *rows = 3;
1228       *cols = 4;
1229       break;
1230    default:
1231       *rows = *cols = 0;
1232    }
1233 }
1234
1235
1236 /**
1237  * Determine the number of rows and columns occupied by a uniform
1238  * according to its datatype.  For non-matrix types (such as GL_FLOAT_VEC4),
1239  * the number of rows = 1 and cols = number of elements in the vector.
1240  */
1241 static void
1242 get_uniform_rows_cols(const struct gl_program_parameter *p,
1243                       GLint *rows, GLint *cols)
1244 {
1245    get_matrix_dims(p->DataType, rows, cols);
1246    if (*rows == 0 && *cols == 0) {
1247       /* not a matrix type, probably a float or vector */
1248       if (p->Size <= 4) {
1249          *rows = 1;
1250          *cols = p->Size;
1251       }
1252       else {
1253          *rows = p->Size / 4 + 1;
1254          if (p->Size % 4 == 0)
1255             *cols = 4;
1256          else
1257             *cols = p->Size % 4;
1258       }
1259    }
1260 }
1261
1262
1263 /**
1264  * Helper for get_uniform[fi]v() functions.
1265  * Given a shader program name and uniform location, return a pointer
1266  * to the shader program and return the program parameter position.
1267  */
1268 static void
1269 lookup_uniform_parameter(GLcontext *ctx, GLuint program, GLint location,
1270                          struct gl_program **progOut, GLint *paramPosOut)
1271 {
1272    struct gl_shader_program *shProg
1273       = _mesa_lookup_shader_program_err(ctx, program, "glGetUniform[if]v");
1274    struct gl_program *prog = NULL;
1275    GLint progPos = -1;
1276
1277    /* if shProg is NULL, we'll have already recorded an error */
1278
1279    if (shProg) {
1280       if (!shProg->Uniforms ||
1281           location < 0 ||
1282           location >= (GLint) shProg->Uniforms->NumUniforms) {
1283          _mesa_error(ctx, GL_INVALID_OPERATION,  "glGetUniformfv(location)");
1284       }
1285       else {
1286          /* OK, find the gl_program and program parameter location */
1287          progPos = shProg->Uniforms->Uniforms[location].VertPos;
1288          if (progPos >= 0) {
1289             prog = &shProg->VertexProgram->Base;
1290          }
1291          else {
1292             progPos = shProg->Uniforms->Uniforms[location].FragPos;
1293             if (progPos >= 0) {
1294                prog = &shProg->FragmentProgram->Base;
1295             }
1296          }
1297       }
1298    }
1299
1300    *progOut = prog;
1301    *paramPosOut = progPos;
1302 }
1303
1304
1305 /**
1306  * Called via ctx->Driver.GetUniformfv().
1307  */
1308 static void
1309 _mesa_get_uniformfv(GLcontext *ctx, GLuint program, GLint location,
1310                     GLfloat *params)
1311 {
1312    struct gl_program *prog;
1313    GLint paramPos;
1314
1315    lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);
1316
1317    if (prog) {
1318       const struct gl_program_parameter *p =
1319          &prog->Parameters->Parameters[paramPos];
1320       GLint rows, cols, i, j, k;
1321
1322       get_uniform_rows_cols(p, &rows, &cols);
1323
1324       k = 0;
1325       for (i = 0; i < rows; i++) {
1326          for (j = 0; j < cols; j++ ) {
1327             params[k++] = prog->Parameters->ParameterValues[paramPos+i][j];
1328          }
1329       }
1330    }
1331 }
1332
1333
1334 /**
1335  * Called via ctx->Driver.GetUniformiv().
1336  * \sa _mesa_get_uniformfv, only difference is a cast.
1337  */
1338 static void
1339 _mesa_get_uniformiv(GLcontext *ctx, GLuint program, GLint location,
1340                     GLint *params)
1341 {
1342    struct gl_program *prog;
1343    GLint paramPos;
1344
1345    lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);
1346
1347    if (prog) {
1348       const struct gl_program_parameter *p =
1349          &prog->Parameters->Parameters[paramPos];
1350       GLint rows, cols, i, j, k;
1351
1352       get_uniform_rows_cols(p, &rows, &cols);
1353
1354       k = 0;
1355       for (i = 0; i < rows; i++) {
1356          for (j = 0; j < cols; j++ ) {
1357             params[k++] = (GLint) prog->Parameters->ParameterValues[paramPos+i][j];
1358          }
1359       }
1360    }
1361 }
1362
1363
1364 /**
1365  * The value returned by GetUniformLocation actually encodes two things:
1366  * 1. the index into the prog->Uniforms[] array for the uniform
1367  * 2. an offset in the prog->ParameterValues[] array for specifying array
1368  *    elements or structure fields.
1369  * This function merges those two values.
1370  */
1371 static void
1372 merge_location_offset(GLint *location, GLint offset)
1373 {
1374    *location = *location | (offset << 16);
1375 }
1376
1377
1378 /**
1379  * Seperate the uniform location and parameter offset.  See above.
1380  */
1381 static void
1382 split_location_offset(GLint *location, GLint *offset)
1383 {
1384    *offset = (*location >> 16);
1385    *location = *location & 0xffff;
1386 }
1387
1388
1389 /**
1390  * Called via ctx->Driver.GetUniformLocation().
1391  *
1392  * The return value will encode two values, the uniform location and an
1393  * offset (used for arrays, structs).
1394  */
1395 static GLint
1396 _mesa_get_uniform_location(GLcontext *ctx, GLuint program, const GLchar *name)
1397 {
1398    GLint offset = 0, location = -1;
1399
1400    struct gl_shader_program *shProg =
1401       _mesa_lookup_shader_program_err(ctx, program, "glGetUniformLocation");
1402
1403    if (!shProg)
1404       return -1;
1405
1406    if (shProg->LinkStatus == GL_FALSE) {
1407       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(program)");
1408       return -1;
1409    }
1410
1411    /* XXX we should return -1 if the uniform was declared, but not
1412     * actually used.
1413     */
1414
1415    /* XXX we need to be able to parse uniform names for structs and arrays
1416     * such as:
1417     *   mymatrix[1]
1418     *   mystruct.field1
1419     */
1420
1421    {
1422       /* handle 1-dimension arrays here... */
1423       char *c = strchr(name, '[');
1424       if (c) {
1425          /* truncate name at [ */
1426          const GLint len = c - name;
1427          GLchar *newName = malloc(len + 1);
1428          if (!newName)
1429             return -1; /* out of mem */
1430          memcpy(newName, name, len);
1431          newName[len] = 0;
1432
1433          location = _mesa_lookup_uniform(shProg->Uniforms, newName);
1434          if (location >= 0) {
1435             const GLint element = atoi(c + 1);
1436             if (element > 0) {
1437                /* get type of the uniform array element */
1438                struct gl_program_parameter *p;
1439                p = get_uniform_parameter(shProg, location);
1440                if (p) {
1441                   GLint rows, cols;
1442                   get_matrix_dims(p->DataType, &rows, &cols);
1443                   if (rows < 1)
1444                      rows = 1;
1445                   offset = element * rows;
1446                }
1447             }
1448          }
1449
1450          free(newName);
1451       }
1452    }
1453
1454    if (location < 0) {
1455       location = _mesa_lookup_uniform(shProg->Uniforms, name);
1456    }
1457
1458    if (location >= 0) {
1459       merge_location_offset(&location, offset);
1460    }
1461
1462    return location;
1463 }
1464
1465
1466
1467 /**
1468  * Called via ctx->Driver.ShaderSource()
1469  */
1470 static void
1471 _mesa_shader_source(GLcontext *ctx, GLuint shader, const GLchar *source)
1472 {
1473    struct gl_shader *sh;
1474
1475    sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");
1476    if (!sh)
1477       return;
1478
1479    /* free old shader source string and install new one */
1480    if (sh->Source) {
1481       free((void *) sh->Source);
1482    }
1483    sh->Source = source;
1484    sh->CompileStatus = GL_FALSE;
1485 #ifdef DEBUG
1486    sh->SourceChecksum = _mesa_str_checksum(sh->Source);
1487 #endif
1488 }
1489
1490
1491 /**
1492  * Called via ctx->Driver.CompileShader()
1493  */
1494 static void
1495 _mesa_compile_shader(GLcontext *ctx, GLuint shaderObj)
1496 {
1497    struct gl_shader *sh;
1498
1499    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
1500    if (!sh)
1501       return;
1502
1503    /* set default pragma state for shader */
1504    sh->Pragmas = ctx->Shader.DefaultPragmas;
1505
1506    /* this call will set the sh->CompileStatus field to indicate if
1507     * compilation was successful.
1508     */
1509    (void) _slang_compile(ctx, sh);
1510 }
1511
1512
1513 /**
1514  * Called via ctx->Driver.LinkProgram()
1515  */
1516 static void
1517 _mesa_link_program(GLcontext *ctx, GLuint program)
1518 {
1519    struct gl_shader_program *shProg;
1520
1521    shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
1522    if (!shProg)
1523       return;
1524
1525    if (ctx->TransformFeedback.Active && shProg == ctx->Shader.CurrentProgram) {
1526       _mesa_error(ctx, GL_INVALID_OPERATION,
1527                   "glLinkProgram(transform feedback active");
1528       return;
1529    }
1530
1531    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
1532
1533    _slang_link(ctx, program, shProg);
1534
1535    /* debug code */
1536    if (0) {
1537       GLuint i;
1538
1539       printf("Link %u shaders in program %u: %s\n",
1540                    shProg->NumShaders, shProg->Name,
1541                    shProg->LinkStatus ? "Success" : "Failed");
1542
1543       for (i = 0; i < shProg->NumShaders; i++) {
1544          printf(" shader %u, type 0x%x\n",
1545                       shProg->Shaders[i]->Name,
1546                       shProg->Shaders[i]->Type);
1547       }
1548    }
1549 }
1550
1551
1552 /**
1553  * Print basic shader info (for debug).
1554  */
1555 static void
1556 print_shader_info(const struct gl_shader_program *shProg)
1557 {
1558    GLuint i;
1559
1560    printf("Mesa: glUseProgram(%u)\n", shProg->Name);
1561    for (i = 0; i < shProg->NumShaders; i++) {
1562       const char *s;
1563       switch (shProg->Shaders[i]->Type) {
1564       case GL_VERTEX_SHADER:
1565          s = "vertex";
1566          break;
1567       case GL_FRAGMENT_SHADER:
1568          s = "fragment";
1569          break;
1570       case GL_GEOMETRY_SHADER:
1571          s = "geometry";
1572          break;
1573       default:
1574          s = "";
1575       }
1576       printf("  %s shader %u, checksum %u\n", s,
1577              shProg->Shaders[i]->Name,
1578              shProg->Shaders[i]->SourceChecksum);
1579    }
1580    if (shProg->VertexProgram)
1581       printf("  vert prog %u\n", shProg->VertexProgram->Base.Id);
1582    if (shProg->FragmentProgram)
1583       printf("  frag prog %u\n", shProg->FragmentProgram->Base.Id);
1584 }
1585
1586
1587 /**
1588  * Called via ctx->Driver.UseProgram()
1589  */
1590 void
1591 _mesa_use_program(GLcontext *ctx, GLuint program)
1592 {
1593    struct gl_shader_program *shProg;
1594
1595    if (ctx->TransformFeedback.Active) {
1596       _mesa_error(ctx, GL_INVALID_OPERATION,
1597                   "glUseProgram(transform feedback active)");
1598       return;
1599    }
1600
1601    if (ctx->Shader.CurrentProgram &&
1602        ctx->Shader.CurrentProgram->Name == program) {
1603       /* no-op */
1604       return;
1605    }
1606
1607    if (program) {
1608       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1609       if (!shProg) {
1610          return;
1611       }
1612       if (!shProg->LinkStatus) {
1613          _mesa_error(ctx, GL_INVALID_OPERATION,
1614                      "glUseProgram(program %u not linked)", program);
1615          return;
1616       }
1617
1618       /* debug code */
1619       if (ctx->Shader.Flags & GLSL_USE_PROG) {
1620          print_shader_info(shProg);
1621       }
1622    }
1623    else {
1624       shProg = NULL;
1625    }
1626
1627    if (ctx->Shader.CurrentProgram != shProg) {
1628       FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
1629       _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, shProg);
1630    }
1631 }
1632
1633
1634
1635 /**
1636  * Update the vertex/fragment program's TexturesUsed array.
1637  *
1638  * This needs to be called after glUniform(set sampler var) is called.
1639  * A call to glUniform(samplerVar, value) causes a sampler to point to a
1640  * particular texture unit.  We know the sampler's texture target
1641  * (1D/2D/3D/etc) from compile time but the sampler's texture unit is
1642  * set by glUniform() calls.
1643  *
1644  * So, scan the program->SamplerUnits[] and program->SamplerTargets[]
1645  * information to update the prog->TexturesUsed[] values.
1646  * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,
1647  * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.
1648  * We'll use that info for state validation before rendering.
1649  */
1650 void
1651 _mesa_update_shader_textures_used(struct gl_program *prog)
1652 {
1653    GLuint s;
1654
1655    memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed));
1656
1657    for (s = 0; s < MAX_SAMPLERS; s++) {
1658       if (prog->SamplersUsed & (1 << s)) {
1659          GLuint unit = prog->SamplerUnits[s];
1660          GLuint tgt = prog->SamplerTargets[s];
1661          assert(unit < MAX_TEXTURE_IMAGE_UNITS);
1662          assert(tgt < NUM_TEXTURE_TARGETS);
1663          prog->TexturesUsed[unit] |= (1 << tgt);
1664       }
1665    }
1666 }
1667
1668
1669 /**
1670  * Check if the type given by userType is allowed to set a uniform of the
1671  * target type.  Generally, equivalence is required, but setting Boolean
1672  * uniforms can be done with glUniformiv or glUniformfv.
1673  */
1674 static GLboolean
1675 compatible_types(GLenum userType, GLenum targetType)
1676 {
1677    if (userType == targetType)
1678       return GL_TRUE;
1679
1680    if (targetType == GL_BOOL && (userType == GL_FLOAT || userType == GL_INT))
1681       return GL_TRUE;
1682
1683    if (targetType == GL_BOOL_VEC2 && (userType == GL_FLOAT_VEC2 ||
1684                                       userType == GL_INT_VEC2))
1685       return GL_TRUE;
1686
1687    if (targetType == GL_BOOL_VEC3 && (userType == GL_FLOAT_VEC3 ||
1688                                       userType == GL_INT_VEC3))
1689       return GL_TRUE;
1690
1691    if (targetType == GL_BOOL_VEC4 && (userType == GL_FLOAT_VEC4 ||
1692                                       userType == GL_INT_VEC4))
1693       return GL_TRUE;
1694
1695    if (is_sampler_type(targetType) && userType == GL_INT)
1696       return GL_TRUE;
1697
1698    return GL_FALSE;
1699 }
1700
1701
1702 /**
1703  * Set the value of a program's uniform variable.
1704  * \param program  the program whose uniform to update
1705  * \param index  the index of the program parameter for the uniform
1706  * \param offset  additional parameter slot offset (for arrays)
1707  * \param type  the incoming datatype of 'values'
1708  * \param count  the number of uniforms to set
1709  * \param elems  number of elements per uniform (1, 2, 3 or 4)
1710  * \param values  the new values, of datatype 'type'
1711  */
1712 static void
1713 set_program_uniform(GLcontext *ctx, struct gl_program *program,
1714                     GLint index, GLint offset,
1715                     GLenum type, GLsizei count, GLint elems,
1716                     const void *values)
1717 {
1718    const struct gl_program_parameter *param =
1719       &program->Parameters->Parameters[index];
1720
1721    assert(offset >= 0);
1722    assert(elems >= 1);
1723    assert(elems <= 4);
1724
1725    if (!compatible_types(type, param->DataType)) {
1726       _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");
1727       return;
1728    }
1729
1730    if (index + offset > (GLint) program->Parameters->Size) {
1731       /* out of bounds! */
1732       return;
1733    }
1734
1735    if (param->Type == PROGRAM_SAMPLER) {
1736       /* This controls which texture unit which is used by a sampler */
1737       GLboolean changed = GL_FALSE;
1738       GLint i;
1739
1740       /* this should have been caught by the compatible_types() check */
1741       ASSERT(type == GL_INT);
1742
1743       /* loop over number of samplers to change */
1744       for (i = 0; i < count; i++) {
1745          GLuint sampler =
1746             (GLuint) program->Parameters->ParameterValues[index + offset + i][0];
1747          GLuint texUnit = ((GLuint *) values)[i];
1748
1749          /* check that the sampler (tex unit index) is legal */
1750          if (texUnit >= ctx->Const.MaxTextureImageUnits) {
1751             _mesa_error(ctx, GL_INVALID_VALUE,
1752                         "glUniform1(invalid sampler/tex unit index)");
1753             return;
1754          }
1755
1756          /* This maps a sampler to a texture unit: */
1757          if (sampler < MAX_SAMPLERS) {
1758 #if 0
1759             printf("Set program %p sampler %d '%s' to unit %u\n",
1760                    program, sampler, param->Name, texUnit);
1761 #endif
1762             if (program->SamplerUnits[sampler] != texUnit) {
1763                program->SamplerUnits[sampler] = texUnit;
1764                changed = GL_TRUE;
1765             }
1766          }
1767       }
1768
1769       if (changed) {
1770          /* When a sampler's value changes it usually requires rewriting
1771           * a GPU program's TEX instructions since there may not be a
1772           * sampler->texture lookup table.  We signal this with the
1773           * ProgramStringNotify() callback.
1774           */
1775          FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM);
1776          _mesa_update_shader_textures_used(program);
1777          /* Do we need to care about the return value here?
1778           * This should not be the first time the driver was notified of
1779           * this program.
1780           */
1781          (void) ctx->Driver.ProgramStringNotify(ctx, program->Target, program);
1782       }
1783    }
1784    else {
1785       /* ordinary uniform variable */
1786       const GLboolean isUniformBool = is_boolean_type(param->DataType);
1787       const GLboolean areIntValues = is_integer_type(type);
1788       const GLint slots = (param->Size + 3) / 4;
1789       const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
1790       GLsizei k, i;
1791
1792       if ((GLint) param->Size > typeSize) {
1793          /* an array */
1794          /* we'll ignore extra data below */
1795       }
1796       else {
1797          /* non-array: count must be at most one; count == 0 is handled by the loop below */
1798          if (count > 1) {
1799             _mesa_error(ctx, GL_INVALID_OPERATION,
1800                         "glUniform(uniform is not an array)");
1801             return;
1802          }
1803       }
1804
1805       /* loop over number of array elements */
1806       for (k = 0; k < count; k++) {
1807          GLfloat *uniformVal;
1808
1809          if (offset + k >= slots) {
1810             /* Extra array data is ignored */
1811             break;
1812          }
1813
1814          /* uniformVal (the destination) is always float[4] */
1815          uniformVal = program->Parameters->ParameterValues[index + offset + k];
1816
1817          if (areIntValues) {
1818             /* convert user's ints to floats */
1819             const GLint *iValues = ((const GLint *) values) + k * elems;
1820             for (i = 0; i < elems; i++) {
1821                uniformVal[i] = (GLfloat) iValues[i];
1822             }
1823          }
1824          else {
1825             const GLfloat *fValues = ((const GLfloat *) values) + k * elems;
1826             for (i = 0; i < elems; i++) {
1827                uniformVal[i] = fValues[i];
1828             }
1829          }
1830
1831          /* if the uniform is bool-valued, convert to 1.0 or 0.0 */
1832          if (isUniformBool) {
1833             for (i = 0; i < elems; i++) {
1834                uniformVal[i] = uniformVal[i] ? 1.0f : 0.0f;
1835             }
1836          }
1837       }
1838    }
1839 }
1840
1841
1842 /**
1843  * Called via ctx->Driver.Uniform().
1844  */
1845 static void
1846 _mesa_uniform(GLcontext *ctx, GLint location, GLsizei count,
1847               const GLvoid *values, GLenum type)
1848 {
1849    struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
1850    struct gl_uniform *uniform;
1851    GLint elems, offset;
1852    GLenum basicType;
1853
1854    if (!shProg || !shProg->LinkStatus) {
1855       _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");
1856       return;
1857    }
1858
1859    if (location == -1)
1860       return;   /* The standard specifies this as a no-op */
1861
1862    if (location < -1) {
1863       _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(location)");
1864       return;
1865    }
1866
1867    split_location_offset(&location, &offset);
1868
1869    if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {
1870       _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(location)");
1871       return;
1872    }
1873
1874    if (count < 0) {
1875       _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(count < 0)");
1876       return;
1877    }
1878
1879    switch (type) {
1880    case GL_FLOAT:
1881       basicType = GL_FLOAT;
1882       elems = 1;
1883       break;
1884    case GL_INT:
1885       basicType = GL_INT;
1886       elems = 1;
1887       break;
1888    case GL_FLOAT_VEC2:
1889       basicType = GL_FLOAT;
1890       elems = 2;
1891       break;
1892    case GL_INT_VEC2:
1893       basicType = GL_INT;
1894       elems = 2;
1895       break;
1896    case GL_FLOAT_VEC3:
1897       basicType = GL_FLOAT;
1898       elems = 3;
1899       break;
1900    case GL_INT_VEC3:
1901       basicType = GL_INT;
1902       elems = 3;
1903       break;
1904    case GL_FLOAT_VEC4:
1905       basicType = GL_FLOAT;
1906       elems = 4;
1907       break;
1908    case GL_INT_VEC4:
1909       basicType = GL_INT;
1910       elems = 4;
1911       break;
1912    default:
1913       _mesa_problem(ctx, "Invalid type in _mesa_uniform");
1914       return;
1915    }
1916
1917    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
1918
1919    uniform = &shProg->Uniforms->Uniforms[location];
1920
1921    if (ctx->Shader.Flags & GLSL_UNIFORMS) {
1922       GLint i;
1923       printf("Mesa: set program %u uniform %s (loc %d) to: ",
1924              shProg->Name, uniform->Name, location);
1925       if (basicType == GL_INT) {
1926          const GLint *v = (const GLint *) values;
1927          for (i = 0; i < count * elems; i++) {
1928             printf("%d ", v[i]);
1929          }
1930       }
1931       else {
1932          const GLfloat *v = (const GLfloat *) values;
1933          for (i = 0; i < count * elems; i++) {
1934             printf("%g ", v[i]);
1935          }
1936       }
1937       printf("\n");
1938    }
1939
1940    /* A uniform var may be used by both a vertex shader and a fragment
1941     * shader.  We may need to update one or both shader's uniform here:
1942     */
1943    if (shProg->VertexProgram) {
1944       /* convert uniform location to program parameter index */
1945       GLint index = uniform->VertPos;
1946       if (index >= 0) {
1947          set_program_uniform(ctx, &shProg->VertexProgram->Base,
1948                              index, offset, type, count, elems, values);
1949       }
1950    }
1951
1952    if (shProg->FragmentProgram) {
1953       /* convert uniform location to program parameter index */
1954       GLint index = uniform->FragPos;
1955       if (index >= 0) {
1956          set_program_uniform(ctx, &shProg->FragmentProgram->Base,
1957                              index, offset, type, count, elems, values);
1958       }
1959    }
1960
1961    uniform->Initialized = GL_TRUE;
1962 }
1963
1964
1965 /**
1966  * Set a matrix-valued program parameter.
1967  */
1968 static void
1969 set_program_uniform_matrix(GLcontext *ctx, struct gl_program *program,
1970                            GLuint index, GLuint offset,
1971                            GLuint count, GLuint rows, GLuint cols,
1972                            GLboolean transpose, const GLfloat *values)
1973 {
1974    GLuint mat, row, col;
1975    GLuint src = 0;
1976    const struct gl_program_parameter * param = &program->Parameters->Parameters[index];
1977    const GLuint slots = (param->Size + 3) / 4;
1978    const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
1979    GLint nr, nc;
1980
1981    /* check that the number of rows, columns is correct */
1982    get_matrix_dims(param->DataType, &nr, &nc);
1983    if (rows != nr || cols != nc) {
1984       _mesa_error(ctx, GL_INVALID_OPERATION,
1985                   "glUniformMatrix(matrix size mismatch)");
1986       return;
1987    }
1988
1989    if ((GLint) param->Size <= typeSize) {
1990       /* non-array: count must be at most one; count == 0 is handled by the loop below */
1991       if (count > 1) {
1992          _mesa_error(ctx, GL_INVALID_OPERATION,
1993                      "glUniformMatrix(uniform is not an array)");
1994          return;
1995       }
1996    }
1997
1998    /*
1999     * Note: the _columns_ of a matrix are stored in program registers, not
2000     * the rows.  So, the loops below look a little funny.
2001     * XXX could optimize this a bit...
2002     */
2003
2004    /* loop over matrices */
2005    for (mat = 0; mat < count; mat++) {
2006
2007       /* each matrix: */
2008       for (col = 0; col < cols; col++) {
2009          GLfloat *v;
2010          if (offset >= slots) {
2011             /* Ignore writes beyond the end of (the used part of) an array */
2012             return;
2013          }
2014          v = program->Parameters->ParameterValues[index + offset];
2015          for (row = 0; row < rows; row++) {
2016             if (transpose) {
2017                v[row] = values[src + row * cols + col];
2018             }
2019             else {
2020                v[row] = values[src + col * rows + row];
2021             }
2022          }
2023
2024          offset++;
2025       }
2026
2027       src += rows * cols;  /* next matrix */
2028    }
2029 }
2030
2031
2032 /**
2033  * Called by ctx->Driver.UniformMatrix().
2034  * Note: cols=2, rows=4  ==>  array[2] of vec4
2035  */
2036 static void
2037 _mesa_uniform_matrix(GLcontext *ctx, GLint cols, GLint rows,
2038                      GLint location, GLsizei count,
2039                      GLboolean transpose, const GLfloat *values)
2040 {
2041    struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
2042    struct gl_uniform *uniform;
2043    GLint offset;
2044
2045    if (!shProg || !shProg->LinkStatus) {
2046       _mesa_error(ctx, GL_INVALID_OPERATION,
2047          "glUniformMatrix(program not linked)");
2048       return;
2049    }
2050
2051    if (location == -1)
2052       return;   /* The standard specifies this as a no-op */
2053
2054    if (location < -1) {
2055       _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformMatrix(location)");
2056       return;
2057    }
2058
2059    split_location_offset(&location, &offset);
2060
2061    if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {
2062       _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix(location)");
2063       return;
2064    }
2065    if (values == NULL) {
2066       _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix");
2067       return;
2068    }
2069
2070    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
2071
2072    uniform = &shProg->Uniforms->Uniforms[location];
2073
2074    if (shProg->VertexProgram) {
2075       /* convert uniform location to program parameter index */
2076       GLint index = uniform->VertPos;
2077       if (index >= 0) {
2078          set_program_uniform_matrix(ctx, &shProg->VertexProgram->Base,
2079                                     index, offset,
2080                                     count, rows, cols, transpose, values);
2081       }
2082    }
2083
2084    if (shProg->FragmentProgram) {
2085       /* convert uniform location to program parameter index */
2086       GLint index = uniform->FragPos;
2087       if (index >= 0) {
2088          set_program_uniform_matrix(ctx, &shProg->FragmentProgram->Base,
2089                                     index, offset,
2090                                     count, rows, cols, transpose, values);
2091       }
2092    }
2093
2094    uniform->Initialized = GL_TRUE;
2095 }
2096
2097
2098 /**
2099  * Validate a program's samplers.
2100  * Specifically, check that there aren't two samplers of different types
2101  * pointing to the same texture unit.
2102  * \return GL_TRUE if valid, GL_FALSE if invalid
2103  */
2104 static GLboolean
2105 validate_samplers(GLcontext *ctx, const struct gl_program *prog, char *errMsg)
2106 {
2107    static const char *targetName[] = {
2108       "TEXTURE_2D_ARRAY",
2109       "TEXTURE_1D_ARRAY",
2110       "TEXTURE_CUBE",
2111       "TEXTURE_3D",
2112       "TEXTURE_RECT",
2113       "TEXTURE_2D",
2114       "TEXTURE_1D",
2115    };
2116    GLint targetUsed[MAX_TEXTURE_IMAGE_UNITS];
2117    GLbitfield samplersUsed = prog->SamplersUsed;
2118    GLuint i;
2119
2120    assert(Elements(targetName) == NUM_TEXTURE_TARGETS);
2121
2122    if (samplersUsed == 0x0)
2123       return GL_TRUE;
2124
2125    for (i = 0; i < Elements(targetUsed); i++)
2126       targetUsed[i] = -1;
2127
2128    /* walk over bits which are set in 'samplers' */
2129    while (samplersUsed) {
2130       GLuint unit;
2131       gl_texture_index target;
2132       GLint sampler = _mesa_ffs(samplersUsed) - 1;
2133       assert(sampler >= 0);
2134       assert(sampler < MAX_TEXTURE_IMAGE_UNITS);
2135       unit = prog->SamplerUnits[sampler];
2136       target = prog->SamplerTargets[sampler];
2137       if (targetUsed[unit] != -1 && targetUsed[unit] != target) {
2138          _mesa_snprintf(errMsg, 100,
2139                   "Texture unit %d is accessed both as %s and %s",
2140                   unit, targetName[targetUsed[unit]], targetName[target]);
2141          return GL_FALSE;
2142       }
2143       targetUsed[unit] = target;
2144       samplersUsed ^= (1 << sampler);
2145    }
2146
2147    return GL_TRUE;
2148 }
2149
2150
2151 /**
2152  * Do validation of the given shader program.
2153  * \param errMsg  returns error message if validation fails.
2154  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
2155  */
2156 GLboolean
2157 _mesa_validate_shader_program(GLcontext *ctx,
2158                               const struct gl_shader_program *shProg,
2159                               char *errMsg)
2160 {
2161    const struct gl_vertex_program *vp = shProg->VertexProgram;
2162    const struct gl_fragment_program *fp = shProg->FragmentProgram;
2163
2164    if (!shProg->LinkStatus) {
2165       return GL_FALSE;
2166    }
2167
2168    /* From the GL spec, a program is invalid if any of these are true:
2169
2170      any two active samplers in the current program object are of
2171      different types, but refer to the same texture image unit,
2172
2173      any active sampler in the current program object refers to a texture
2174      image unit where fixed-function fragment processing accesses a
2175      texture target that does not match the sampler type, or
2176
2177      the sum of the number of active samplers in the program and the
2178      number of texture image units enabled for fixed-function fragment
2179      processing exceeds the combined limit on the total number of texture
2180      image units allowed.
2181    */
2182
2183
2184    /*
2185     * Check: any two active samplers in the current program object are of
2186     * different types, but refer to the same texture image unit,
2187     */
2188    if (vp && !validate_samplers(ctx, &vp->Base, errMsg)) {
2189       return GL_FALSE;
2190    }
2191    if (fp && !validate_samplers(ctx, &fp->Base, errMsg)) {
2192       return GL_FALSE;
2193    }
2194
2195    return GL_TRUE;
2196 }
2197
2198
2199 /**
2200  * Called via glValidateProgram()
2201  */
2202 static void
2203 _mesa_validate_program(GLcontext *ctx, GLuint program)
2204 {
2205    struct gl_shader_program *shProg;
2206    char errMsg[100];
2207
2208    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
2209    if (!shProg) {
2210       return;
2211    }
2212
2213    shProg->Validated = _mesa_validate_shader_program(ctx, shProg, errMsg);
2214    if (!shProg->Validated) {
2215       /* update info log */
2216       if (shProg->InfoLog) {
2217          free(shProg->InfoLog);
2218       }
2219       shProg->InfoLog = _mesa_strdup(errMsg);
2220    }
2221 }
2222
2223
2224 /**
2225  * Plug in Mesa's GLSL functions into the device driver function table.
2226  */
2227 void
2228 _mesa_init_glsl_driver_functions(struct dd_function_table *driver)
2229 {
2230    driver->AttachShader = _mesa_attach_shader;
2231    driver->BindAttribLocation = _mesa_bind_attrib_location;
2232    driver->CompileShader = _mesa_compile_shader;
2233    driver->CreateProgram = _mesa_create_program;
2234    driver->CreateShader = _mesa_create_shader;
2235    driver->DeleteProgram2 = _mesa_delete_program2;
2236    driver->DeleteShader = _mesa_delete_shader;
2237    driver->DetachShader = _mesa_detach_shader;
2238    driver->GetActiveAttrib = _mesa_get_active_attrib;
2239    driver->GetActiveUniform = _mesa_get_active_uniform;
2240    driver->GetAttachedShaders = _mesa_get_attached_shaders;
2241    driver->GetAttribLocation = _mesa_get_attrib_location;
2242    driver->GetHandle = _mesa_get_handle;
2243    driver->GetProgramiv = _mesa_get_programiv;
2244    driver->GetProgramInfoLog = _mesa_get_program_info_log;
2245    driver->GetShaderiv = _mesa_get_shaderiv;
2246    driver->GetShaderInfoLog = _mesa_get_shader_info_log;
2247    driver->GetShaderSource = _mesa_get_shader_source;
2248    driver->GetUniformfv = _mesa_get_uniformfv;
2249    driver->GetUniformiv = _mesa_get_uniformiv;
2250    driver->GetUniformLocation = _mesa_get_uniform_location;
2251    driver->IsProgram = _mesa_is_program;
2252    driver->IsShader = _mesa_is_shader;
2253    driver->LinkProgram = _mesa_link_program;
2254    driver->ShaderSource = _mesa_shader_source;
2255    driver->Uniform = _mesa_uniform;
2256    driver->UniformMatrix = _mesa_uniform_matrix;
2257    driver->UseProgram = _mesa_use_program;
2258    driver->ValidateProgram = _mesa_validate_program;
2259 }