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