src/mesa/main/shaderapi.c

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