src/mesa/main/shaderapi.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * \file shaderapi.c
  27  * \author Brian Paul
  28  *
  29  * Implementation of GLSL-related API functions.
  30  * The glUniform* functions are in uniforms.c
  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/dispatch.h"
  42 #include "main/enums.h"
  43 #include "main/hash.h"
  44 #include "main/mfeatures.h"
  45 #include "main/mtypes.h"
  46 #include "main/shaderapi.h"
  47 #include "main/shaderobj.h"
  48 #include "program/program.h"
  49 #include "program/prog_parameter.h"
  50 #include "program/prog_uniform.h"
  51 #include "ralloc.h"
  52 #include <stdbool.h>
  53 #include "../glsl/glsl_parser_extras.h"
  54
  55 /** Define this to enable shader substitution (see below) */
  56 #define SHADER_SUBST 0
  57
  58
  59 /**
  60  * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
  61  */
  62 static GLbitfield
  63 get_shader_flags(void)
  64 {
  65    GLbitfield flags = 0x0;
  66    const char *env = _mesa_getenv("MESA_GLSL");
  67
  68    if (env) {
  69       if (strstr(env, "dump"))
  70          flags |= GLSL_DUMP;
  71       if (strstr(env, "log"))
  72          flags |= GLSL_LOG;
  73       if (strstr(env, "nopvert"))
  74          flags |= GLSL_NOP_VERT;
  75       if (strstr(env, "nopfrag"))
  76          flags |= GLSL_NOP_FRAG;
  77       if (strstr(env, "nopt"))
  78          flags |= GLSL_NO_OPT;
  79       else if (strstr(env, "opt"))
  80          flags |= GLSL_OPT;
  81       if (strstr(env, "uniform"))
  82          flags |= GLSL_UNIFORMS;
  83       if (strstr(env, "useprog"))
  84          flags |= GLSL_USE_PROG;
  85    }
  86
  87    return flags;
  88 }
  89
  90
  91 /**
  92  * Initialize context's shader state.
  93  */
  94 void
  95 _mesa_init_shader_state(struct gl_context *ctx)
  96 {
  97    /* Device drivers may override these to control what kind of instructions
  98     * are generated by the GLSL compiler.
  99     */
 100    struct gl_shader_compiler_options options;
 101    gl_shader_type sh;
 102
 103    memset(&options, 0, sizeof(options));
 104    options.MaxUnrollIterations = 32;
 105
 106    /* Default pragma settings */
 107    options.DefaultPragmas.Optimize = GL_TRUE;
 108
 109    for (sh = 0; sh < MESA_SHADER_TYPES; ++sh)
 110       memcpy(&ctx->ShaderCompilerOptions[sh], &options, sizeof(options));
 111
 112    ctx->Shader.Flags = get_shader_flags();
 113 }
 114
 115
 116 /**
 117  * Free the per-context shader-related state.
 118  */
 119 void
 120 _mesa_free_shader_state(struct gl_context *ctx)
 121 {
 122    _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentVertexProgram, NULL);
 123    _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentGeometryProgram,
 124                                   NULL);
 125    _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentFragmentProgram,
 126                                   NULL);
 127    _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);
 128 }
 129
 130
 131 /**
 132  * Return the size of the given GLSL datatype, in floats (components).
 133  */
 134 GLint
 135 _mesa_sizeof_glsl_type(GLenum type)
 136 {
 137    switch (type) {
 138    case GL_FLOAT:
 139    case GL_INT:
 140    case GL_BOOL:
 141    case GL_SAMPLER_1D:
 142    case GL_SAMPLER_2D:
 143    case GL_SAMPLER_3D:
 144    case GL_SAMPLER_CUBE:
 145    case GL_SAMPLER_1D_SHADOW:
 146    case GL_SAMPLER_2D_SHADOW:
 147    case GL_SAMPLER_2D_RECT_ARB:
 148    case GL_SAMPLER_2D_RECT_SHADOW_ARB:
 149    case GL_SAMPLER_1D_ARRAY_EXT:
 150    case GL_SAMPLER_2D_ARRAY_EXT:
 151    case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:
 152    case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:
 153    case GL_SAMPLER_CUBE_SHADOW_EXT:
 154       return 1;
 155    case GL_FLOAT_VEC2:
 156    case GL_INT_VEC2:
 157    case GL_UNSIGNED_INT_VEC2:
 158    case GL_BOOL_VEC2:
 159       return 2;
 160    case GL_FLOAT_VEC3:
 161    case GL_INT_VEC3:
 162    case GL_UNSIGNED_INT_VEC3:
 163    case GL_BOOL_VEC3:
 164       return 3;
 165    case GL_FLOAT_VEC4:
 166    case GL_INT_VEC4:
 167    case GL_UNSIGNED_INT_VEC4:
 168    case GL_BOOL_VEC4:
 169       return 4;
 170    case GL_FLOAT_MAT2:
 171    case GL_FLOAT_MAT2x3:
 172    case GL_FLOAT_MAT2x4:
 173       return 8; /* two float[4] vectors */
 174    case GL_FLOAT_MAT3:
 175    case GL_FLOAT_MAT3x2:
 176    case GL_FLOAT_MAT3x4:
 177       return 12; /* three float[4] vectors */
 178    case GL_FLOAT_MAT4:
 179    case GL_FLOAT_MAT4x2:
 180    case GL_FLOAT_MAT4x3:
 181       return 16;  /* four float[4] vectors */
 182    default:
 183       _mesa_problem(NULL, "Invalid type in _mesa_sizeof_glsl_type()");
 184       return 1;
 185    }
 186 }
 187
 188
 189 /**
 190  * Copy string from <src> to <dst>, up to maxLength characters, returning
 191  * length of <dst> in <length>.
 192  * \param src  the strings source
 193  * \param maxLength  max chars to copy
 194  * \param length  returns number of chars copied
 195  * \param dst  the string destination
 196  */
 197 void
 198 _mesa_copy_string(GLchar *dst, GLsizei maxLength,
 199                   GLsizei *length, const GLchar *src)
 200 {
 201    GLsizei len;
 202    for (len = 0; len < maxLength - 1 && src && src[len]; len++)
 203       dst[len] = src[len];
 204    if (maxLength > 0)
 205       dst[len] = 0;
 206    if (length)
 207       *length = len;
 208 }
 209
 210
 211
 212 /**
 213  * Confirm that the a shader type is valid and supported by the implementation
 214  *
 215  * \param ctx   Current GL context
 216  * \param type  Shader target
 217  *
 218  */
 219 static bool
 220 validate_shader_target(const struct gl_context *ctx, GLenum type)
 221 {
 222    switch (type) {
 223 #if FEATURE_ARB_fragment_shader
 224    case GL_FRAGMENT_SHADER:
 225       return ctx->Extensions.ARB_fragment_shader;
 226 #endif
 227 #if FEATURE_ARB_vertex_shader
 228    case GL_VERTEX_SHADER:
 229       return ctx->Extensions.ARB_vertex_shader;
 230 #endif
 231 #if FEATURE_ARB_geometry_shader4
 232    case GL_GEOMETRY_SHADER_ARB:
 233       return ctx->Extensions.ARB_geometry_shader4;
 234 #endif
 235    default:
 236       return false;
 237    }
 238 }
 239
 240
 241 /**
 242  * Find the length of the longest transform feedback varying name
 243  * which was specified with glTransformFeedbackVaryings().
 244  */
 245 static GLint
 246 longest_feedback_varying_name(const struct gl_shader_program *shProg)
 247 {
 248    GLuint i;
 249    GLint max = 0;
 250    for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
 251       GLint len = strlen(shProg->TransformFeedback.VaryingNames[i]);
 252       if (len > max)
 253          max = len;
 254    }
 255    return max;
 256 }
 257
 258
 259
 260 static GLboolean
 261 is_program(struct gl_context *ctx, GLuint name)
 262 {
 263    struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
 264    return shProg ? GL_TRUE : GL_FALSE;
 265 }
 266
 267
 268 static GLboolean
 269 is_shader(struct gl_context *ctx, GLuint name)
 270 {
 271    struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
 272    return shader ? GL_TRUE : GL_FALSE;
 273 }
 274
 275
 276 /**
 277  * Attach shader to a shader program.
 278  */
 279 static void
 280 attach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
 281 {
 282    struct gl_shader_program *shProg;
 283    struct gl_shader *sh;
 284    GLuint i, n;
 285
 286    shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");
 287    if (!shProg)
 288       return;
 289
 290    sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");
 291    if (!sh) {
 292       return;
 293    }
 294
 295    n = shProg->NumShaders;
 296    for (i = 0; i < n; i++) {
 297       if (shProg->Shaders[i] == sh) {
 298          /* The shader is already attched to this program.  The
 299           * GL_ARB_shader_objects spec says:
 300           *
 301           *     "The error INVALID_OPERATION is generated by AttachObjectARB
 302           *     if <obj> is already attached to <containerObj>."
 303           */
 304          _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
 305          return;
 306       }
 307    }
 308
 309    /* grow list */
 310    shProg->Shaders = (struct gl_shader **)
 311       _mesa_realloc(shProg->Shaders,
 312                     n * sizeof(struct gl_shader *),
 313                     (n + 1) * sizeof(struct gl_shader *));
 314    if (!shProg->Shaders) {
 315       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
 316       return;
 317    }
 318
 319    /* append */
 320    shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
 321    _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
 322    shProg->NumShaders++;
 323 }
 324
 325
 326 static GLint
 327 get_attrib_location(struct gl_context *ctx, GLuint program, const GLchar *name)
 328 {
 329    struct gl_shader_program *shProg
 330       = _mesa_lookup_shader_program_err(ctx, program, "glGetAttribLocation");
 331
 332    if (!shProg) {
 333       return -1;
 334    }
 335
 336    if (!shProg->LinkStatus) {
 337       _mesa_error(ctx, GL_INVALID_OPERATION,
 338                   "glGetAttribLocation(program not linked)");
 339       return -1;
 340    }
 341
 342    if (!name)
 343       return -1;
 344
 345    if (shProg->VertexProgram) {
 346       const struct gl_program_parameter_list *attribs =
 347          shProg->VertexProgram->Base.Attributes;
 348       if (attribs) {
 349          GLint i = _mesa_lookup_parameter_index(attribs, -1, name);
 350          if (i >= 0) {
 351             return attribs->Parameters[i].StateIndexes[0];
 352          }
 353       }
 354    }
 355    return -1;
 356 }
 357
 358
 359 static void
 360 bind_attrib_location(struct gl_context *ctx, GLuint program, GLuint index,
 361                      const GLchar *name)
 362 {
 363    struct gl_shader_program *shProg;
 364    const GLint size = -1; /* unknown size */
 365    GLint i, oldIndex;
 366    GLenum datatype = GL_FLOAT_VEC4;
 367
 368    shProg = _mesa_lookup_shader_program_err(ctx, program,
 369                                             "glBindAttribLocation");
 370    if (!shProg) {
 371       return;
 372    }
 373
 374    if (!name)
 375       return;
 376
 377    if (strncmp(name, "gl_", 3) == 0) {
 378       _mesa_error(ctx, GL_INVALID_OPERATION,
 379                   "glBindAttribLocation(illegal name)");
 380       return;
 381    }
 382
 383    if (index >= ctx->Const.VertexProgram.MaxAttribs) {
 384       _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(index)");
 385       return;
 386    }
 387
 388    if (shProg->LinkStatus) {
 389       /* get current index/location for the attribute */
 390       oldIndex = get_attrib_location(ctx, program, name);
 391    }
 392    else {
 393       oldIndex = -1;
 394    }
 395
 396    /* this will replace the current value if it's already in the list */
 397    i = _mesa_add_attribute(shProg->Attributes, name, size, datatype, index);
 398    if (i < 0) {
 399       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");
 400       return;
 401    }
 402
 403    /*
 404     * Note that this attribute binding won't go into effect until
 405     * glLinkProgram is called again.
 406     */
 407 }
 408
 409
 410 static void
 411 bind_frag_data_location(struct gl_context *ctx, GLuint program,
 412                         GLuint colorNumber, const GLchar *name)
 413 {
 414    _mesa_problem(ctx, "bind_frag_data_location() not implemented yet");
 415 }
 416
 417
 418 static GLuint
 419 create_shader(struct gl_context *ctx, GLenum type)
 420 {
 421    struct gl_shader *sh;
 422    GLuint name;
 423
 424    if (!validate_shader_target(ctx, type)) {
 425       _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
 426       return 0;
 427    }
 428
 429    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 430    sh = ctx->Driver.NewShader(ctx, name, type);
 431    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
 432
 433    return name;
 434 }
 435
 436
 437 static GLuint
 438 create_shader_program(struct gl_context *ctx)
 439 {
 440    GLuint name;
 441    struct gl_shader_program *shProg;
 442
 443    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 444
 445    shProg = ctx->Driver.NewShaderProgram(ctx, name);
 446
 447    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);
 448
 449    assert(shProg->RefCount == 1);
 450
 451    return name;
 452 }
 453
 454
 455 /**
 456  * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
 457  * DeleteProgramARB.
 458  */
 459 static void
 460 delete_shader_program(struct gl_context *ctx, GLuint name)
 461 {
 462    /*
 463     * NOTE: deleting shaders/programs works a bit differently than
 464     * texture objects (and buffer objects, etc).  Shader/program
 465     * handles/IDs exist in the hash table until the object is really
 466     * deleted (refcount==0).  With texture objects, the handle/ID is
 467     * removed from the hash table in glDeleteTextures() while the tex
 468     * object itself might linger until its refcount goes to zero.
 469     */
 470    struct gl_shader_program *shProg;
 471
 472    shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
 473    if (!shProg)
 474       return;
 475
 476    shProg->DeletePending = GL_TRUE;
 477
 478    /* effectively, decr shProg's refcount */
 479    _mesa_reference_shader_program(ctx, &shProg, NULL);
 480 }
 481
 482
 483 static void
 484 delete_shader(struct gl_context *ctx, GLuint shader)
 485 {
 486    struct gl_shader *sh;
 487
 488    sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
 489    if (!sh)
 490       return;
 491
 492    sh->DeletePending = GL_TRUE;
 493
 494    /* effectively, decr sh's refcount */
 495    _mesa_reference_shader(ctx, &sh, NULL);
 496 }
 497
 498
 499 static void
 500 detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
 501 {
 502    struct gl_shader_program *shProg;
 503    GLuint n;
 504    GLuint i, j;
 505
 506    shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
 507    if (!shProg)
 508       return;
 509
 510    n = shProg->NumShaders;
 511
 512    for (i = 0; i < n; i++) {
 513       if (shProg->Shaders[i]->Name == shader) {
 514          /* found it */
 515          struct gl_shader **newList;
 516
 517          /* release */
 518          _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
 519
 520          /* alloc new, smaller array */
 521          newList = (struct gl_shader **)
 522             malloc((n - 1) * sizeof(struct gl_shader *));
 523          if (!newList) {
 524             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
 525             return;
 526          }
 527          for (j = 0; j < i; j++) {
 528             newList[j] = shProg->Shaders[j];
 529          }
 530          while (++i < n)
 531             newList[j++] = shProg->Shaders[i];
 532          free(shProg->Shaders);
 533
 534          shProg->Shaders = newList;
 535          shProg->NumShaders = n - 1;
 536
 537 #ifdef DEBUG
 538          /* sanity check */
 539          {
 540             for (j = 0; j < shProg->NumShaders; j++) {
 541                assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
 542                       shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
 543                assert(shProg->Shaders[j]->RefCount > 0);
 544             }
 545          }
 546 #endif
 547
 548          return;
 549       }
 550    }
 551
 552    /* not found */
 553    {
 554       GLenum err;
 555       if (is_shader(ctx, shader))
 556          err = GL_INVALID_OPERATION;
 557       else if (is_program(ctx, shader))
 558          err = GL_INVALID_OPERATION;
 559       else
 560          err = GL_INVALID_VALUE;
 561       _mesa_error(ctx, err, "glDetachProgram(shader)");
 562       return;
 563    }
 564 }
 565
 566
 567 static void
 568 get_active_attrib(struct gl_context *ctx, GLuint program, GLuint index,
 569                   GLsizei maxLength, GLsizei *length, GLint *size,
 570                   GLenum *type, GLchar *nameOut)
 571 {
 572    const struct gl_program_parameter_list *attribs = NULL;
 573    struct gl_shader_program *shProg;
 574
 575    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");
 576    if (!shProg)
 577       return;
 578
 579    if (shProg->VertexProgram)
 580       attribs = shProg->VertexProgram->Base.Attributes;
 581
 582    if (!attribs || index >= attribs->NumParameters) {
 583       _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
 584       return;
 585    }
 586
 587    _mesa_copy_string(nameOut, maxLength, length,
 588                      attribs->Parameters[index].Name);
 589
 590    if (size)
 591       *size = attribs->Parameters[index].Size
 592          / _mesa_sizeof_glsl_type(attribs->Parameters[index].DataType);
 593
 594    if (type)
 595       *type = attribs->Parameters[index].DataType;
 596 }
 597
 598
 599 /**
 600  * Return list of shaders attached to shader program.
 601  */
 602 static void
 603 get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,
 604                      GLsizei *count, GLuint *obj)
 605 {
 606    struct gl_shader_program *shProg =
 607       _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
 608    if (shProg) {
 609       GLuint i;
 610       for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {
 611          obj[i] = shProg->Shaders[i]->Name;
 612       }
 613       if (count)
 614          *count = i;
 615    }
 616 }
 617
 618
 619 static GLint
 620 get_frag_data_location(struct gl_context *ctx, GLuint program,
 621                        const GLchar *name)
 622 {
 623    _mesa_problem(ctx, "get_frag_data_location() not implemented yet");
 624    return -1;
 625 }
 626
 627
 628
 629 /**
 630  * glGetHandleARB() - return ID/name of currently bound shader program.
 631  */
 632 static GLuint
 633 get_handle(struct gl_context *ctx, GLenum pname)
 634 {
 635    if (pname == GL_PROGRAM_OBJECT_ARB) {
 636       if (ctx->Shader.ActiveProgram)
 637          return ctx->Shader.ActiveProgram->Name;
 638       else
 639          return 0;
 640    }
 641    else {
 642       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
 643       return 0;
 644    }
 645 }
 646
 647
 648 /**
 649  * glGetProgramiv() - get shader program state.
 650  * Note that this is for GLSL shader programs, not ARB vertex/fragment
 651  * programs (see glGetProgramivARB).
 652  */
 653 static void
 654 get_programiv(struct gl_context *ctx, GLuint program, GLenum pname, GLint *params)
 655 {
 656    const struct gl_program_parameter_list *attribs;
 657    struct gl_shader_program *shProg
 658       = _mesa_lookup_shader_program(ctx, program);
 659
 660    if (!shProg) {
 661       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
 662       return;
 663    }
 664
 665    if (shProg->VertexProgram)
 666       attribs = shProg->VertexProgram->Base.Attributes;
 667    else
 668       attribs = NULL;
 669
 670    switch (pname) {
 671    case GL_DELETE_STATUS:
 672       *params = shProg->DeletePending;
 673       break;
 674    case GL_LINK_STATUS:
 675       *params = shProg->LinkStatus;
 676       break;
 677    case GL_VALIDATE_STATUS:
 678       *params = shProg->Validated;
 679       break;
 680    case GL_INFO_LOG_LENGTH:
 681       *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
 682       break;
 683    case GL_ATTACHED_SHADERS:
 684       *params = shProg->NumShaders;
 685       break;
 686    case GL_ACTIVE_ATTRIBUTES:
 687       *params = attribs ? attribs->NumParameters : 0;
 688       break;
 689    case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
 690       *params = _mesa_longest_parameter_name(attribs, PROGRAM_INPUT) + 1;
 691       break;
 692    case GL_ACTIVE_UNIFORMS:
 693       *params = shProg->Uniforms ? shProg->Uniforms->NumUniforms : 0;
 694       break;
 695    case GL_ACTIVE_UNIFORM_MAX_LENGTH:
 696       *params = _mesa_longest_uniform_name(shProg->Uniforms);
 697       if (*params > 0)
 698          (*params)++;  /* add one for terminating zero */
 699       break;
 700    case GL_PROGRAM_BINARY_LENGTH_OES:
 701       *params = 0;
 702       break;
 703 #if FEATURE_EXT_transform_feedback
 704    case GL_TRANSFORM_FEEDBACK_VARYINGS:
 705       *params = shProg->TransformFeedback.NumVarying;
 706       break;
 707    case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
 708       *params = longest_feedback_varying_name(shProg) + 1;
 709       break;
 710    case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
 711       *params = shProg->TransformFeedback.BufferMode;
 712       break;
 713 #endif
 714 #if FEATURE_ARB_geometry_shader4
 715    case GL_GEOMETRY_VERTICES_OUT_ARB:
 716       *params = shProg->Geom.VerticesOut;
 717       break;
 718    case GL_GEOMETRY_INPUT_TYPE_ARB:
 719       *params = shProg->Geom.InputType;
 720       break;
 721    case GL_GEOMETRY_OUTPUT_TYPE_ARB:
 722       *params = shProg->Geom.OutputType;
 723       break;
 724 #endif
 725    default:
 726       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");
 727       return;
 728    }
 729 }
 730
 731
 732 /**
 733  * glGetShaderiv() - get GLSL shader state
 734  */
 735 static void
 736 get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)
 737 {
 738    struct gl_shader *shader =
 739       _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
 740
 741    if (!shader) {
 742       return;
 743    }
 744
 745    switch (pname) {
 746    case GL_SHADER_TYPE:
 747       *params = shader->Type;
 748       break;
 749    case GL_DELETE_STATUS:
 750       *params = shader->DeletePending;
 751       break;
 752    case GL_COMPILE_STATUS:
 753       *params = shader->CompileStatus;
 754       break;
 755    case GL_INFO_LOG_LENGTH:
 756       *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
 757       break;
 758    case GL_SHADER_SOURCE_LENGTH:
 759       *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
 760       break;
 761    default:
 762       _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
 763       return;
 764    }
 765 }
 766
 767
 768 static void
 769 get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,
 770                      GLsizei *length, GLchar *infoLog)
 771 {
 772    struct gl_shader_program *shProg
 773       = _mesa_lookup_shader_program(ctx, program);
 774    if (!shProg) {
 775       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
 776       return;
 777    }
 778    _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);
 779 }
 780
 781
 782 static void
 783 get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,
 784                     GLsizei *length, GLchar *infoLog)
 785 {
 786    struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
 787    if (!sh) {
 788       _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
 789       return;
 790    }
 791    _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);
 792 }
 793
 794
 795 /**
 796  * Return shader source code.
 797  */
 798 static void
 799 get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,
 800                   GLsizei *length, GLchar *sourceOut)
 801 {
 802    struct gl_shader *sh;
 803    sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
 804    if (!sh) {
 805       return;
 806    }
 807    _mesa_copy_string(sourceOut, maxLength, length, sh->Source);
 808 }
 809
 810
 811 /**
 812  * Set/replace shader source code.
 813  */
 814 static void
 815 shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)
 816 {
 817    struct gl_shader *sh;
 818
 819    sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");
 820    if (!sh)
 821       return;
 822
 823    /* free old shader source string and install new one */
 824    if (sh->Source) {
 825       free((void *) sh->Source);
 826    }
 827    sh->Source = source;
 828    sh->CompileStatus = GL_FALSE;
 829 #ifdef DEBUG
 830    sh->SourceChecksum = _mesa_str_checksum(sh->Source);
 831 #endif
 832 }
 833
 834
 835 /**
 836  * Compile a shader.
 837  */
 838 static void
 839 compile_shader(struct gl_context *ctx, GLuint shaderObj)
 840 {
 841    struct gl_shader *sh;
 842    struct gl_shader_compiler_options *options;
 843
 844    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
 845    if (!sh)
 846       return;
 847
 848    options = &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(sh->Type)];
 849
 850    /* set default pragma state for shader */
 851    sh->Pragmas = options->DefaultPragmas;
 852
 853    /* this call will set the sh->CompileStatus field to indicate if
 854     * compilation was successful.
 855     */
 856    _mesa_glsl_compile_shader(ctx, sh);
 857 }
 858
 859
 860 /**
 861  * Link a program's shaders.
 862  */
 863 static void
 864 link_program(struct gl_context *ctx, GLuint program)
 865 {
 866    struct gl_shader_program *shProg;
 867    struct gl_transform_feedback_object *obj =
 868       ctx->TransformFeedback.CurrentObject;
 869
 870    shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
 871    if (!shProg)
 872       return;
 873
 874    if (obj->Active
 875        && (shProg == ctx->Shader.CurrentVertexProgram
 876            || shProg == ctx->Shader.CurrentGeometryProgram
 877            || shProg == ctx->Shader.CurrentFragmentProgram)) {
 878       _mesa_error(ctx, GL_INVALID_OPERATION,
 879                   "glLinkProgram(transform feedback active");
 880       return;
 881    }
 882
 883    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 884
 885    _mesa_glsl_link_shader(ctx, shProg);
 886
 887    /* debug code */
 888    if (0) {
 889       GLuint i;
 890
 891       printf("Link %u shaders in program %u: %s\n",
 892                    shProg->NumShaders, shProg->Name,
 893                    shProg->LinkStatus ? "Success" : "Failed");
 894
 895       for (i = 0; i < shProg->NumShaders; i++) {
 896          printf(" shader %u, type 0x%x\n",
 897                       shProg->Shaders[i]->Name,
 898                       shProg->Shaders[i]->Type);
 899       }
 900    }
 901 }
 902
 903
 904 /**
 905  * Print basic shader info (for debug).
 906  */
 907 static void
 908 print_shader_info(const struct gl_shader_program *shProg)
 909 {
 910    GLuint i;
 911
 912    printf("Mesa: glUseProgram(%u)\n", shProg->Name);
 913    for (i = 0; i < shProg->NumShaders; i++) {
 914       const char *s;
 915       switch (shProg->Shaders[i]->Type) {
 916       case GL_VERTEX_SHADER:
 917          s = "vertex";
 918          break;
 919       case GL_FRAGMENT_SHADER:
 920          s = "fragment";
 921          break;
 922       case GL_GEOMETRY_SHADER:
 923          s = "geometry";
 924          break;
 925       default:
 926          s = "";
 927       }
 928       printf("  %s shader %u, checksum %u\n", s,
 929              shProg->Shaders[i]->Name,
 930              shProg->Shaders[i]->SourceChecksum);
 931    }
 932    if (shProg->VertexProgram)
 933       printf("  vert prog %u\n", shProg->VertexProgram->Base.Id);
 934    if (shProg->FragmentProgram)
 935       printf("  frag prog %u\n", shProg->FragmentProgram->Base.Id);
 936 }
 937
 938
 939 /**
 940  * Use the named shader program for subsequent glUniform calls
 941  */
 942 void
 943 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
 944                      const char *caller)
 945 {
 946    if ((shProg != NULL) && !shProg->LinkStatus) {
 947       _mesa_error(ctx, GL_INVALID_OPERATION,
 948                   "%s(program %u not linked)", caller, shProg->Name);
 949       return;
 950    }
 951
 952    if (ctx->Shader.ActiveProgram != shProg) {
 953       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
 954    }
 955 }
 956
 957 /**
 958  */
 959 static bool
 960 use_shader_program(struct gl_context *ctx, GLenum type,
 961                    struct gl_shader_program *shProg)
 962 {
 963    struct gl_shader_program **target;
 964
 965    switch (type) {
 966 #if FEATURE_ARB_vertex_shader
 967    case GL_VERTEX_SHADER:
 968       target = &ctx->Shader.CurrentVertexProgram;
 969       if ((shProg == NULL)
 970           || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) {
 971          shProg = NULL;
 972       }
 973       break;
 974 #endif
 975 #if FEATURE_ARB_geometry_shader4
 976    case GL_GEOMETRY_SHADER_ARB:
 977       target = &ctx->Shader.CurrentGeometryProgram;
 978       if ((shProg == NULL)
 979           || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) {
 980          shProg = NULL;
 981       }
 982       break;
 983 #endif
 984 #if FEATURE_ARB_fragment_shader
 985    case GL_FRAGMENT_SHADER:
 986       target = &ctx->Shader.CurrentFragmentProgram;
 987       if ((shProg == NULL)
 988           || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) {
 989          shProg = NULL;
 990       }
 991       break;
 992 #endif
 993    default:
 994       return false;
 995    }
 996
 997    if (*target != shProg) {
 998       FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
 999       _mesa_reference_shader_program(ctx, target, shProg);
1000       return true;
1001    }
1002
1003    return false;
1004 }
1005
1006 /**
1007  * Use the named shader program for subsequent rendering.
1008  */
1009 void
1010 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
1011 {
1012    use_shader_program(ctx, GL_VERTEX_SHADER, shProg);
1013    use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);
1014    use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);
1015    _mesa_active_program(ctx, shProg, "glUseProgram");
1016
1017    if (ctx->Driver.UseProgram)
1018       ctx->Driver.UseProgram(ctx, shProg);
1019 }
1020
1021
1022 /**
1023  * Validate a program's samplers.
1024  * Specifically, check that there aren't two samplers of different types
1025  * pointing to the same texture unit.
1026  * \return GL_TRUE if valid, GL_FALSE if invalid
1027  */
1028 static GLboolean
1029 validate_samplers(const struct gl_program *prog, char *errMsg)
1030 {
1031    static const char *targetName[] = {
1032       "TEXTURE_2D_ARRAY",
1033       "TEXTURE_1D_ARRAY",
1034       "TEXTURE_CUBE",
1035       "TEXTURE_3D",
1036       "TEXTURE_RECT",
1037       "TEXTURE_2D",
1038       "TEXTURE_1D",
1039    };
1040    GLint targetUsed[MAX_TEXTURE_IMAGE_UNITS];
1041    GLbitfield samplersUsed = prog->SamplersUsed;
1042    GLuint i;
1043
1044    assert(Elements(targetName) == NUM_TEXTURE_TARGETS);
1045
1046    if (samplersUsed == 0x0)
1047       return GL_TRUE;
1048
1049    for (i = 0; i < Elements(targetUsed); i++)
1050       targetUsed[i] = -1;
1051
1052    /* walk over bits which are set in 'samplers' */
1053    while (samplersUsed) {
1054       GLuint unit;
1055       gl_texture_index target;
1056       GLint sampler = _mesa_ffs(samplersUsed) - 1;
1057       assert(sampler >= 0);
1058       assert(sampler < MAX_TEXTURE_IMAGE_UNITS);
1059       unit = prog->SamplerUnits[sampler];
1060       target = prog->SamplerTargets[sampler];
1061       if (targetUsed[unit] != -1 && targetUsed[unit] != (int) target) {
1062          _mesa_snprintf(errMsg, 100,
1063                   "Texture unit %d is accessed both as %s and %s",
1064                   unit, targetName[targetUsed[unit]], targetName[target]);
1065          return GL_FALSE;
1066       }
1067       targetUsed[unit] = target;
1068       samplersUsed ^= (1 << sampler);
1069    }
1070
1071    return GL_TRUE;
1072 }
1073
1074
1075 /**
1076  * Do validation of the given shader program.
1077  * \param errMsg  returns error message if validation fails.
1078  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1079  */
1080 static GLboolean
1081 validate_shader_program(const struct gl_shader_program *shProg,
1082                         char *errMsg)
1083 {
1084    const struct gl_vertex_program *vp = shProg->VertexProgram;
1085    const struct gl_fragment_program *fp = shProg->FragmentProgram;
1086
1087    if (!shProg->LinkStatus) {
1088       return GL_FALSE;
1089    }
1090
1091    /* From the GL spec, a program is invalid if any of these are true:
1092
1093      any two active samplers in the current program object are of
1094      different types, but refer to the same texture image unit,
1095
1096      any active sampler in the current program object refers to a texture
1097      image unit where fixed-function fragment processing accesses a
1098      texture target that does not match the sampler type, or
1099
1100      the sum of the number of active samplers in the program and the
1101      number of texture image units enabled for fixed-function fragment
1102      processing exceeds the combined limit on the total number of texture
1103      image units allowed.
1104    */
1105
1106
1107    /*
1108     * Check: any two active samplers in the current program object are of
1109     * different types, but refer to the same texture image unit,
1110     */
1111    if (vp && !validate_samplers(&vp->Base, errMsg)) {
1112       return GL_FALSE;
1113    }
1114    if (fp && !validate_samplers(&fp->Base, errMsg)) {
1115       return GL_FALSE;
1116    }
1117
1118    return GL_TRUE;
1119 }
1120
1121
1122 /**
1123  * Called via glValidateProgram()
1124  */
1125 static void
1126 validate_program(struct gl_context *ctx, GLuint program)
1127 {
1128    struct gl_shader_program *shProg;
1129    char errMsg[100];
1130
1131    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1132    if (!shProg) {
1133       return;
1134    }
1135
1136    shProg->Validated = validate_shader_program(shProg, errMsg);
1137    if (!shProg->Validated) {
1138       /* update info log */
1139       if (shProg->InfoLog) {
1140          ralloc_free(shProg->InfoLog);
1141       }
1142       shProg->InfoLog = ralloc_strdup(shProg, errMsg);
1143    }
1144 }
1145
1146
1147
1148 void GLAPIENTRY
1149 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
1150 {
1151    GET_CURRENT_CONTEXT(ctx);
1152    attach_shader(ctx, program, shader);
1153 }
1154
1155
1156 void GLAPIENTRY
1157 _mesa_AttachShader(GLuint program, GLuint shader)
1158 {
1159    GET_CURRENT_CONTEXT(ctx);
1160    attach_shader(ctx, program, shader);
1161 }
1162
1163
1164 void GLAPIENTRY
1165 _mesa_BindAttribLocationARB(GLhandleARB program, GLuint index,
1166                             const GLcharARB *name)
1167 {
1168    GET_CURRENT_CONTEXT(ctx);
1169    bind_attrib_location(ctx, program, index, name);
1170 }
1171
1172
1173 /* GL_EXT_gpu_shader4, GL3 */
1174 void GLAPIENTRY
1175 _mesa_BindFragDataLocation(GLuint program, GLuint colorNumber,
1176                            const GLchar *name)
1177 {
1178    GET_CURRENT_CONTEXT(ctx);
1179    bind_frag_data_location(ctx, program, colorNumber, name);
1180 }
1181
1182
1183 void GLAPIENTRY
1184 _mesa_CompileShaderARB(GLhandleARB shaderObj)
1185 {
1186    GET_CURRENT_CONTEXT(ctx);
1187    if (MESA_VERBOSE & VERBOSE_API)
1188       _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1189    compile_shader(ctx, shaderObj);
1190 }
1191
1192
1193 GLuint GLAPIENTRY
1194 _mesa_CreateShader(GLenum type)
1195 {
1196    GET_CURRENT_CONTEXT(ctx);
1197    if (MESA_VERBOSE & VERBOSE_API)
1198       _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));
1199    return create_shader(ctx, type);
1200 }
1201
1202
1203 GLhandleARB GLAPIENTRY
1204 _mesa_CreateShaderObjectARB(GLenum type)
1205 {
1206    GET_CURRENT_CONTEXT(ctx);
1207    return create_shader(ctx, type);
1208 }
1209
1210
1211 GLuint GLAPIENTRY
1212 _mesa_CreateProgram(void)
1213 {
1214    GET_CURRENT_CONTEXT(ctx);
1215    if (MESA_VERBOSE & VERBOSE_API)
1216       _mesa_debug(ctx, "glCreateProgram\n");
1217    return create_shader_program(ctx);
1218 }
1219
1220
1221 GLhandleARB GLAPIENTRY
1222 _mesa_CreateProgramObjectARB(void)
1223 {
1224    GET_CURRENT_CONTEXT(ctx);
1225    return create_shader_program(ctx);
1226 }
1227
1228
1229 void GLAPIENTRY
1230 _mesa_DeleteObjectARB(GLhandleARB obj)
1231 {
1232    if (MESA_VERBOSE & VERBOSE_API) {
1233       GET_CURRENT_CONTEXT(ctx);
1234       _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);
1235    }
1236
1237    if (obj) {
1238       GET_CURRENT_CONTEXT(ctx);
1239       FLUSH_VERTICES(ctx, 0);
1240       if (is_program(ctx, obj)) {
1241          delete_shader_program(ctx, obj);
1242       }
1243       else if (is_shader(ctx, obj)) {
1244          delete_shader(ctx, obj);
1245       }
1246       else {
1247          /* error? */
1248       }
1249    }
1250 }
1251
1252
1253 void GLAPIENTRY
1254 _mesa_DeleteProgram(GLuint name)
1255 {
1256    if (name) {
1257       GET_CURRENT_CONTEXT(ctx);
1258       FLUSH_VERTICES(ctx, 0);
1259       delete_shader_program(ctx, name);
1260    }
1261 }
1262
1263
1264 void GLAPIENTRY
1265 _mesa_DeleteShader(GLuint name)
1266 {
1267    if (name) {
1268       GET_CURRENT_CONTEXT(ctx);
1269       FLUSH_VERTICES(ctx, 0);
1270       delete_shader(ctx, name);
1271    }
1272 }
1273
1274
1275 void GLAPIENTRY
1276 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1277 {
1278    GET_CURRENT_CONTEXT(ctx);
1279    detach_shader(ctx, program, shader);
1280 }
1281
1282
1283 void GLAPIENTRY
1284 _mesa_DetachShader(GLuint program, GLuint shader)
1285 {
1286    GET_CURRENT_CONTEXT(ctx);
1287    detach_shader(ctx, program, shader);
1288 }
1289
1290
1291 void GLAPIENTRY
1292 _mesa_GetActiveAttribARB(GLhandleARB program, GLuint index,
1293                          GLsizei maxLength, GLsizei * length, GLint * size,
1294                          GLenum * type, GLcharARB * name)
1295 {
1296    GET_CURRENT_CONTEXT(ctx);
1297    get_active_attrib(ctx, program, index, maxLength, length, size, type, name);
1298 }
1299
1300
1301 void GLAPIENTRY
1302 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1303                             GLsizei * count, GLhandleARB * obj)
1304 {
1305    GET_CURRENT_CONTEXT(ctx);
1306    get_attached_shaders(ctx, container, maxCount, count, obj);
1307 }
1308
1309
1310 void GLAPIENTRY
1311 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1312                          GLsizei *count, GLuint *obj)
1313 {
1314    GET_CURRENT_CONTEXT(ctx);
1315    get_attached_shaders(ctx, program, maxCount, count, obj);
1316 }
1317
1318
1319 GLint GLAPIENTRY
1320 _mesa_GetAttribLocationARB(GLhandleARB program, const GLcharARB * name)
1321 {
1322    GET_CURRENT_CONTEXT(ctx);
1323    return get_attrib_location(ctx, program, name);
1324 }
1325
1326
1327 /* GL_EXT_gpu_shader4, GL3 */
1328 GLint GLAPIENTRY
1329 _mesa_GetFragDataLocation(GLuint program, const GLchar *name)
1330 {
1331    GET_CURRENT_CONTEXT(ctx);
1332    return get_frag_data_location(ctx, program, name);
1333 }
1334
1335
1336
1337 void GLAPIENTRY
1338 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1339                     GLcharARB * infoLog)
1340 {
1341    GET_CURRENT_CONTEXT(ctx);
1342    if (is_program(ctx, object)) {
1343       get_program_info_log(ctx, object, maxLength, length, infoLog);
1344    }
1345    else if (is_shader(ctx, object)) {
1346       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1347    }
1348    else {
1349       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1350    }
1351 }
1352
1353
1354 void GLAPIENTRY
1355 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1356 {
1357    GET_CURRENT_CONTEXT(ctx);
1358    /* Implement in terms of GetProgramiv, GetShaderiv */
1359    if (is_program(ctx, object)) {
1360       if (pname == GL_OBJECT_TYPE_ARB) {
1361          *params = GL_PROGRAM_OBJECT_ARB;
1362       }
1363       else {
1364          get_programiv(ctx, object, pname, params);
1365       }
1366    }
1367    else if (is_shader(ctx, object)) {
1368       if (pname == GL_OBJECT_TYPE_ARB) {
1369          *params = GL_SHADER_OBJECT_ARB;
1370       }
1371       else {
1372          get_shaderiv(ctx, object, pname, params);
1373       }
1374    }
1375    else {
1376       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1377    }
1378 }
1379
1380
1381 void GLAPIENTRY
1382 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1383                               GLfloat *params)
1384 {
1385    GLint iparams[1];  /* XXX is one element enough? */
1386    _mesa_GetObjectParameterivARB(object, pname, iparams);
1387    params[0] = (GLfloat) iparams[0];
1388 }
1389
1390
1391 void GLAPIENTRY
1392 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1393 {
1394    GET_CURRENT_CONTEXT(ctx);
1395    get_programiv(ctx, program, pname, params);
1396 }
1397
1398
1399 void GLAPIENTRY
1400 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1401 {
1402    GET_CURRENT_CONTEXT(ctx);
1403    get_shaderiv(ctx, shader, pname, params);
1404 }
1405
1406
1407 void GLAPIENTRY
1408 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1409                         GLsizei *length, GLchar *infoLog)
1410 {
1411    GET_CURRENT_CONTEXT(ctx);
1412    get_program_info_log(ctx, program, bufSize, length, infoLog);
1413 }
1414
1415
1416 void GLAPIENTRY
1417 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1418                        GLsizei *length, GLchar *infoLog)
1419 {
1420    GET_CURRENT_CONTEXT(ctx);
1421    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1422 }
1423
1424
1425 void GLAPIENTRY
1426 _mesa_GetShaderSourceARB(GLhandleARB shader, GLsizei maxLength,
1427                          GLsizei *length, GLcharARB *sourceOut)
1428 {
1429    GET_CURRENT_CONTEXT(ctx);
1430    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1431 }
1432
1433
1434 GLhandleARB GLAPIENTRY
1435 _mesa_GetHandleARB(GLenum pname)
1436 {
1437    GET_CURRENT_CONTEXT(ctx);
1438    return get_handle(ctx, pname);
1439 }
1440
1441
1442 GLboolean GLAPIENTRY
1443 _mesa_IsProgram(GLuint name)
1444 {
1445    GET_CURRENT_CONTEXT(ctx);
1446    return is_program(ctx, name);
1447 }
1448
1449
1450 GLboolean GLAPIENTRY
1451 _mesa_IsShader(GLuint name)
1452 {
1453    GET_CURRENT_CONTEXT(ctx);
1454    return is_shader(ctx, name);
1455 }
1456
1457
1458 void GLAPIENTRY
1459 _mesa_LinkProgramARB(GLhandleARB programObj)
1460 {
1461    GET_CURRENT_CONTEXT(ctx);
1462    link_program(ctx, programObj);
1463 }
1464
1465
1466
1467 /**
1468  * Read shader source code from a file.
1469  * Useful for debugging to override an app's shader.
1470  */
1471 static GLcharARB *
1472 read_shader(const char *fname)
1473 {
1474    const int max = 50*1000;
1475    FILE *f = fopen(fname, "r");
1476    GLcharARB *buffer, *shader;
1477    int len;
1478
1479    if (!f) {
1480       return NULL;
1481    }
1482
1483    buffer = (char *) malloc(max);
1484    len = fread(buffer, 1, max, f);
1485    buffer[len] = 0;
1486
1487    fclose(f);
1488
1489    shader = _mesa_strdup(buffer);
1490    free(buffer);
1491
1492    return shader;
1493 }
1494
1495
1496 /**
1497  * Called via glShaderSource() and glShaderSourceARB() API functions.
1498  * Basically, concatenate the source code strings into one long string
1499  * and pass it to _mesa_shader_source().
1500  */
1501 void GLAPIENTRY
1502 _mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
1503                       const GLcharARB ** string, const GLint * length)
1504 {
1505    GET_CURRENT_CONTEXT(ctx);
1506    GLint *offsets;
1507    GLsizei i, totalLength;
1508    GLcharARB *source;
1509    GLuint checksum;
1510
1511    if (!shaderObj || string == NULL) {
1512       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1513       return;
1514    }
1515
1516    /*
1517     * This array holds offsets of where the appropriate string ends, thus the
1518     * last element will be set to the total length of the source code.
1519     */
1520    offsets = (GLint *) malloc(count * sizeof(GLint));
1521    if (offsets == NULL) {
1522       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1523       return;
1524    }
1525
1526    for (i = 0; i < count; i++) {
1527       if (string[i] == NULL) {
1528          free((GLvoid *) offsets);
1529          _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderSourceARB(null string)");
1530          return;
1531       }
1532       if (length == NULL || length[i] < 0)
1533          offsets[i] = strlen(string[i]);
1534       else
1535          offsets[i] = length[i];
1536       /* accumulate string lengths */
1537       if (i > 0)
1538          offsets[i] += offsets[i - 1];
1539    }
1540
1541    /* Total length of source string is sum off all strings plus two.
1542     * One extra byte for terminating zero, another extra byte to silence
1543     * valgrind warnings in the parser/grammer code.
1544     */
1545    totalLength = offsets[count - 1] + 2;
1546    source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB));
1547    if (source == NULL) {
1548       free((GLvoid *) offsets);
1549       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1550       return;
1551    }
1552
1553    for (i = 0; i < count; i++) {
1554       GLint start = (i > 0) ? offsets[i - 1] : 0;
1555       memcpy(source + start, string[i],
1556              (offsets[i] - start) * sizeof(GLcharARB));
1557    }
1558    source[totalLength - 1] = '\0';
1559    source[totalLength - 2] = '\0';
1560
1561    if (SHADER_SUBST) {
1562       /* Compute the shader's source code checksum then try to open a file
1563        * named newshader_<CHECKSUM>.  If it exists, use it in place of the
1564        * original shader source code.  For debugging.
1565        */
1566       char filename[100];
1567       GLcharARB *newSource;
1568
1569       checksum = _mesa_str_checksum(source);
1570
1571       _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
1572
1573       newSource = read_shader(filename);
1574       if (newSource) {
1575          fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
1576                        shaderObj, checksum, filename);
1577          free(source);
1578          source = newSource;
1579       }
1580    }
1581
1582    shader_source(ctx, shaderObj, source);
1583
1584    if (SHADER_SUBST) {
1585       struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
1586       if (sh)
1587          sh->SourceChecksum = checksum; /* save original checksum */
1588    }
1589
1590    free(offsets);
1591 }
1592
1593
1594 void GLAPIENTRY
1595 _mesa_UseProgramObjectARB(GLhandleARB program)
1596 {
1597    GET_CURRENT_CONTEXT(ctx);
1598    struct gl_shader_program *shProg;
1599    struct gl_transform_feedback_object *obj =
1600       ctx->TransformFeedback.CurrentObject;
1601
1602    if (obj->Active) {
1603       _mesa_error(ctx, GL_INVALID_OPERATION,
1604                   "glUseProgram(transform feedback active)");
1605       return;
1606    }
1607
1608    if (program) {
1609       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1610       if (!shProg) {
1611          return;
1612       }
1613       if (!shProg->LinkStatus) {
1614          _mesa_error(ctx, GL_INVALID_OPERATION,
1615                      "glUseProgram(program %u not linked)", program);
1616          return;
1617       }
1618
1619       /* debug code */
1620       if (ctx->Shader.Flags & GLSL_USE_PROG) {
1621          print_shader_info(shProg);
1622       }
1623    }
1624    else {
1625       shProg = NULL;
1626    }
1627
1628    _mesa_use_program(ctx, shProg);
1629 }
1630
1631
1632 void GLAPIENTRY
1633 _mesa_ValidateProgramARB(GLhandleARB program)
1634 {
1635    GET_CURRENT_CONTEXT(ctx);
1636    validate_program(ctx, program);
1637 }
1638
1639 #ifdef FEATURE_ES2
1640
1641 void GLAPIENTRY
1642 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1643                                GLint* range, GLint* precision)
1644 {
1645    const struct gl_program_constants *limits;
1646    const struct gl_precision *p;
1647    GET_CURRENT_CONTEXT(ctx);
1648
1649    switch (shadertype) {
1650    case GL_VERTEX_SHADER:
1651       limits = &ctx->Const.VertexProgram;
1652       break;
1653    case GL_FRAGMENT_SHADER:
1654       limits = &ctx->Const.FragmentProgram;
1655       break;
1656    default:
1657       _mesa_error(ctx, GL_INVALID_ENUM,
1658                   "glGetShaderPrecisionFormat(shadertype)");
1659       return;
1660    }
1661
1662    switch (precisiontype) {
1663    case GL_LOW_FLOAT:
1664       p = &limits->LowFloat;
1665       break;
1666    case GL_MEDIUM_FLOAT:
1667       p = &limits->MediumFloat;
1668       break;
1669    case GL_HIGH_FLOAT:
1670       p = &limits->HighFloat;
1671       break;
1672    case GL_LOW_INT:
1673       p = &limits->LowInt;
1674       break;
1675    case GL_MEDIUM_INT:
1676       p = &limits->MediumInt;
1677       break;
1678    case GL_HIGH_INT:
1679       p = &limits->HighInt;
1680       break;
1681    default:
1682       _mesa_error(ctx, GL_INVALID_ENUM,
1683                   "glGetShaderPrecisionFormat(precisiontype)");
1684       return;
1685    }
1686
1687    range[0] = p->RangeMin;
1688    range[1] = p->RangeMax;
1689    precision[0] = p->Precision;
1690 }
1691
1692
1693 void GLAPIENTRY
1694 _mesa_ReleaseShaderCompiler(void)
1695 {
1696    _mesa_destroy_shader_compiler_caches();
1697 }
1698
1699
1700 void GLAPIENTRY
1701 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1702                    const void* binary, GLint length)
1703 {
1704    GET_CURRENT_CONTEXT(ctx);
1705    (void) n;
1706    (void) shaders;
1707    (void) binaryformat;
1708    (void) binary;
1709    (void) length;
1710    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1711 }
1712
1713 #endif /* FEATURE_ES2 */
1714
1715
1716 #if FEATURE_ARB_geometry_shader4
1717
1718 void GLAPIENTRY
1719 _mesa_ProgramParameteriARB(GLuint program, GLenum pname,
1720                            GLint value)
1721 {
1722    struct gl_shader_program *shProg;
1723    GET_CURRENT_CONTEXT(ctx);
1724
1725    ASSERT_OUTSIDE_BEGIN_END(ctx);
1726
1727    shProg = _mesa_lookup_shader_program_err(ctx, program,
1728                                             "glProgramParameteri");
1729    if (!shProg)
1730       return;
1731
1732    switch (pname) {
1733    case GL_GEOMETRY_VERTICES_OUT_ARB:
1734       if (value < 1 ||
1735           (unsigned) value > ctx->Const.GeometryProgram.MaxGeometryOutputVertices) {
1736          _mesa_error(ctx, GL_INVALID_VALUE,
1737                      "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1738                      value);
1739          return;
1740       }
1741       shProg->Geom.VerticesOut = value;
1742       break;
1743    case GL_GEOMETRY_INPUT_TYPE_ARB:
1744       switch (value) {
1745       case GL_POINTS:
1746       case GL_LINES:
1747       case GL_LINES_ADJACENCY_ARB:
1748       case GL_TRIANGLES:
1749       case GL_TRIANGLES_ADJACENCY_ARB:
1750          shProg->Geom.InputType = value;
1751          break;
1752       default:
1753          _mesa_error(ctx, GL_INVALID_VALUE,
1754                      "glProgramParameteri(geometry input type = %s",
1755                      _mesa_lookup_enum_by_nr(value));
1756          return;
1757       }
1758       break;
1759    case GL_GEOMETRY_OUTPUT_TYPE_ARB:
1760       switch (value) {
1761       case GL_POINTS:
1762       case GL_LINE_STRIP:
1763       case GL_TRIANGLE_STRIP:
1764          shProg->Geom.OutputType = value;
1765          break;
1766       default:
1767          _mesa_error(ctx, GL_INVALID_VALUE,
1768                      "glProgramParameteri(geometry output type = %s",
1769                      _mesa_lookup_enum_by_nr(value));
1770          return;
1771       }
1772       break;
1773    default:
1774       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteriARB(pname=%s)",
1775                   _mesa_lookup_enum_by_nr(pname));
1776       break;
1777    }
1778 }
1779
1780 #endif
1781
1782 void
1783 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
1784                          struct gl_shader_program *shProg)
1785 {
1786    use_shader_program(ctx, type, shProg);
1787
1788    if (ctx->Driver.UseProgram)
1789       ctx->Driver.UseProgram(ctx, shProg);
1790 }
1791
1792 void GLAPIENTRY
1793 _mesa_UseShaderProgramEXT(GLenum type, GLuint program)
1794 {
1795    GET_CURRENT_CONTEXT(ctx);
1796    struct gl_shader_program *shProg = NULL;
1797
1798    if (!validate_shader_target(ctx, type)) {
1799       _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");
1800       return;
1801    }
1802
1803    if (ctx->TransformFeedback.CurrentObject->Active) {
1804       _mesa_error(ctx, GL_INVALID_OPERATION,
1805                   "glUseShaderProgramEXT(transform feedback is active)");
1806       return;
1807    }
1808
1809    if (program) {
1810       shProg = _mesa_lookup_shader_program_err(ctx, program,
1811                                                "glUseShaderProgramEXT");
1812       if (shProg == NULL)
1813          return;
1814
1815       if (!shProg->LinkStatus) {
1816          _mesa_error(ctx, GL_INVALID_OPERATION,
1817                      "glUseShaderProgramEXT(program not linked)");
1818          return;
1819       }
1820    }
1821
1822    _mesa_use_shader_program(ctx, type, shProg);
1823 }
1824
1825 void GLAPIENTRY
1826 _mesa_ActiveProgramEXT(GLuint program)
1827 {
1828    GET_CURRENT_CONTEXT(ctx);
1829    struct gl_shader_program *shProg = (program != 0)
1830       ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
1831       : NULL;
1832
1833    _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
1834    return;
1835 }
1836
1837 GLuint GLAPIENTRY
1838 _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
1839 {
1840    GET_CURRENT_CONTEXT(ctx);
1841    const GLuint shader = create_shader(ctx, type);
1842    GLuint program = 0;
1843
1844    if (shader) {
1845       shader_source(ctx, shader, _mesa_strdup(string));
1846       compile_shader(ctx, shader);
1847
1848       program = create_shader_program(ctx);
1849       if (program) {
1850          struct gl_shader_program *shProg;
1851          struct gl_shader *sh;
1852          GLint compiled = GL_FALSE;
1853
1854          shProg = _mesa_lookup_shader_program(ctx, program);
1855          sh = _mesa_lookup_shader(ctx, shader);
1856
1857          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
1858          if (compiled) {
1859             attach_shader(ctx, program, shader);
1860             link_program(ctx, program);
1861             detach_shader(ctx, program, shader);
1862
1863 #if 0
1864             /* Possibly... */
1865             if (active-user-defined-varyings-in-linked-program) {
1866                append-error-to-info-log;
1867                shProg->LinkStatus = GL_FALSE;
1868             }
1869 #endif
1870          }
1871
1872          ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
1873       }
1874
1875       delete_shader(ctx, shader);
1876    }
1877
1878    return program;
1879 }
1880
1881 /**
1882  * Plug in shader-related functions into API dispatch table.
1883  */
1884 void
1885 _mesa_init_shader_dispatch(struct _glapi_table *exec)
1886 {
1887 #if FEATURE_GL
1888    /* GL_ARB_vertex/fragment_shader */
1889    SET_DeleteObjectARB(exec, _mesa_DeleteObjectARB);
1890    SET_GetHandleARB(exec, _mesa_GetHandleARB);
1891    SET_DetachObjectARB(exec, _mesa_DetachObjectARB);
1892    SET_CreateShaderObjectARB(exec, _mesa_CreateShaderObjectARB);
1893    SET_ShaderSourceARB(exec, _mesa_ShaderSourceARB);
1894    SET_CompileShaderARB(exec, _mesa_CompileShaderARB);
1895    SET_CreateProgramObjectARB(exec, _mesa_CreateProgramObjectARB);
1896    SET_AttachObjectARB(exec, _mesa_AttachObjectARB);
1897    SET_LinkProgramARB(exec, _mesa_LinkProgramARB);
1898    SET_UseProgramObjectARB(exec, _mesa_UseProgramObjectARB);
1899    SET_ValidateProgramARB(exec, _mesa_ValidateProgramARB);
1900    SET_GetObjectParameterfvARB(exec, _mesa_GetObjectParameterfvARB);
1901    SET_GetObjectParameterivARB(exec, _mesa_GetObjectParameterivARB);
1902    SET_GetInfoLogARB(exec, _mesa_GetInfoLogARB);
1903    SET_GetAttachedObjectsARB(exec, _mesa_GetAttachedObjectsARB);
1904    SET_GetShaderSourceARB(exec, _mesa_GetShaderSourceARB);
1905
1906    /* OpenGL 2.0 */
1907    SET_AttachShader(exec, _mesa_AttachShader);
1908    SET_CreateProgram(exec, _mesa_CreateProgram);
1909    SET_CreateShader(exec, _mesa_CreateShader);
1910    SET_DeleteProgram(exec, _mesa_DeleteProgram);
1911    SET_DeleteShader(exec, _mesa_DeleteShader);
1912    SET_DetachShader(exec, _mesa_DetachShader);
1913    SET_GetAttachedShaders(exec, _mesa_GetAttachedShaders);
1914    SET_GetProgramiv(exec, _mesa_GetProgramiv);
1915    SET_GetProgramInfoLog(exec, _mesa_GetProgramInfoLog);
1916    SET_GetShaderiv(exec, _mesa_GetShaderiv);
1917    SET_GetShaderInfoLog(exec, _mesa_GetShaderInfoLog);
1918    SET_IsProgram(exec, _mesa_IsProgram);
1919    SET_IsShader(exec, _mesa_IsShader);
1920
1921 #if FEATURE_ARB_vertex_shader
1922    SET_BindAttribLocationARB(exec, _mesa_BindAttribLocationARB);
1923    SET_GetActiveAttribARB(exec, _mesa_GetActiveAttribARB);
1924    SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB);
1925 #endif
1926
1927 #if FEATURE_ARB_geometry_shader4
1928    SET_ProgramParameteriARB(exec, _mesa_ProgramParameteriARB);
1929 #endif
1930
1931    SET_UseShaderProgramEXT(exec, _mesa_UseShaderProgramEXT);
1932    SET_ActiveProgramEXT(exec, _mesa_ActiveProgramEXT);
1933    SET_CreateShaderProgramEXT(exec, _mesa_CreateShaderProgramEXT);
1934
1935    /* GL_EXT_gpu_shader4 / GL 3.0 */
1936    SET_BindFragDataLocationEXT(exec, _mesa_BindFragDataLocation);
1937    SET_GetFragDataLocationEXT(exec, _mesa_GetFragDataLocation);
1938
1939    /* GL_ARB_ES2_compatibility */
1940    SET_ReleaseShaderCompiler(exec, _mesa_ReleaseShaderCompiler);
1941    SET_GetShaderPrecisionFormat(exec, _mesa_GetShaderPrecisionFormat);
1942
1943 #endif /* FEATURE_GL */
1944 }
1945