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  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /**
  27  * \file shaderapi.c
  28  * \author Brian Paul
  29  *
  30  * Implementation of GLSL-related API functions.
  31  * The glUniform* functions are in uniforms.c
  32  *
  33  *
  34  * XXX things to do:
  35  * 1. Check that the right error code is generated for all _mesa_error() calls.
  36  * 2. Insert FLUSH_VERTICES calls in various places
  37  */
  38
  39
  40 #include "main/glheader.h"
  41 #include "main/context.h"
  42 #include "main/dispatch.h"
  43 #include "main/enums.h"
  44 #include "main/hash.h"
  45 #include "main/hash_table.h"
  46 #include "main/mtypes.h"
  47 #include "main/shaderapi.h"
  48 #include "main/shaderobj.h"
  49 #include "main/transformfeedback.h"
  50 #include "main/uniforms.h"
  51 #include "program/program.h"
  52 #include "program/prog_print.h"
  53 #include "program/prog_parameter.h"
  54 #include "ralloc.h"
  55 #include <stdbool.h>
  56 #include "../glsl/glsl_parser_extras.h"
  57 #include "../glsl/ir.h"
  58 #include "../glsl/ir_uniform.h"
  59 #include "../glsl/program.h"
  60
  61 /** Define this to enable shader substitution (see below) */
  62 #define SHADER_SUBST 0
  63
  64
  65 /**
  66  * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
  67  */
  68 static GLbitfield
  69 get_shader_flags(void)
  70 {
  71    GLbitfield flags = 0x0;
  72    const char *env = _mesa_getenv("MESA_GLSL");
  73
  74    if (env) {
  75       if (strstr(env, "dump_on_error"))
  76          flags |= GLSL_DUMP_ON_ERROR;
  77       else if (strstr(env, "dump"))
  78          flags |= GLSL_DUMP;
  79       if (strstr(env, "log"))
  80          flags |= GLSL_LOG;
  81       if (strstr(env, "nopvert"))
  82          flags |= GLSL_NOP_VERT;
  83       if (strstr(env, "nopfrag"))
  84          flags |= GLSL_NOP_FRAG;
  85       if (strstr(env, "nopt"))
  86          flags |= GLSL_NO_OPT;
  87       else if (strstr(env, "opt"))
  88          flags |= GLSL_OPT;
  89       if (strstr(env, "uniform"))
  90          flags |= GLSL_UNIFORMS;
  91       if (strstr(env, "useprog"))
  92          flags |= GLSL_USE_PROG;
  93       if (strstr(env, "errors"))
  94          flags |= GLSL_REPORT_ERRORS;
  95    }
  96
  97    return flags;
  98 }
  99
 100
 101 /**
 102  * Initialize context's shader state.
 103  */
 104 void
 105 _mesa_init_shader_state(struct gl_context *ctx)
 106 {
 107    /* Device drivers may override these to control what kind of instructions
 108     * are generated by the GLSL compiler.
 109     */
 110    struct gl_shader_compiler_options options;
 111    gl_shader_stage sh;
 112
 113    memset(&options, 0, sizeof(options));
 114    options.MaxUnrollIterations = 32;
 115    options.MaxIfDepth = UINT_MAX;
 116
 117    /* Default pragma settings */
 118    options.DefaultPragmas.Optimize = GL_TRUE;
 119
 120    for (sh = 0; sh < MESA_SHADER_STAGES; ++sh)
 121       memcpy(&ctx->ShaderCompilerOptions[sh], &options, sizeof(options));
 122
 123    ctx->Shader.Flags = get_shader_flags();
 124 }
 125
 126
 127 /**
 128  * Free the per-context shader-related state.
 129  */
 130 void
 131 _mesa_free_shader_state(struct gl_context *ctx)
 132 {
 133    int i;
 134    for (i = 0; i < MESA_SHADER_STAGES; i++) {
 135       _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram[i],
 136                                      NULL);
 137    }
 138    _mesa_reference_shader_program(ctx, &ctx->Shader._CurrentFragmentProgram,
 139                                   NULL);
 140    _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);
 141 }
 142
 143
 144 /**
 145  * Copy string from <src> to <dst>, up to maxLength characters, returning
 146  * length of <dst> in <length>.
 147  * \param src  the strings source
 148  * \param maxLength  max chars to copy
 149  * \param length  returns number of chars copied
 150  * \param dst  the string destination
 151  */
 152 void
 153 _mesa_copy_string(GLchar *dst, GLsizei maxLength,
 154                   GLsizei *length, const GLchar *src)
 155 {
 156    GLsizei len;
 157    for (len = 0; len < maxLength - 1 && src && src[len]; len++)
 158       dst[len] = src[len];
 159    if (maxLength > 0)
 160       dst[len] = 0;
 161    if (length)
 162       *length = len;
 163 }
 164
 165
 166
 167 /**
 168  * Confirm that the a shader type is valid and supported by the implementation
 169  *
 170  * \param ctx   Current GL context
 171  * \param type  Shader target
 172  *
 173  */
 174 bool
 175 _mesa_validate_shader_target(const struct gl_context *ctx, GLenum type)
 176 {
 177    /* Note: when building built-in GLSL functions, this function may be
 178     * invoked with ctx == NULL.  In that case, we can only validate that it's
 179     * a shader target we recognize, not that it's supported in the current
 180     * context.  But that's fine--we don't need any further validation than
 181     * that when building built-in GLSL functions.
 182     */
 183
 184    switch (type) {
 185    case GL_FRAGMENT_SHADER:
 186       return ctx == NULL || ctx->Extensions.ARB_fragment_shader;
 187    case GL_VERTEX_SHADER:
 188       return ctx == NULL || ctx->Extensions.ARB_vertex_shader;
 189    case GL_GEOMETRY_SHADER_ARB:
 190       return ctx == NULL || _mesa_has_geometry_shaders(ctx);
 191    case GL_COMPUTE_SHADER:
 192       return ctx == NULL || ctx->Extensions.ARB_compute_shader;
 193    default:
 194       return false;
 195    }
 196 }
 197
 198
 199 static GLboolean
 200 is_program(struct gl_context *ctx, GLuint name)
 201 {
 202    struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
 203    return shProg ? GL_TRUE : GL_FALSE;
 204 }
 205
 206
 207 static GLboolean
 208 is_shader(struct gl_context *ctx, GLuint name)
 209 {
 210    struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
 211    return shader ? GL_TRUE : GL_FALSE;
 212 }
 213
 214
 215 /**
 216  * Attach shader to a shader program.
 217  */
 218 static void
 219 attach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
 220 {
 221    struct gl_shader_program *shProg;
 222    struct gl_shader *sh;
 223    GLuint i, n;
 224
 225    const bool same_type_disallowed = _mesa_is_gles(ctx);
 226
 227    shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");
 228    if (!shProg)
 229       return;
 230
 231    sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");
 232    if (!sh) {
 233       return;
 234    }
 235
 236    n = shProg->NumShaders;
 237    for (i = 0; i < n; i++) {
 238       if (shProg->Shaders[i] == sh) {
 239          /* The shader is already attched to this program.  The
 240           * GL_ARB_shader_objects spec says:
 241           *
 242           *     "The error INVALID_OPERATION is generated by AttachObjectARB
 243           *     if <obj> is already attached to <containerObj>."
 244           */
 245          _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
 246          return;
 247       } else if (same_type_disallowed &&
 248                  shProg->Shaders[i]->Type == sh->Type) {
 249         /* Shader with the same type is already attached to this program,
 250          * OpenGL ES 2.0 and 3.0 specs say:
 251          *
 252          *      "Multiple shader objects of the same type may not be attached
 253          *      to a single program object. [...] The error INVALID_OPERATION
 254          *      is generated if [...] another shader object of the same type
 255          *      as shader is already attached to program."
 256          */
 257          _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
 258          return;
 259       }
 260    }
 261
 262    /* grow list */
 263    shProg->Shaders = (struct gl_shader **)
 264       _mesa_realloc(shProg->Shaders,
 265                     n * sizeof(struct gl_shader *),
 266                     (n + 1) * sizeof(struct gl_shader *));
 267    if (!shProg->Shaders) {
 268       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
 269       return;
 270    }
 271
 272    /* append */
 273    shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
 274    _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
 275    shProg->NumShaders++;
 276 }
 277
 278
 279 static GLuint
 280 create_shader(struct gl_context *ctx, GLenum type)
 281 {
 282    struct gl_shader *sh;
 283    GLuint name;
 284
 285    if (!_mesa_validate_shader_target(ctx, type)) {
 286       _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
 287       return 0;
 288    }
 289
 290    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 291    sh = ctx->Driver.NewShader(ctx, name, type);
 292    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
 293
 294    return name;
 295 }
 296
 297
 298 static GLuint
 299 create_shader_program(struct gl_context *ctx)
 300 {
 301    GLuint name;
 302    struct gl_shader_program *shProg;
 303
 304    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 305
 306    shProg = ctx->Driver.NewShaderProgram(ctx, name);
 307
 308    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);
 309
 310    assert(shProg->RefCount == 1);
 311
 312    return name;
 313 }
 314
 315
 316 /**
 317  * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
 318  * DeleteProgramARB.
 319  */
 320 static void
 321 delete_shader_program(struct gl_context *ctx, GLuint name)
 322 {
 323    /*
 324     * NOTE: deleting shaders/programs works a bit differently than
 325     * texture objects (and buffer objects, etc).  Shader/program
 326     * handles/IDs exist in the hash table until the object is really
 327     * deleted (refcount==0).  With texture objects, the handle/ID is
 328     * removed from the hash table in glDeleteTextures() while the tex
 329     * object itself might linger until its refcount goes to zero.
 330     */
 331    struct gl_shader_program *shProg;
 332
 333    shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
 334    if (!shProg)
 335       return;
 336
 337    if (!shProg->DeletePending) {
 338       shProg->DeletePending = GL_TRUE;
 339
 340       /* effectively, decr shProg's refcount */
 341       _mesa_reference_shader_program(ctx, &shProg, NULL);
 342    }
 343 }
 344
 345
 346 static void
 347 delete_shader(struct gl_context *ctx, GLuint shader)
 348 {
 349    struct gl_shader *sh;
 350
 351    sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
 352    if (!sh)
 353       return;
 354
 355    if (!sh->DeletePending) {
 356       sh->DeletePending = GL_TRUE;
 357
 358       /* effectively, decr sh's refcount */
 359       _mesa_reference_shader(ctx, &sh, NULL);
 360    }
 361 }
 362
 363
 364 static void
 365 detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
 366 {
 367    struct gl_shader_program *shProg;
 368    GLuint n;
 369    GLuint i, j;
 370
 371    shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
 372    if (!shProg)
 373       return;
 374
 375    n = shProg->NumShaders;
 376
 377    for (i = 0; i < n; i++) {
 378       if (shProg->Shaders[i]->Name == shader) {
 379          /* found it */
 380          struct gl_shader **newList;
 381
 382          /* release */
 383          _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
 384
 385          /* alloc new, smaller array */
 386          newList =
 387             malloc((n - 1) * sizeof(struct gl_shader *));
 388          if (!newList) {
 389             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
 390             return;
 391          }
 392          for (j = 0; j < i; j++) {
 393             newList[j] = shProg->Shaders[j];
 394          }
 395          while (++i < n)
 396             newList[j++] = shProg->Shaders[i];
 397          free(shProg->Shaders);
 398
 399          shProg->Shaders = newList;
 400          shProg->NumShaders = n - 1;
 401
 402 #ifdef DEBUG
 403          /* sanity check */
 404          {
 405             for (j = 0; j < shProg->NumShaders; j++) {
 406                assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
 407                       shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
 408                assert(shProg->Shaders[j]->RefCount > 0);
 409             }
 410          }
 411 #endif
 412
 413          return;
 414       }
 415    }
 416
 417    /* not found */
 418    {
 419       GLenum err;
 420       if (is_shader(ctx, shader))
 421          err = GL_INVALID_OPERATION;
 422       else if (is_program(ctx, shader))
 423          err = GL_INVALID_OPERATION;
 424       else
 425          err = GL_INVALID_VALUE;
 426       _mesa_error(ctx, err, "glDetachShader(shader)");
 427       return;
 428    }
 429 }
 430
 431
 432 /**
 433  * Return list of shaders attached to shader program.
 434  */
 435 static void
 436 get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,
 437                      GLsizei *count, GLuint *obj)
 438 {
 439    struct gl_shader_program *shProg =
 440       _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
 441    if (shProg) {
 442       GLuint i;
 443       for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {
 444          obj[i] = shProg->Shaders[i]->Name;
 445       }
 446       if (count)
 447          *count = i;
 448    }
 449 }
 450
 451
 452 /**
 453  * glGetHandleARB() - return ID/name of currently bound shader program.
 454  */
 455 static GLuint
 456 get_handle(struct gl_context *ctx, GLenum pname)
 457 {
 458    if (pname == GL_PROGRAM_OBJECT_ARB) {
 459       if (ctx->Shader.ActiveProgram)
 460          return ctx->Shader.ActiveProgram->Name;
 461       else
 462          return 0;
 463    }
 464    else {
 465       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
 466       return 0;
 467    }
 468 }
 469
 470
 471 /**
 472  * Check if a geometry shader query is valid at this time.  If not, report an
 473  * error and return false.
 474  *
 475  * From GL 3.2 section 6.1.16 (Shader and Program Queries):
 476  *
 477  *     "If GEOMETRY_VERTICES_OUT, GEOMETRY_INPUT_TYPE, or GEOMETRY_OUTPUT_TYPE
 478  *     are queried for a program which has not been linked successfully, or
 479  *     which does not contain objects to form a geometry shader, then an
 480  *     INVALID_OPERATION error is generated."
 481  */
 482 static bool
 483 check_gs_query(struct gl_context *ctx, const struct gl_shader_program *shProg)
 484 {
 485    if (shProg->LinkStatus &&
 486        shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] != NULL) {
 487       return true;
 488    }
 489
 490    _mesa_error(ctx, GL_INVALID_OPERATION,
 491                "glGetProgramv(linked geometry shader required)");
 492    return false;
 493 }
 494
 495
 496 /**
 497  * glGetProgramiv() - get shader program state.
 498  * Note that this is for GLSL shader programs, not ARB vertex/fragment
 499  * programs (see glGetProgramivARB).
 500  */
 501 static void
 502 get_programiv(struct gl_context *ctx, GLuint program, GLenum pname, GLint *params)
 503 {
 504    struct gl_shader_program *shProg
 505       = _mesa_lookup_shader_program(ctx, program);
 506
 507    /* Is transform feedback available in this context?
 508     */
 509    const bool has_xfb =
 510       (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.EXT_transform_feedback)
 511       || ctx->API == API_OPENGL_CORE
 512       || _mesa_is_gles3(ctx);
 513
 514    /* True if geometry shaders (of the form that was adopted into GLSL 1.50
 515     * and GL 3.2) are available in this context
 516     */
 517    const bool has_core_gs = _mesa_is_desktop_gl(ctx) && ctx->Version >= 32;
 518
 519    /* Are uniform buffer objects available in this context?
 520     */
 521    const bool has_ubo =
 522       (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.ARB_uniform_buffer_object)
 523       || ctx->API == API_OPENGL_CORE
 524       || _mesa_is_gles3(ctx);
 525
 526    if (!shProg) {
 527       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
 528       return;
 529    }
 530
 531    switch (pname) {
 532    case GL_DELETE_STATUS:
 533       *params = shProg->DeletePending;
 534       return;
 535    case GL_LINK_STATUS:
 536       *params = shProg->LinkStatus;
 537       return;
 538    case GL_VALIDATE_STATUS:
 539       *params = shProg->Validated;
 540       return;
 541    case GL_INFO_LOG_LENGTH:
 542       *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
 543       return;
 544    case GL_ATTACHED_SHADERS:
 545       *params = shProg->NumShaders;
 546       return;
 547    case GL_ACTIVE_ATTRIBUTES:
 548       *params = _mesa_count_active_attribs(shProg);
 549       return;
 550    case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
 551       *params = _mesa_longest_attribute_name_length(shProg);
 552       return;
 553    case GL_ACTIVE_UNIFORMS:
 554       *params = shProg->NumUserUniformStorage;
 555       return;
 556    case GL_ACTIVE_UNIFORM_MAX_LENGTH: {
 557       unsigned i;
 558       GLint max_len = 0;
 559
 560       for (i = 0; i < shProg->NumUserUniformStorage; i++) {
 561          /* Add one for the terminating NUL character for a non-array, and
 562           * 4 for the "[0]" and the NUL for an array.
 563           */
 564          const GLint len = strlen(shProg->UniformStorage[i].name) + 1 +
 565              ((shProg->UniformStorage[i].array_elements != 0) ? 3 : 0);
 566
 567          if (len > max_len)
 568             max_len = len;
 569       }
 570
 571       *params = max_len;
 572       return;
 573    }
 574    case GL_TRANSFORM_FEEDBACK_VARYINGS:
 575       if (!has_xfb)
 576          break;
 577       *params = shProg->TransformFeedback.NumVarying;
 578       return;
 579    case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: {
 580       unsigned i;
 581       GLint max_len = 0;
 582       if (!has_xfb)
 583          break;
 584
 585       for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
 586          /* Add one for the terminating NUL character.
 587           */
 588          const GLint len = strlen(shProg->TransformFeedback.VaryingNames[i]) + 1;
 589
 590          if (len > max_len)
 591             max_len = len;
 592       }
 593
 594       *params = max_len;
 595       return;
 596    }
 597    case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
 598       if (!has_xfb)
 599          break;
 600       *params = shProg->TransformFeedback.BufferMode;
 601       return;
 602    case GL_GEOMETRY_VERTICES_OUT:
 603       if (!has_core_gs)
 604          break;
 605       if (check_gs_query(ctx, shProg))
 606          *params = shProg->Geom.VerticesOut;
 607       return;
 608    case GL_GEOMETRY_INPUT_TYPE:
 609       if (!has_core_gs)
 610          break;
 611       if (check_gs_query(ctx, shProg))
 612          *params = shProg->Geom.InputType;
 613       return;
 614    case GL_GEOMETRY_OUTPUT_TYPE:
 615       if (!has_core_gs)
 616          break;
 617       if (check_gs_query(ctx, shProg))
 618          *params = shProg->Geom.OutputType;
 619       return;
 620    case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: {
 621       unsigned i;
 622       GLint max_len = 0;
 623
 624       if (!has_ubo)
 625          break;
 626
 627       for (i = 0; i < shProg->NumUniformBlocks; i++) {
 628          /* Add one for the terminating NUL character.
 629           */
 630          const GLint len = strlen(shProg->UniformBlocks[i].Name) + 1;
 631
 632          if (len > max_len)
 633             max_len = len;
 634       }
 635
 636       *params = max_len;
 637       return;
 638    }
 639    case GL_ACTIVE_UNIFORM_BLOCKS:
 640       if (!has_ubo)
 641          break;
 642
 643       *params = shProg->NumUniformBlocks;
 644       return;
 645    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
 646       /* This enum isn't part of the OES extension for OpenGL ES 2.0.  It is
 647        * only available with desktop OpenGL 3.0+ with the
 648        * GL_ARB_get_program_binary extension or OpenGL ES 3.0.
 649        *
 650        * On desktop, we ignore the 3.0+ requirement because it is silly.
 651        */
 652       if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx))
 653          break;
 654
 655       *params = shProg->BinaryRetreivableHint;
 656       return;
 657    case GL_PROGRAM_BINARY_LENGTH:
 658       *params = 0;
 659       return;
 660    case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS:
 661       if (!ctx->Extensions.ARB_shader_atomic_counters)
 662          break;
 663
 664       *params = shProg->NumAtomicBuffers;
 665       return;
 666    default:
 667       break;
 668    }
 669
 670    _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname=%s)",
 671                _mesa_lookup_enum_by_nr(pname));
 672 }
 673
 674
 675 /**
 676  * glGetShaderiv() - get GLSL shader state
 677  */
 678 static void
 679 get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)
 680 {
 681    struct gl_shader *shader =
 682       _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
 683
 684    if (!shader) {
 685       return;
 686    }
 687
 688    switch (pname) {
 689    case GL_SHADER_TYPE:
 690       *params = shader->Type;
 691       break;
 692    case GL_DELETE_STATUS:
 693       *params = shader->DeletePending;
 694       break;
 695    case GL_COMPILE_STATUS:
 696       *params = shader->CompileStatus;
 697       break;
 698    case GL_INFO_LOG_LENGTH:
 699       *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
 700       break;
 701    case GL_SHADER_SOURCE_LENGTH:
 702       *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
 703       break;
 704    default:
 705       _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
 706       return;
 707    }
 708 }
 709
 710
 711 static void
 712 get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,
 713                      GLsizei *length, GLchar *infoLog)
 714 {
 715    struct gl_shader_program *shProg
 716       = _mesa_lookup_shader_program(ctx, program);
 717    if (!shProg) {
 718       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
 719       return;
 720    }
 721    _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);
 722 }
 723
 724
 725 static void
 726 get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,
 727                     GLsizei *length, GLchar *infoLog)
 728 {
 729    struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
 730    if (!sh) {
 731       _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
 732       return;
 733    }
 734    _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);
 735 }
 736
 737
 738 /**
 739  * Return shader source code.
 740  */
 741 static void
 742 get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,
 743                   GLsizei *length, GLchar *sourceOut)
 744 {
 745    struct gl_shader *sh;
 746    sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
 747    if (!sh) {
 748       return;
 749    }
 750    _mesa_copy_string(sourceOut, maxLength, length, sh->Source);
 751 }
 752
 753
 754 /**
 755  * Set/replace shader source code.  A helper function used by
 756  * glShaderSource[ARB] and glCreateShaderProgramEXT.
 757  */
 758 static void
 759 shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)
 760 {
 761    struct gl_shader *sh;
 762
 763    sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");
 764    if (!sh)
 765       return;
 766
 767    /* free old shader source string and install new one */
 768    free((void *)sh->Source);
 769    sh->Source = source;
 770    sh->CompileStatus = GL_FALSE;
 771 #ifdef DEBUG
 772    sh->SourceChecksum = _mesa_str_checksum(sh->Source);
 773 #endif
 774 }
 775
 776
 777 /**
 778  * Compile a shader.
 779  */
 780 static void
 781 compile_shader(struct gl_context *ctx, GLuint shaderObj)
 782 {
 783    struct gl_shader *sh;
 784    struct gl_shader_compiler_options *options;
 785
 786    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
 787    if (!sh)
 788       return;
 789
 790    options = &ctx->ShaderCompilerOptions[sh->Stage];
 791
 792    /* set default pragma state for shader */
 793    sh->Pragmas = options->DefaultPragmas;
 794
 795    if (!sh->Source) {
 796       /* If the user called glCompileShader without first calling
 797        * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
 798        */
 799       sh->CompileStatus = GL_FALSE;
 800    } else {
 801       if (ctx->Shader.Flags & GLSL_DUMP) {
 802          printf("GLSL source for %s shader %d:\n",
 803                 _mesa_shader_stage_to_string(sh->Stage), sh->Name);
 804          printf("%s\n", sh->Source);
 805       }
 806
 807       /* this call will set the shader->CompileStatus field to indicate if
 808        * compilation was successful.
 809        */
 810       _mesa_glsl_compile_shader(ctx, sh, false, false);
 811
 812       if (ctx->Shader.Flags & GLSL_LOG) {
 813          _mesa_write_shader_to_file(sh);
 814       }
 815
 816       if (ctx->Shader.Flags & GLSL_DUMP) {
 817          if (sh->CompileStatus) {
 818             printf("GLSL IR for shader %d:\n", sh->Name);
 819             _mesa_print_ir(sh->ir, NULL);
 820             printf("\n\n");
 821          } else {
 822             printf("GLSL shader %d failed to compile.\n", sh->Name);
 823          }
 824          if (sh->InfoLog && sh->InfoLog[0] != 0) {
 825             printf("GLSL shader %d info log:\n", sh->Name);
 826             printf("%s\n", sh->InfoLog);
 827          }
 828       }
 829
 830    }
 831
 832    if (!sh->CompileStatus) {
 833       if (ctx->Shader.Flags & GLSL_DUMP_ON_ERROR) {
 834          fprintf(stderr, "GLSL source for %s shader %d:\n",
 835                  _mesa_shader_stage_to_string(sh->Stage), sh->Name);
 836          fprintf(stderr, "%s\n", sh->Source);
 837          fprintf(stderr, "Info Log:\n%s\n", sh->InfoLog);
 838          fflush(stderr);
 839       }
 840
 841       if (ctx->Shader.Flags & GLSL_REPORT_ERRORS) {
 842          _mesa_debug(ctx, "Error compiling shader %u:\n%s\n",
 843                      sh->Name, sh->InfoLog);
 844       }
 845    }
 846 }
 847
 848
 849 /**
 850  * Link a program's shaders.
 851  */
 852 static void
 853 link_program(struct gl_context *ctx, GLuint program)
 854 {
 855    struct gl_shader_program *shProg;
 856
 857    shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
 858    if (!shProg)
 859       return;
 860
 861    /* From the ARB_transform_feedback2 specification:
 862     * "The error INVALID_OPERATION is generated by LinkProgram if <program> is
 863     *  the name of a program being used by one or more transform feedback
 864     *  objects, even if the objects are not currently bound or are paused."
 865     */
 866    if (_mesa_transform_feedback_is_using_program(ctx, shProg)) {
 867       _mesa_error(ctx, GL_INVALID_OPERATION,
 868                   "glLinkProgram(transform feedback is using the program)");
 869       return;
 870    }
 871
 872    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 873
 874    _mesa_glsl_link_shader(ctx, shProg);
 875
 876    if (shProg->LinkStatus == GL_FALSE &&
 877        (ctx->Shader.Flags & GLSL_REPORT_ERRORS)) {
 878       _mesa_debug(ctx, "Error linking program %u:\n%s\n",
 879                   shProg->Name, shProg->InfoLog);
 880    }
 881
 882    /* debug code */
 883    if (0) {
 884       GLuint i;
 885
 886       printf("Link %u shaders in program %u: %s\n",
 887                    shProg->NumShaders, shProg->Name,
 888                    shProg->LinkStatus ? "Success" : "Failed");
 889
 890       for (i = 0; i < shProg->NumShaders; i++) {
 891          printf(" shader %u, type 0x%x\n",
 892                       shProg->Shaders[i]->Name,
 893                       shProg->Shaders[i]->Type);
 894       }
 895    }
 896 }
 897
 898
 899 /**
 900  * Print basic shader info (for debug).
 901  */
 902 static void
 903 print_shader_info(const struct gl_shader_program *shProg)
 904 {
 905    GLuint i;
 906
 907    printf("Mesa: glUseProgram(%u)\n", shProg->Name);
 908    for (i = 0; i < shProg->NumShaders; i++) {
 909       printf("  %s shader %u, checksum %u\n",
 910              _mesa_shader_stage_to_string(shProg->Shaders[i]->Stage),
 911              shProg->Shaders[i]->Name,
 912              shProg->Shaders[i]->SourceChecksum);
 913    }
 914    if (shProg->_LinkedShaders[MESA_SHADER_VERTEX])
 915       printf("  vert prog %u\n",
 916              shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program->Id);
 917    if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT])
 918       printf("  frag prog %u\n",
 919              shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program->Id);
 920    if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY])
 921       printf("  geom prog %u\n",
 922              shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program->Id);
 923 }
 924
 925
 926 /**
 927  * Use the named shader program for subsequent glUniform calls
 928  */
 929 void
 930 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
 931                      const char *caller)
 932 {
 933    if ((shProg != NULL) && !shProg->LinkStatus) {
 934       _mesa_error(ctx, GL_INVALID_OPERATION,
 935                   "%s(program %u not linked)", caller, shProg->Name);
 936       return;
 937    }
 938
 939    if (ctx->Shader.ActiveProgram != shProg) {
 940       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
 941    }
 942 }
 943
 944 /**
 945  */
 946 static void
 947 use_shader_program(struct gl_context *ctx, GLenum type,
 948                    struct gl_shader_program *shProg)
 949 {
 950    struct gl_shader_program **target;
 951    gl_shader_stage stage = _mesa_shader_enum_to_shader_stage(type);
 952
 953    target = &ctx->Shader.CurrentProgram[stage];
 954    if ((shProg == NULL) || (shProg->_LinkedShaders[stage] == NULL))
 955       shProg = NULL;
 956
 957    if (*target != shProg) {
 958       FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
 959
 960       /* If the shader is also bound as the current rendering shader, unbind
 961        * it from that binding point as well.  This ensures that the correct
 962        * semantics of glDeleteProgram are maintained.
 963        */
 964       switch (type) {
 965       case GL_VERTEX_SHADER:
 966          /* Empty for now. */
 967          break;
 968       case GL_GEOMETRY_SHADER_ARB:
 969          /* Empty for now. */
 970          break;
 971       case GL_COMPUTE_SHADER:
 972          /* Empty for now. */
 973          break;
 974       case GL_FRAGMENT_SHADER:
 975          if (*target == ctx->Shader._CurrentFragmentProgram) {
 976             _mesa_reference_shader_program(ctx,
 977                                            &ctx->Shader._CurrentFragmentProgram,
 978                                            NULL);
 979          }
 980          break;
 981       }
 982
 983       _mesa_reference_shader_program(ctx, target, shProg);
 984       return;
 985    }
 986 }
 987
 988 /**
 989  * Use the named shader program for subsequent rendering.
 990  */
 991 void
 992 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
 993 {
 994    use_shader_program(ctx, GL_VERTEX_SHADER, shProg);
 995    use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);
 996    use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);
 997    _mesa_active_program(ctx, shProg, "glUseProgram");
 998
 999    if (ctx->Driver.UseProgram)
