src/mesa/main/shaderapi.c

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