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