1000       ctx->Driver.UseProgram(ctx, shProg);
1001 }
1002
1003
1004 /**
1005  * Do validation of the given shader program.
1006  * \param errMsg  returns error message if validation fails.
1007  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1008  */
1009 static GLboolean
1010 validate_shader_program(const struct gl_shader_program *shProg,
1011                         char *errMsg)
1012 {
1013    if (!shProg->LinkStatus) {
1014       return GL_FALSE;
1015    }
1016
1017    /* From the GL spec, a program is invalid if any of these are true:
1018
1019      any two active samplers in the current program object are of
1020      different types, but refer to the same texture image unit,
1021
1022      any active sampler in the current program object refers to a texture
1023      image unit where fixed-function fragment processing accesses a
1024      texture target that does not match the sampler type, or
1025
1026      the sum of the number of active samplers in the program and the
1027      number of texture image units enabled for fixed-function fragment
1028      processing exceeds the combined limit on the total number of texture
1029      image units allowed.
1030    */
1031
1032
1033    /*
1034     * Check: any two active samplers in the current program object are of
1035     * different types, but refer to the same texture image unit,
1036     */
1037    if (!_mesa_sampler_uniforms_are_valid(shProg, errMsg, 100))
1038       return GL_FALSE;
1039
1040    return GL_TRUE;
1041 }
1042
1043
1044 /**
1045  * Called via glValidateProgram()
1046  */
1047 static void
1048 validate_program(struct gl_context *ctx, GLuint program)
1049 {
1050    struct gl_shader_program *shProg;
1051    char errMsg[100] = "";
1052
1053    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1054    if (!shProg) {
1055       return;
1056    }
1057
1058    shProg->Validated = validate_shader_program(shProg, errMsg);
1059    if (!shProg->Validated) {
1060       /* update info log */
1061       if (shProg->InfoLog) {
1062          ralloc_free(shProg->InfoLog);
1063       }
1064       shProg->InfoLog = ralloc_strdup(shProg, errMsg);
1065    }
1066 }
1067
1068
1069
1070 void GLAPIENTRY
1071 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
1072 {
1073    GET_CURRENT_CONTEXT(ctx);
1074    attach_shader(ctx, program, shader);
1075 }
1076
1077
1078 void GLAPIENTRY
1079 _mesa_AttachShader(GLuint program, GLuint shader)
1080 {
1081    GET_CURRENT_CONTEXT(ctx);
1082    attach_shader(ctx, program, shader);
1083 }
1084
1085
1086 void GLAPIENTRY
1087 _mesa_CompileShader(GLhandleARB shaderObj)
1088 {
1089    GET_CURRENT_CONTEXT(ctx);
1090    if (MESA_VERBOSE & VERBOSE_API)
1091       _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1092    compile_shader(ctx, shaderObj);
1093 }
1094
1095
1096 GLuint GLAPIENTRY
1097 _mesa_CreateShader(GLenum type)
1098 {
1099    GET_CURRENT_CONTEXT(ctx);
1100    if (MESA_VERBOSE & VERBOSE_API)
1101       _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));
1102    return create_shader(ctx, type);
1103 }
1104
1105
1106 GLhandleARB GLAPIENTRY
1107 _mesa_CreateShaderObjectARB(GLenum type)
1108 {
1109    GET_CURRENT_CONTEXT(ctx);
1110    return create_shader(ctx, type);
1111 }
1112
1113
1114 GLuint GLAPIENTRY
1115 _mesa_CreateProgram(void)
1116 {
1117    GET_CURRENT_CONTEXT(ctx);
1118    if (MESA_VERBOSE & VERBOSE_API)
1119       _mesa_debug(ctx, "glCreateProgram\n");
1120    return create_shader_program(ctx);
1121 }
1122
1123
1124 GLhandleARB GLAPIENTRY
1125 _mesa_CreateProgramObjectARB(void)
1126 {
1127    GET_CURRENT_CONTEXT(ctx);
1128    return create_shader_program(ctx);
1129 }
1130
1131
1132 void GLAPIENTRY
1133 _mesa_DeleteObjectARB(GLhandleARB obj)
1134 {
1135    if (MESA_VERBOSE & VERBOSE_API) {
1136       GET_CURRENT_CONTEXT(ctx);
1137       _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);
1138    }
1139
1140    if (obj) {
1141       GET_CURRENT_CONTEXT(ctx);
1142       FLUSH_VERTICES(ctx, 0);
1143       if (is_program(ctx, obj)) {
1144          delete_shader_program(ctx, obj);
1145       }
1146       else if (is_shader(ctx, obj)) {
1147          delete_shader(ctx, obj);
1148       }
1149       else {
1150          /* error? */
1151       }
1152    }
1153 }
1154
1155
1156 void GLAPIENTRY
1157 _mesa_DeleteProgram(GLuint name)
1158 {
1159    if (name) {
1160       GET_CURRENT_CONTEXT(ctx);
1161       FLUSH_VERTICES(ctx, 0);
1162       delete_shader_program(ctx, name);
1163    }
1164 }
1165
1166
1167 void GLAPIENTRY
1168 _mesa_DeleteShader(GLuint name)
1169 {
1170    if (name) {
1171       GET_CURRENT_CONTEXT(ctx);
1172       FLUSH_VERTICES(ctx, 0);
1173       delete_shader(ctx, name);
1174    }
1175 }
1176
1177
1178 void GLAPIENTRY
1179 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1180 {
1181    GET_CURRENT_CONTEXT(ctx);
1182    detach_shader(ctx, program, shader);
1183 }
1184
1185
1186 void GLAPIENTRY
1187 _mesa_DetachShader(GLuint program, GLuint shader)
1188 {
1189    GET_CURRENT_CONTEXT(ctx);
1190    detach_shader(ctx, program, shader);
1191 }
1192
1193
1194 void GLAPIENTRY
1195 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1196                             GLsizei * count, GLhandleARB * obj)
1197 {
1198    GET_CURRENT_CONTEXT(ctx);
1199    get_attached_shaders(ctx, container, maxCount, count, obj);
1200 }
1201
1202
1203 void GLAPIENTRY
1204 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1205                          GLsizei *count, GLuint *obj)
1206 {
1207    GET_CURRENT_CONTEXT(ctx);
1208    get_attached_shaders(ctx, program, maxCount, count, obj);
1209 }
1210
1211
1212 void GLAPIENTRY
1213 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1214                     GLcharARB * infoLog)
1215 {
1216    GET_CURRENT_CONTEXT(ctx);
1217    if (is_program(ctx, object)) {
1218       get_program_info_log(ctx, object, maxLength, length, infoLog);
1219    }
1220    else if (is_shader(ctx, object)) {
1221       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1222    }
1223    else {
1224       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1225    }
1226 }
1227
1228
1229 void GLAPIENTRY
1230 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1231 {
1232    GET_CURRENT_CONTEXT(ctx);
1233    /* Implement in terms of GetProgramiv, GetShaderiv */
1234    if (is_program(ctx, object)) {
1235       if (pname == GL_OBJECT_TYPE_ARB) {
1236          *params = GL_PROGRAM_OBJECT_ARB;
1237       }
1238       else {
1239          get_programiv(ctx, object, pname, params);
1240       }
1241    }
1242    else if (is_shader(ctx, object)) {
1243       if (pname == GL_OBJECT_TYPE_ARB) {
1244          *params = GL_SHADER_OBJECT_ARB;
1245       }
1246       else {
1247          get_shaderiv(ctx, object, pname, params);
1248       }
1249    }
1250    else {
1251       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1252    }
1253 }
1254
1255
1256 void GLAPIENTRY
1257 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1258                               GLfloat *params)
1259 {
1260    GLint iparams[1];  /* XXX is one element enough? */
1261    _mesa_GetObjectParameterivARB(object, pname, iparams);
1262    params[0] = (GLfloat) iparams[0];
1263 }
1264
1265
1266 void GLAPIENTRY
1267 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1268 {
1269    GET_CURRENT_CONTEXT(ctx);
1270    get_programiv(ctx, program, pname, params);
1271 }
1272
1273
1274 void GLAPIENTRY
1275 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1276 {
1277    GET_CURRENT_CONTEXT(ctx);
1278    get_shaderiv(ctx, shader, pname, params);
1279 }
1280
1281
1282 void GLAPIENTRY
1283 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1284                         GLsizei *length, GLchar *infoLog)
1285 {
1286    GET_CURRENT_CONTEXT(ctx);
1287    get_program_info_log(ctx, program, bufSize, length, infoLog);
1288 }
1289
1290
1291 void GLAPIENTRY
1292 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1293                        GLsizei *length, GLchar *infoLog)
1294 {
1295    GET_CURRENT_CONTEXT(ctx);
1296    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1297 }
1298
1299
1300 void GLAPIENTRY
1301 _mesa_GetShaderSource(GLhandleARB shader, GLsizei maxLength,
1302                          GLsizei *length, GLcharARB *sourceOut)
1303 {
1304    GET_CURRENT_CONTEXT(ctx);
1305    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1306 }
1307
1308
1309 GLhandleARB GLAPIENTRY
1310 _mesa_GetHandleARB(GLenum pname)
1311 {
1312    GET_CURRENT_CONTEXT(ctx);
1313    return get_handle(ctx, pname);
1314 }
1315
1316
1317 GLboolean GLAPIENTRY
1318 _mesa_IsProgram(GLuint name)
1319 {
1320    GET_CURRENT_CONTEXT(ctx);
1321    return is_program(ctx, name);
1322 }
1323
1324
1325 GLboolean GLAPIENTRY
1326 _mesa_IsShader(GLuint name)
1327 {
1328    GET_CURRENT_CONTEXT(ctx);
1329    return is_shader(ctx, name);
1330 }
1331
1332
1333 void GLAPIENTRY
1334 _mesa_LinkProgram(GLhandleARB programObj)
1335 {
1336    GET_CURRENT_CONTEXT(ctx);
1337    link_program(ctx, programObj);
1338 }
1339
1340
1341
1342 /**
1343  * Read shader source code from a file.
1344  * Useful for debugging to override an app's shader.
1345  */
1346 static GLcharARB *
1347 read_shader(const char *fname)
1348 {
1349    const int max = 50*1000;
1350    FILE *f = fopen(fname, "r");
1351    GLcharARB *buffer, *shader;
1352    int len;
1353
1354    if (!f) {
1355       return NULL;
1356    }
1357
1358    buffer = malloc(max);
1359    len = fread(buffer, 1, max, f);
1360    buffer[len] = 0;
1361
1362    fclose(f);
1363
1364    shader = _mesa_strdup(buffer);
1365    free(buffer);
1366
1367    return shader;
1368 }
1369
1370
1371 /**
1372  * Called via glShaderSource() and glShaderSourceARB() API functions.
1373  * Basically, concatenate the source code strings into one long string
1374  * and pass it to _mesa_shader_source().
1375  */
1376 void GLAPIENTRY
1377 _mesa_ShaderSource(GLhandleARB shaderObj, GLsizei count,
1378                       const GLcharARB * const * string, const GLint * length)
1379 {
1380    GET_CURRENT_CONTEXT(ctx);
1381    GLint *offsets;
1382    GLsizei i, totalLength;
1383    GLcharARB *source;
1384    GLuint checksum;
1385
1386    if (!shaderObj || string == NULL) {
1387       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1388       return;
1389    }
1390
1391    /*
1392     * This array holds offsets of where the appropriate string ends, thus the
1393     * last element will be set to the total length of the source code.
1394     */
1395    offsets = malloc(count * sizeof(GLint));
1396    if (offsets == NULL) {
1397       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1398       return;
1399    }
1400
1401    for (i = 0; i < count; i++) {
1402       if (string[i] == NULL) {
1403          free((GLvoid *) offsets);
1404          _mesa_error(ctx, GL_INVALID_OPERATION,
1405                      "glShaderSourceARB(null string)");
1406          return;
1407       }
1408       if (length == NULL || length[i] < 0)
1409          offsets[i] = strlen(string[i]);
1410       else
1411          offsets[i] = length[i];
1412       /* accumulate string lengths */
1413       if (i > 0)
1414          offsets[i] += offsets[i - 1];
1415    }
1416
1417    /* Total length of source string is sum off all strings plus two.
1418     * One extra byte for terminating zero, another extra byte to silence
1419     * valgrind warnings in the parser/grammer code.
1420     */
1421    totalLength = offsets[count - 1] + 2;
1422    source = malloc(totalLength * sizeof(GLcharARB));
1423    if (source == NULL) {
1424       free((GLvoid *) offsets);
1425       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1426       return;
1427    }
1428
1429    for (i = 0; i < count; i++) {
1430       GLint start = (i > 0) ? offsets[i - 1] : 0;
1431       memcpy(source + start, string[i],
1432              (offsets[i] - start) * sizeof(GLcharARB));
1433    }
1434    source[totalLength - 1] = '\0';
1435    source[totalLength - 2] = '\0';
1436
1437    if (SHADER_SUBST) {
1438       /* Compute the shader's source code checksum then try to open a file
1439        * named newshader_<CHECKSUM>.  If it exists, use it in place of the
1440        * original shader source code.  For debugging.
1441        */
1442       char filename[100];
1443       GLcharARB *newSource;
1444
1445       checksum = _mesa_str_checksum(source);
1446
1447       _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
1448
1449       newSource = read_shader(filename);
1450       if (newSource) {
1451          fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
1452                        shaderObj, checksum, filename);
1453          free(source);
1454          source = newSource;
1455       }
1456    }
1457
1458    shader_source(ctx, shaderObj, source);
1459
1460    if (SHADER_SUBST) {
1461       struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
1462       if (sh)
1463          sh->SourceChecksum = checksum; /* save original checksum */
1464    }
1465
1466    free(offsets);
1467 }
1468
1469
1470 void GLAPIENTRY
1471 _mesa_UseProgram(GLhandleARB program)
1472 {
1473    GET_CURRENT_CONTEXT(ctx);
1474    struct gl_shader_program *shProg;
1475
1476    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1477       _mesa_error(ctx, GL_INVALID_OPERATION,
1478                   "glUseProgram(transform feedback active)");
1479       return;
1480    }
1481
1482    if (program) {
1483       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1484       if (!shProg) {
1485          return;
1486       }
1487       if (!shProg->LinkStatus) {
1488          _mesa_error(ctx, GL_INVALID_OPERATION,
1489                      "glUseProgram(program %u not linked)", program);
1490          return;
1491       }
1492
1493       /* debug code */
1494       if (ctx->Shader.Flags & GLSL_USE_PROG) {
1495          print_shader_info(shProg);
1496       }
1497    }
1498    else {
1499       shProg = NULL;
1500    }
1501
1502    _mesa_use_program(ctx, shProg);
1503 }
1504
1505
1506 void GLAPIENTRY
1507 _mesa_ValidateProgram(GLhandleARB program)
1508 {
1509    GET_CURRENT_CONTEXT(ctx);
1510    validate_program(ctx, program);
1511 }
1512
1513
1514 /**
1515  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1516  */
1517 void GLAPIENTRY
1518 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1519                                GLint* range, GLint* precision)
1520 {
1521    const struct gl_program_constants *limits;
1522    const struct gl_precision *p;
1523    GET_CURRENT_CONTEXT(ctx);
1524
1525    switch (shadertype) {
1526    case GL_VERTEX_SHADER:
1527       limits = &ctx->Const.Program[MESA_SHADER_VERTEX];
1528       break;
1529    case GL_FRAGMENT_SHADER:
1530       limits = &ctx->Const.Program[MESA_SHADER_FRAGMENT];
1531       break;
1532    default:
1533       _mesa_error(ctx, GL_INVALID_ENUM,
1534                   "glGetShaderPrecisionFormat(shadertype)");
1535       return;
1536    }
1537
1538    switch (precisiontype) {
1539    case GL_LOW_FLOAT:
1540       p = &limits->LowFloat;
1541       break;
1542    case GL_MEDIUM_FLOAT:
1543       p = &limits->MediumFloat;
1544       break;
1545    case GL_HIGH_FLOAT:
1546       p = &limits->HighFloat;
1547       break;
1548    case GL_LOW_INT:
1549       p = &limits->LowInt;
1550       break;
1551    case GL_MEDIUM_INT:
1552       p = &limits->MediumInt;
1553       break;
1554    case GL_HIGH_INT:
1555       p = &limits->HighInt;
1556       break;
1557    default:
1558       _mesa_error(ctx, GL_INVALID_ENUM,
1559                   "glGetShaderPrecisionFormat(precisiontype)");
1560       return;
1561    }
1562
1563    range[0] = p->RangeMin;
1564    range[1] = p->RangeMax;
1565    precision[0] = p->Precision;
1566 }
1567
1568
1569 /**
1570  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1571  */
1572 void GLAPIENTRY
1573 _mesa_ReleaseShaderCompiler(void)
1574 {
1575    _mesa_destroy_shader_compiler_caches();
1576 }
1577
1578
1579 /**
1580  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1581  */
1582 void GLAPIENTRY
1583 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1584                    const void* binary, GLint length)
1585 {
1586    GET_CURRENT_CONTEXT(ctx);
1587    (void) n;
1588    (void) shaders;
1589    (void) binaryformat;
1590    (void) binary;
1591    (void) length;
1592    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1593 }
1594
1595
1596 void GLAPIENTRY
1597 _mesa_GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
1598                        GLenum *binaryFormat, GLvoid *binary)
1599 {
1600    struct gl_shader_program *shProg;
1601    GET_CURRENT_CONTEXT(ctx);
1602
1603    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramBinary");
1604    if (!shProg)
1605       return;
1606
1607    if (!shProg->LinkStatus) {
1608       _mesa_error(ctx, GL_INVALID_OPERATION,
1609                   "glGetProgramBinary(program %u not linked)",
1610                   shProg->Name);
1611       return;
1612    }
1613
1614    if (bufSize < 0){
1615       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramBinary(bufSize < 0)");
1616       return;
1617    }
1618
1619    /* The ARB_get_program_binary spec says:
1620     *
1621     *     "If <length> is NULL, then no length is returned."
1622     */
1623    if (length != NULL)
1624       *length = 0;
1625
1626    (void) binaryFormat;
1627    (void) binary;
1628 }
1629
1630 void GLAPIENTRY
1631 _mesa_ProgramBinary(GLuint program, GLenum binaryFormat,
1632                     const GLvoid *binary, GLsizei length)
1633 {
1634    struct gl_shader_program *shProg;
1635    GET_CURRENT_CONTEXT(ctx);
1636
1637    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramBinary");
1638    if (!shProg)
1639       return;
1640
1641    (void) binaryFormat;
1642    (void) binary;
1643    (void) length;
1644    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1645 }
1646
1647
1648 void GLAPIENTRY
1649 _mesa_ProgramParameteri(GLuint program, GLenum pname, GLint value)
1650 {
1651    struct gl_shader_program *shProg;
1652    GET_CURRENT_CONTEXT(ctx);
1653
1654    shProg = _mesa_lookup_shader_program_err(ctx, program,
1655                                             "glProgramParameteri");
1656    if (!shProg)
1657       return;
1658
1659    switch (pname) {
1660    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
1661       /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
1662        * is part of OpenGL ES 3.0.  For the ES2 case, this function shouldn't
1663        * even be in the dispatch table, so we shouldn't need to expclicitly
1664        * check here.
1665        *
1666        * On desktop, we ignore the 3.0+ requirement because it is silly.
1667        */
1668
1669       /* The ARB_get_program_binary extension spec says:
1670        *
1671        *     "An INVALID_VALUE error is generated if the <value> argument to
1672        *     ProgramParameteri is not TRUE or FALSE."
1673        */
1674       if (value != GL_TRUE && value != GL_FALSE) {
1675          _mesa_error(ctx, GL_INVALID_VALUE,
1676                      "glProgramParameteri(pname=%s, value=%d): "
1677                      "value must be 0 or 1.",
1678                      _mesa_lookup_enum_by_nr(pname),
1679                      value);
1680          return;
1681       }
1682
1683       /* No need to notify the driver.  Any changes will actually take effect
1684        * the next time the shader is linked.
1685        *
1686        * The ARB_get_program_binary extension spec says:
1687        *
1688        *     "To indicate that a program binary is likely to be retrieved,
1689        *     ProgramParameteri should be called with <pname>
1690        *     PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
1691        *     will not be in effect until the next time LinkProgram or
1692        *     ProgramBinary has been called successfully."
1693        *
1694        * The resloution of issue 9 in the extension spec also says:
1695        *
1696        *     "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
1697        *     to indicate to the GL implementation that this program will
1698        *     likely be saved with GetProgramBinary at some point. This will
1699        *     give the GL implementation the opportunity to track any state
1700        *     changes made to the program before being saved such that when it
1701        *     is loaded again a recompile can be avoided."
1702        */
1703       shProg->BinaryRetreivableHint = value;
1704       return;
1705    default:
1706       break;
1707    }
1708
1709    _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteri(pname=%s)",
1710                _mesa_lookup_enum_by_nr(pname));
1711 }
1712
1713 void
1714 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
1715                          struct gl_shader_program *shProg)
1716 {
1717    use_shader_program(ctx, type, shProg);
1718
1719    if (ctx->Driver.UseProgram)
1720       ctx->Driver.UseProgram(ctx, shProg);
1721 }
1722
1723
1724 /**
1725  * For GL_EXT_separate_shader_objects
1726  */
1727 void GLAPIENTRY
1728 _mesa_UseShaderProgramEXT(GLenum type, GLuint program)
1729 {
1730    GET_CURRENT_CONTEXT(ctx);
1731    struct gl_shader_program *shProg = NULL;
1732
1733    if (!_mesa_validate_shader_target(ctx, type)) {
1734       _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");
1735       return;
1736    }
1737
1738    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1739       _mesa_error(ctx, GL_INVALID_OPERATION,
1740                   "glUseShaderProgramEXT(transform feedback is active)");
1741       return;
1742    }
1743
1744    if (program) {
1745       shProg = _mesa_lookup_shader_program_err(ctx, program,
1746                                                "glUseShaderProgramEXT");
1747       if (shProg == NULL)
1748          return;
1749
1750       if (!shProg->LinkStatus) {
1751          _mesa_error(ctx, GL_INVALID_OPERATION,
1752                      "glUseShaderProgramEXT(program not linked)");
1753          return;
1754       }
1755    }
1756
1757    _mesa_use_shader_program(ctx, type, shProg);
1758 }
1759
1760
1761 /**
1762  * For GL_EXT_separate_shader_objects
1763  */
1764 void GLAPIENTRY
1765 _mesa_ActiveProgramEXT(GLuint program)
1766 {
1767    GET_CURRENT_CONTEXT(ctx);
1768    struct gl_shader_program *shProg = (program != 0)
1769       ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
1770       : NULL;
1771
1772    _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
1773    return;
1774 }
1775
1776
1777 /**
1778  * For GL_EXT_separate_shader_objects
1779  */
1780 GLuint GLAPIENTRY
1781 _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
1782 {
1783    GET_CURRENT_CONTEXT(ctx);
1784    const GLuint shader = create_shader(ctx, type);
1785    GLuint program = 0;
1786
1787    if (shader) {
1788       shader_source(ctx, shader, _mesa_strdup(string));
1789       compile_shader(ctx, shader);
1790
1791       program = create_shader_program(ctx);
1792       if (program) {
1793          struct gl_shader_program *shProg;
1794          struct gl_shader *sh;
1795          GLint compiled = GL_FALSE;
1796
1797          shProg = _mesa_lookup_shader_program(ctx, program);
1798          sh = _mesa_lookup_shader(ctx, shader);
1799
1800          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
1801          if (compiled) {
1802             attach_shader(ctx, program, shader);
1803             link_program(ctx, program);
1804             detach_shader(ctx, program, shader);
1805
1806 #if 0
1807             /* Possibly... */
1808             if (active-user-defined-varyings-in-linked-program) {
1809                append-error-to-info-log;
1810                shProg->LinkStatus = GL_FALSE;
1811             }
1812 #endif
1813          }
1814
1815          ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
1816       }
1817
1818       delete_shader(ctx, shader);
1819    }
1820
1821    return program;
1822 }
1823
1824
1825 /**
1826  * Copy program-specific data generated by linking from the gl_shader_program
1827  * object to a specific gl_program object.
1828  */
1829 void
1830 _mesa_copy_linked_program_data(gl_shader_stage type,
1831                                const struct gl_shader_program *src,
1832                                struct gl_program *dst)
1833 {
1834    switch (type) {
1835    case MESA_SHADER_VERTEX:
1836       dst->UsesClipDistanceOut = src->Vert.UsesClipDistance;
1837       break;
1838    case MESA_SHADER_GEOMETRY: {
1839       struct gl_geometry_program *dst_gp = (struct gl_geometry_program *) dst;
1840       dst_gp->VerticesIn = src->Geom.VerticesIn;
1841       dst_gp->VerticesOut = src->Geom.VerticesOut;
1842       dst_gp->InputType = src->Geom.InputType;
1843       dst_gp->OutputType = src->Geom.OutputType;
1844       dst->UsesClipDistanceOut = src->Geom.UsesClipDistance;
1845       dst_gp->UsesEndPrimitive = src->Geom.UsesEndPrimitive;
1846    }
1847       break;
1848    default:
1849       break;
1850    }
1851 }