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    /* Geometry shaders are not yet fully supported, so issue a warning message
 747     * if we're compiling one.
 748     */
 749    if (sh->Type == GL_GEOMETRY_SHADER)
 750       printf("WARNING: Geometry shader support is currently experimental.\n");
 751
 752    options = &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(sh->Type)];
 753
 754    /* set default pragma state for shader */
 755    sh->Pragmas = options->DefaultPragmas;
 756
 757    if (!sh->Source) {
 758       /* If the user called glCompileShader without first calling
 759        * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
 760        */
 761       sh->CompileStatus = GL_FALSE;
 762    } else {
 763       if (ctx->Shader.Flags & GLSL_DUMP) {
 764          printf("GLSL source for %s shader %d:\n",
 765                 _mesa_glsl_shader_target_name(sh->Type), sh->Name);
 766          printf("%s\n", sh->Source);
 767       }
 768
 769       /* this call will set the shader->CompileStatus field to indicate if
 770        * compilation was successful.
 771        */
 772       _mesa_glsl_compile_shader(ctx, sh, false, false);
 773
 774       if (ctx->Shader.Flags & GLSL_LOG) {
 775          _mesa_write_shader_to_file(sh);
 776       }
 777
 778       if (ctx->Shader.Flags & GLSL_DUMP) {
 779          if (sh->CompileStatus) {
 780             printf("GLSL IR for shader %d:\n", sh->Name);
 781             _mesa_print_ir(sh->ir, NULL);
 782             printf("\n\n");
 783          } else {
 784             printf("GLSL shader %d failed to compile.\n", sh->Name);
 785          }
 786          if (sh->InfoLog && sh->InfoLog[0] != 0) {
 787             printf("GLSL shader %d info log:\n", sh->Name);
 788             printf("%s\n", sh->InfoLog);
 789          }
 790       }
 791
 792    }
 793
 794    if (!sh->CompileStatus) {
 795       if (ctx->Shader.Flags & GLSL_DUMP_ON_ERROR) {
 796          fprintf(stderr, "GLSL source for %s shader %d:\n",
 797                  _mesa_glsl_shader_target_name(sh->Type), sh->Name);
 798          fprintf(stderr, "%s\n", sh->Source);
 799       }
 800
 801       if (ctx->Shader.Flags & GLSL_REPORT_ERRORS) {
 802          _mesa_debug(ctx, "Error compiling shader %u:\n%s\n",
 803                      sh->Name, sh->InfoLog);
 804       }
 805    }
 806 }
 807
 808
 809 /**
 810  * Link a program's shaders.
 811  */
 812 static void
 813 link_program(struct gl_context *ctx, GLuint program)
 814 {
 815    struct gl_shader_program *shProg;
 816
 817    shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
 818    if (!shProg)
 819       return;
 820
 821    /* From the ARB_transform_feedback2 specification:
 822     * "The error INVALID_OPERATION is generated by LinkProgram if <program> is
 823     *  the name of a program being used by one or more transform feedback
 824     *  objects, even if the objects are not currently bound or are paused."
 825     */
 826    if (_mesa_transform_feedback_is_using_program(ctx, shProg)) {
 827       _mesa_error(ctx, GL_INVALID_OPERATION,
 828                   "glLinkProgram(transform feedback is using the program)");
 829       return;
 830    }
 831
 832    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 833
 834    _mesa_glsl_link_shader(ctx, shProg);
 835
 836    if (shProg->LinkStatus == GL_FALSE &&
 837        (ctx->Shader.Flags & GLSL_REPORT_ERRORS)) {
 838       _mesa_debug(ctx, "Error linking program %u:\n%s\n",
 839                   shProg->Name, shProg->InfoLog);
 840    }
 841
 842    /* debug code */
 843    if (0) {
 844       GLuint i;
 845
 846       printf("Link %u shaders in program %u: %s\n",
 847                    shProg->NumShaders, shProg->Name,
 848                    shProg->LinkStatus ? "Success" : "Failed");
 849
 850       for (i = 0; i < shProg->NumShaders; i++) {
 851          printf(" shader %u, type 0x%x\n",
 852                       shProg->Shaders[i]->Name,
 853                       shProg->Shaders[i]->Type);
 854       }
 855    }
 856 }
 857
 858
 859 /**
 860  * Print basic shader info (for debug).
 861  */
 862 static void
 863 print_shader_info(const struct gl_shader_program *shProg)
 864 {
 865    GLuint i;
 866
 867    printf("Mesa: glUseProgram(%u)\n", shProg->Name);
 868    for (i = 0; i < shProg->NumShaders; i++) {
 869       printf("  %s shader %u, checksum %u\n",
 870              _mesa_glsl_shader_target_name(shProg->Shaders[i]->Type),
 871              shProg->Shaders[i]->Name,
 872              shProg->Shaders[i]->SourceChecksum);
 873    }
 874    if (shProg->_LinkedShaders[MESA_SHADER_VERTEX])
 875       printf("  vert prog %u\n",
 876              shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program->Id);
 877    if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT])
 878       printf("  frag prog %u\n",
 879              shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program->Id);
 880    if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY])
 881       printf("  geom prog %u\n",
 882              shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program->Id);
 883 }
 884
 885
 886 /**
 887  * Use the named shader program for subsequent glUniform calls
 888  */
 889 void
 890 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
 891                      const char *caller)
 892 {
 893    if ((shProg != NULL) && !shProg->LinkStatus) {
 894       _mesa_error(ctx, GL_INVALID_OPERATION,
 895                   "%s(program %u not linked)", caller, shProg->Name);
 896       return;
 897    }
 898
 899    if (ctx->Shader.ActiveProgram != shProg) {
 900       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
 901    }
 902 }
 903
 904 /**
 905  */
 906 static bool
 907 use_shader_program(struct gl_context *ctx, GLenum type,
 908                    struct gl_shader_program *shProg)
 909 {
 910    struct gl_shader_program **target;
 911
 912    switch (type) {
 913    case GL_VERTEX_SHADER:
 914       target = &ctx->Shader.CurrentVertexProgram;
 915       if ((shProg == NULL)
 916           || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) {
 917          shProg = NULL;
 918       }
 919       break;
 920    case GL_GEOMETRY_SHADER_ARB:
 921       target = &ctx->Shader.CurrentGeometryProgram;
 922       if ((shProg == NULL)
 923           || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) {
 924          shProg = NULL;
 925       }
 926       break;
 927    case GL_FRAGMENT_SHADER:
 928       target = &ctx->Shader.CurrentFragmentProgram;
 929       if ((shProg == NULL)
 930           || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) {
 931          shProg = NULL;
 932       }
 933       break;
 934    default:
 935       return false;
 936    }
 937
 938    if (*target != shProg) {
 939       FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
 940
 941       /* If the shader is also bound as the current rendering shader, unbind
 942        * it from that binding point as well.  This ensures that the correct
 943        * semantics of glDeleteProgram are maintained.
 944        */
 945       switch (type) {
 946       case GL_VERTEX_SHADER:
 947          /* Empty for now. */
 948          break;
 949       case GL_GEOMETRY_SHADER_ARB:
 950          /* Empty for now. */
 951          break;
 952       case GL_FRAGMENT_SHADER:
 953          if (*target == ctx->Shader._CurrentFragmentProgram) {
 954             _mesa_reference_shader_program(ctx,
 955                                            &ctx->Shader._CurrentFragmentProgram,
 956                                            NULL);
 957          }
 958          break;
 959       }
 960
 961       _mesa_reference_shader_program(ctx, target, shProg);
 962       return true;
 963    }
 964
 965    return false;
 966 }
 967
 968 /**
 969  * Use the named shader program for subsequent rendering.
 970  */
 971 void
 972 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
 973 {
 974    use_shader_program(ctx, GL_VERTEX_SHADER, shProg);
 975    use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);
 976    use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);
 977    _mesa_active_program(ctx, shProg, "glUseProgram");
 978
 979    if (ctx->Driver.UseProgram)
 980       ctx->Driver.UseProgram(ctx, shProg);
 981 }
 982
 983
 984 /**
 985  * Do validation of the given shader program.
 986  * \param errMsg  returns error message if validation fails.
 987  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
 988  */
 989 static GLboolean
 990 validate_shader_program(const struct gl_shader_program *shProg,
 991                         char *errMsg)
 992 {
 993    if (!shProg->LinkStatus) {
 994       return GL_FALSE;
 995    }
 996
 997    /* From the GL spec, a program is invalid if any of these are true:
 998
 999      any two active samplers in the current program object are of
1000      different types, but refer to the same texture image unit,
1001
1002      any active sampler in the current program object refers to a texture
1003      image unit where fixed-function fragment processing accesses a
1004      texture target that does not match the sampler type, or
1005
1006      the sum of the number of active samplers in the program and the
1007      number of texture image units enabled for fixed-function fragment
1008      processing exceeds the combined limit on the total number of texture
1009      image units allowed.
1010    */
1011
1012
1013    /*
1014     * Check: any two active samplers in the current program object are of
1015     * different types, but refer to the same texture image unit,
1016     */
1017    if (!_mesa_sampler_uniforms_are_valid(shProg, errMsg, 100))
1018       return GL_FALSE;
1019
1020    return GL_TRUE;
1021 }
1022
1023
1024 /**
1025  * Called via glValidateProgram()
1026  */
1027 static void
1028 validate_program(struct gl_context *ctx, GLuint program)
1029 {
1030    struct gl_shader_program *shProg;
1031    char errMsg[100] = "";
1032
1033    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1034    if (!shProg) {
1035       return;
1036    }
1037
1038    shProg->Validated = validate_shader_program(shProg, errMsg);
1039    if (!shProg->Validated) {
1040       /* update info log */
1041       if (shProg->InfoLog) {
1042          ralloc_free(shProg->InfoLog);
1043       }
1044       shProg->InfoLog = ralloc_strdup(shProg, errMsg);
1045    }
1046 }
1047
1048
1049
1050 void GLAPIENTRY
1051 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
1052 {
1053    GET_CURRENT_CONTEXT(ctx);
1054    attach_shader(ctx, program, shader);
1055 }
1056
1057
1058 void GLAPIENTRY
1059 _mesa_AttachShader(GLuint program, GLuint shader)
1060 {
1061    GET_CURRENT_CONTEXT(ctx);
1062    attach_shader(ctx, program, shader);
1063 }
1064
1065
1066 void GLAPIENTRY
1067 _mesa_CompileShader(GLhandleARB shaderObj)
1068 {
1069    GET_CURRENT_CONTEXT(ctx);
1070    if (MESA_VERBOSE & VERBOSE_API)
1071       _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1072    compile_shader(ctx, shaderObj);
1073 }
1074
1075
1076 GLuint GLAPIENTRY
1077 _mesa_CreateShader(GLenum type)
1078 {
1079    GET_CURRENT_CONTEXT(ctx);
1080    if (MESA_VERBOSE & VERBOSE_API)
1081       _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));
1082    return create_shader(ctx, type);
1083 }
1084
1085
1086 GLhandleARB GLAPIENTRY
1087 _mesa_CreateShaderObjectARB(GLenum type)
1088 {
1089    GET_CURRENT_CONTEXT(ctx);
1090    return create_shader(ctx, type);
1091 }
1092
1093
1094 GLuint GLAPIENTRY
1095 _mesa_CreateProgram(void)
1096 {
1097    GET_CURRENT_CONTEXT(ctx);
1098    if (MESA_VERBOSE & VERBOSE_API)
1099       _mesa_debug(ctx, "glCreateProgram\n");
1100    return create_shader_program(ctx);
1101 }
1102
1103
1104 GLhandleARB GLAPIENTRY
1105 _mesa_CreateProgramObjectARB(void)
1106 {
1107    GET_CURRENT_CONTEXT(ctx);
1108    return create_shader_program(ctx);
1109 }
1110
1111
1112 void GLAPIENTRY
1113 _mesa_DeleteObjectARB(GLhandleARB obj)
1114 {
1115    if (MESA_VERBOSE & VERBOSE_API) {
1116       GET_CURRENT_CONTEXT(ctx);
1117       _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);
1118    }
1119
1120    if (obj) {
1121       GET_CURRENT_CONTEXT(ctx);
1122       FLUSH_VERTICES(ctx, 0);
1123       if (is_program(ctx, obj)) {
1124          delete_shader_program(ctx, obj);
1125       }
1126       else if (is_shader(ctx, obj)) {
1127          delete_shader(ctx, obj);
1128       }
1129       else {
1130          /* error? */
1131       }
1132    }
1133 }
1134
1135
1136 void GLAPIENTRY
1137 _mesa_DeleteProgram(GLuint name)
1138 {
1139    if (name) {
1140       GET_CURRENT_CONTEXT(ctx);
1141       FLUSH_VERTICES(ctx, 0);
1142       delete_shader_program(ctx, name);
1143    }
1144 }
1145
1146
1147 void GLAPIENTRY
1148 _mesa_DeleteShader(GLuint name)
1149 {
1150    if (name) {
1151       GET_CURRENT_CONTEXT(ctx);
1152       FLUSH_VERTICES(ctx, 0);
1153       delete_shader(ctx, name);
1154    }
1155 }
1156
1157
1158 void GLAPIENTRY
1159 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1160 {
1161    GET_CURRENT_CONTEXT(ctx);
1162    detach_shader(ctx, program, shader);
1163 }
1164
1165
1166 void GLAPIENTRY
1167 _mesa_DetachShader(GLuint program, GLuint shader)
1168 {
1169    GET_CURRENT_CONTEXT(ctx);
1170    detach_shader(ctx, program, shader);
1171 }
1172
1173
1174 void GLAPIENTRY
1175 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1176                             GLsizei * count, GLhandleARB * obj)
1177 {
1178    GET_CURRENT_CONTEXT(ctx);
1179    get_attached_shaders(ctx, container, maxCount, count, obj);
1180 }
1181
1182
1183 void GLAPIENTRY
1184 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1185                          GLsizei *count, GLuint *obj)
1186 {
1187    GET_CURRENT_CONTEXT(ctx);
1188    get_attached_shaders(ctx, program, maxCount, count, obj);
1189 }
1190
1191
1192 void GLAPIENTRY
1193 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1194                     GLcharARB * infoLog)
1195 {
1196    GET_CURRENT_CONTEXT(ctx);
1197    if (is_program(ctx, object)) {
1198       get_program_info_log(ctx, object, maxLength, length, infoLog);
1199    }
1200    else if (is_shader(ctx, object)) {
1201       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1202    }
1203    else {
1204       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1205    }
1206 }
1207
1208
1209 void GLAPIENTRY
1210 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1211 {
1212    GET_CURRENT_CONTEXT(ctx);
1213    /* Implement in terms of GetProgramiv, GetShaderiv */
1214    if (is_program(ctx, object)) {
1215       if (pname == GL_OBJECT_TYPE_ARB) {
1216          *params = GL_PROGRAM_OBJECT_ARB;
1217       }
1218       else {
1219          get_programiv(ctx, object, pname, params);
1220       }
1221    }
1222    else if (is_shader(ctx, object)) {
1223       if (pname == GL_OBJECT_TYPE_ARB) {
1224          *params = GL_SHADER_OBJECT_ARB;
1225       }
1226       else {
1227          get_shaderiv(ctx, object, pname, params);
1228       }
1229    }
1230    else {
1231       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1232    }
1233 }
1234
1235
1236 void GLAPIENTRY
1237 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1238                               GLfloat *params)
1239 {
1240    GLint iparams[1];  /* XXX is one element enough? */
1241    _mesa_GetObjectParameterivARB(object, pname, iparams);
1242    params[0] = (GLfloat) iparams[0];
1243 }
1244
1245
1246 void GLAPIENTRY
1247 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1248 {
1249    GET_CURRENT_CONTEXT(ctx);
1250    get_programiv(ctx, program, pname, params);
1251 }
1252
1253
1254 void GLAPIENTRY
1255 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1256 {
1257    GET_CURRENT_CONTEXT(ctx);
1258    get_shaderiv(ctx, shader, pname, params);
1259 }
1260
1261
1262 void GLAPIENTRY
1263 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1264                         GLsizei *length, GLchar *infoLog)
1265 {
1266    GET_CURRENT_CONTEXT(ctx);
1267    get_program_info_log(ctx, program, bufSize, length, infoLog);
1268 }
1269
1270
1271 void GLAPIENTRY
1272 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1273                        GLsizei *length, GLchar *infoLog)
1274 {
1275    GET_CURRENT_CONTEXT(ctx);
1276    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1277 }
1278
1279
1280 void GLAPIENTRY
1281 _mesa_GetShaderSource(GLhandleARB shader, GLsizei maxLength,
1282                          GLsizei *length, GLcharARB *sourceOut)
1283 {
1284    GET_CURRENT_CONTEXT(ctx);
1285    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1286 }
1287
1288
1289 GLhandleARB GLAPIENTRY
1290 _mesa_GetHandleARB(GLenum pname)
1291 {
1292    GET_CURRENT_CONTEXT(ctx);
1293    return get_handle(ctx, pname);
1294 }
1295
1296
1297 GLboolean GLAPIENTRY
1298 _mesa_IsProgram(GLuint name)
1299 {
1300    GET_CURRENT_CONTEXT(ctx);
1301    return is_program(ctx, name);
1302 }
1303
1304
1305 GLboolean GLAPIENTRY
1306 _mesa_IsShader(GLuint name)
1307 {
1308    GET_CURRENT_CONTEXT(ctx);
1309    return is_shader(ctx, name);
1310 }
1311
1312
1313 void GLAPIENTRY
1314 _mesa_LinkProgram(GLhandleARB programObj)
1315 {
1316    GET_CURRENT_CONTEXT(ctx);
1317    link_program(ctx, programObj);
1318 }
1319
1320
1321
1322 /**
1323  * Read shader source code from a file.
1324  * Useful for debugging to override an app's shader.
1325  */
1326 static GLcharARB *
1327 read_shader(const char *fname)
1328 {
1329    const int max = 50*1000;
1330    FILE *f = fopen(fname, "r");
1331    GLcharARB *buffer, *shader;
1332    int len;
1333
1334    if (!f) {
1335       return NULL;
1336    }
1337
1338    buffer = malloc(max);
1339    len = fread(buffer, 1, max, f);
1340    buffer[len] = 0;
1341
1342    fclose(f);
1343
1344    shader = _mesa_strdup(buffer);
1345    free(buffer);
1346
1347    return shader;
1348 }
1349
1350
1351 /**
1352  * Called via glShaderSource() and glShaderSourceARB() API functions.
1353  * Basically, concatenate the source code strings into one long string
1354  * and pass it to _mesa_shader_source().
1355  */
1356 void GLAPIENTRY
1357 _mesa_ShaderSource(GLhandleARB shaderObj, GLsizei count,
1358                       const GLcharARB * const * string, const GLint * length)
1359 {
1360    GET_CURRENT_CONTEXT(ctx);
1361    GLint *offsets;
1362    GLsizei i, totalLength;
1363    GLcharARB *source;
1364    GLuint checksum;
1365
1366    if (!shaderObj || string == NULL) {
1367       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1368       return;
1369    }
1370
1371    /*
1372     * This array holds offsets of where the appropriate string ends, thus the
1373     * last element will be set to the total length of the source code.
1374     */
1375    offsets = malloc(count * sizeof(GLint));
1376    if (offsets == NULL) {
1377       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1378       return;
1379    }
1380
1381    for (i = 0; i < count; i++) {
1382       if (string[i] == NULL) {
1383          free((GLvoid *) offsets);
1384          _mesa_error(ctx, GL_INVALID_OPERATION,
1385                      "glShaderSourceARB(null string)");
1386          return;
1387       }
1388       if (length == NULL || length[i] < 0)
1389          offsets[i] = strlen(string[i]);
1390       else
1391          offsets[i] = length[i];
1392       /* accumulate string lengths */
1393       if (i > 0)
1394          offsets[i] += offsets[i - 1];
1395    }
1396
1397    /* Total length of source string is sum off all strings plus two.
1398     * One extra byte for terminating zero, another extra byte to silence
1399     * valgrind warnings in the parser/grammer code.
1400     */
1401    totalLength = offsets[count - 1] + 2;
1402    source = malloc(totalLength * sizeof(GLcharARB));
1403    if (source == NULL) {
1404       free((GLvoid *) offsets);
1405       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1406       return;
1407    }
1408
1409    for (i = 0; i < count; i++) {
1410       GLint start = (i > 0) ? offsets[i - 1] : 0;
1411       memcpy(source + start, string[i],
1412              (offsets[i] - start) * sizeof(GLcharARB));
1413    }
1414    source[totalLength - 1] = '\0';
1415    source[totalLength - 2] = '\0';
1416
1417    if (SHADER_SUBST) {
1418       /* Compute the shader's source code checksum then try to open a file
1419        * named newshader_<CHECKSUM>.  If it exists, use it in place of the
1420        * original shader source code.  For debugging.
1421        */
1422       char filename[100];
1423       GLcharARB *newSource;
1424
1425       checksum = _mesa_str_checksum(source);
1426
1427       _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
1428
1429       newSource = read_shader(filename);
1430       if (newSource) {
1431          fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
1432                        shaderObj, checksum, filename);
1433          free(source);
1434          source = newSource;
1435       }
1436    }
1437
1438    shader_source(ctx, shaderObj, source);
1439
1440    if (SHADER_SUBST) {
1441       struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
1442       if (sh)
1443          sh->SourceChecksum = checksum; /* save original checksum */
1444    }
1445
1446    free(offsets);
1447 }
1448
1449
1450 void GLAPIENTRY
1451 _mesa_UseProgram(GLhandleARB program)
1452 {
1453    GET_CURRENT_CONTEXT(ctx);
1454    struct gl_shader_program *shProg;
1455
1456    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1457       _mesa_error(ctx, GL_INVALID_OPERATION,
1458                   "glUseProgram(transform feedback active)");
1459       return;
1460    }
1461
1462    if (program) {
1463       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1464       if (!shProg) {
1465          return;
1466       }
1467       if (!shProg->LinkStatus) {
1468          _mesa_error(ctx, GL_INVALID_OPERATION,
1469                      "glUseProgram(program %u not linked)", program);
1470          return;
1471       }
1472
1473       /* debug code */
1474       if (ctx->Shader.Flags & GLSL_USE_PROG) {
1475          print_shader_info(shProg);
1476       }
1477    }
1478    else {
1479       shProg = NULL;
1480    }
1481
1482    _mesa_use_program(ctx, shProg);
1483 }
1484
1485
1486 void GLAPIENTRY
1487 _mesa_ValidateProgram(GLhandleARB program)
1488 {
1489    GET_CURRENT_CONTEXT(ctx);
1490    validate_program(ctx, program);
1491 }
1492
1493
1494 /**
1495  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1496  */
1497 void GLAPIENTRY
1498 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1499                                GLint* range, GLint* precision)
1500 {
1501    const struct gl_program_constants *limits;
1502    const struct gl_precision *p;
1503    GET_CURRENT_CONTEXT(ctx);
1504
1505    switch (shadertype) {
1506    case GL_VERTEX_SHADER:
1507       limits = &ctx->Const.VertexProgram;
1508       break;
1509    case GL_FRAGMENT_SHADER:
1510       limits = &ctx->Const.FragmentProgram;
1511       break;
1512    default:
1513       _mesa_error(ctx, GL_INVALID_ENUM,
1514                   "glGetShaderPrecisionFormat(shadertype)");
1515       return;
1516    }
1517
1518    switch (precisiontype) {
1519    case GL_LOW_FLOAT:
1520       p = &limits->LowFloat;
1521       break;
1522    case GL_MEDIUM_FLOAT:
1523       p = &limits->MediumFloat;
1524       break;
1525    case GL_HIGH_FLOAT:
1526       p = &limits->HighFloat;
1527       break;
1528    case GL_LOW_INT:
1529       p = &limits->LowInt;
1530       break;
1531    case GL_MEDIUM_INT:
1532       p = &limits->MediumInt;
1533       break;
1534    case GL_HIGH_INT:
1535       p = &limits->HighInt;
1536       break;
1537    default:
1538       _mesa_error(ctx, GL_INVALID_ENUM,
1539                   "glGetShaderPrecisionFormat(precisiontype)");
1540       return;
1541    }
1542
1543    range[0] = p->RangeMin;
1544    range[1] = p->RangeMax;
1545    precision[0] = p->Precision;
1546 }
1547
1548
1549 /**
1550  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1551  */
1552 void GLAPIENTRY
1553 _mesa_ReleaseShaderCompiler(void)
1554 {
1555    _mesa_destroy_shader_compiler_caches();
1556 }
1557
1558
1559 /**
1560  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1561  */
1562 void GLAPIENTRY
1563 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1564                    const void* binary, GLint length)
1565 {
1566    GET_CURRENT_CONTEXT(ctx);
1567    (void) n;
1568    (void) shaders;
1569    (void) binaryformat;
1570    (void) binary;
1571    (void) length;
1572    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1573 }
1574
1575
1576 void GLAPIENTRY
1577 _mesa_GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
1578                        GLenum *binaryFormat, GLvoid *binary)
1579 {
1580    struct gl_shader_program *shProg;
1581    GET_CURRENT_CONTEXT(ctx);
1582
1583    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramBinary");
1584    if (!shProg)
1585       return;
1586
1587    if (!shProg->LinkStatus) {
1588       _mesa_error(ctx, GL_INVALID_OPERATION,
1589                   "glGetProgramBinary(program %u not linked)",
1590                   shProg->Name);
1591       return;
1592    }
1593
1594    if (bufSize < 0){
1595       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramBinary(bufSize < 0)");
1596       return;
1597    }
1598
1599    /* The ARB_get_program_binary spec says:
1600     *
1601     *     "If <length> is NULL, then no length is returned."
1602     */
1603    if (length != NULL)
1604       *length = 0;
1605
1606    (void) binaryFormat;
1607    (void) binary;
1608 }
1609
1610 void GLAPIENTRY
1611 _mesa_ProgramBinary(GLuint program, GLenum binaryFormat,
1612                     const GLvoid *binary, GLsizei length)
1613 {
1614    struct gl_shader_program *shProg;
1615    GET_CURRENT_CONTEXT(ctx);
1616
1617    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramBinary");
1618    if (!shProg)
1619       return;
1620
1621    (void) binaryFormat;
1622    (void) binary;
1623    (void) length;
1624    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1625 }
1626
1627
1628 void GLAPIENTRY
1629 _mesa_ProgramParameteri(GLuint program, GLenum pname, GLint value)
1630 {
1631    struct gl_shader_program *shProg;
1632    GET_CURRENT_CONTEXT(ctx);
1633
1634    shProg = _mesa_lookup_shader_program_err(ctx, program,
1635                                             "glProgramParameteri");
1636    if (!shProg)
1637       return;
1638
1639    switch (pname) {
1640    case GL_GEOMETRY_VERTICES_OUT_ARB:
1641       if (!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_geometry_shader4)
1642          break;
1643
1644       if (value < 0 ||
1645           (unsigned) value > ctx->Const.MaxGeometryOutputVertices) {
1646          _mesa_error(ctx, GL_INVALID_VALUE,
1647                      "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d)",
1648                      value);
1649          return;
1650       }
1651       shProg->Geom.VerticesOut = value;
1652       return;
1653    case GL_GEOMETRY_INPUT_TYPE_ARB:
1654       if (!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_geometry_shader4)
1655          break;
1656
1657       switch (value) {
1658       case GL_POINTS:
1659       case GL_LINES:
1660       case GL_LINES_ADJACENCY_ARB:
1661       case GL_TRIANGLES:
1662       case GL_TRIANGLES_ADJACENCY_ARB:
1663          shProg->Geom.InputType = value;
1664          break;
1665       default:
1666          _mesa_error(ctx, GL_INVALID_VALUE,
1667                      "glProgramParameteri(geometry input type = %s)",
1668                      _mesa_lookup_enum_by_nr(value));
1669          return;
1670       }
1671       return;
1672    case GL_GEOMETRY_OUTPUT_TYPE_ARB:
1673       if (!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_geometry_shader4)
1674          break;
1675
1676       switch (value) {
1677       case GL_POINTS:
1678       case GL_LINE_STRIP:
1679       case GL_TRIANGLE_STRIP:
1680          shProg->Geom.OutputType = value;
1681          break;
1682       default:
1683          _mesa_error(ctx, GL_INVALID_VALUE,
1684                      "glProgramParameteri(geometry output type = %s)",
1685                      _mesa_lookup_enum_by_nr(value));
1686          return;
1687       }
1688       return;
1689    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
1690       /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
1691        * is part of OpenGL ES 3.0.  For the ES2 case, this function shouldn't
1692        * even be in the dispatch table, so we shouldn't need to expclicitly
1693        * check here.
1694        *
1695        * On desktop, we ignore the 3.0+ requirement because it is silly.
1696        */
1697
1698       /* The ARB_get_program_binary extension spec says:
1699        *
1700        *     "An INVALID_VALUE error is generated if the <value> argument to
1701        *     ProgramParameteri is not TRUE or FALSE."
1702        */
1703       if (value != GL_TRUE && value != GL_FALSE) {
1704          _mesa_error(ctx, GL_INVALID_VALUE,
1705                      "glProgramParameteri(pname=%s, value=%d): "
1706                      "value must be 0 or 1.",
1707                      _mesa_lookup_enum_by_nr(pname),
1708                      value);
1709          return;
1710       }
1711
1712       /* No need to notify the driver.  Any changes will actually take effect
1713        * the next time the shader is linked.
1714        *
1715        * The ARB_get_program_binary extension spec says:
1716        *
1717        *     "To indicate that a program binary is likely to be retrieved,
1718        *     ProgramParameteri should be called with <pname>
1719        *     PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
1720        *     will not be in effect until the next time LinkProgram or
1721        *     ProgramBinary has been called successfully."
1722        *
1723        * The resloution of issue 9 in the extension spec also says:
1724        *
1725        *     "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
1726        *     to indicate to the GL implementation that this program will
1727        *     likely be saved with GetProgramBinary at some point. This will
1728        *     give the GL implementation the opportunity to track any state
1729        *     changes made to the program before being saved such that when it
1730        *     is loaded again a recompile can be avoided."
1731        */
1732       shProg->BinaryRetreivableHint = value;
1733       return;
1734    default:
1735       break;
1736    }
1737
1738    _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteri(pname=%s)",
1739                _mesa_lookup_enum_by_nr(pname));
1740 }
1741
1742 void
1743 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
1744                          struct gl_shader_program *shProg)
1745 {
1746    use_shader_program(ctx, type, shProg);
1747
1748    if (ctx->Driver.UseProgram)
1749       ctx->Driver.UseProgram(ctx, shProg);
1750 }
1751
1752
1753 /**
1754  * For GL_EXT_separate_shader_objects
1755  */
1756 void GLAPIENTRY
1757 _mesa_UseShaderProgramEXT(GLenum type, GLuint program)
1758 {
1759    GET_CURRENT_CONTEXT(ctx);
1760    struct gl_shader_program *shProg = NULL;
1761
1762    if (!validate_shader_target(ctx, type)) {
1763       _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");
1764       return;
1765    }
1766
1767    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1768       _mesa_error(ctx, GL_INVALID_OPERATION,
1769                   "glUseShaderProgramEXT(transform feedback is active)");
1770       return;
1771    }
1772
1773    if (program) {
1774       shProg = _mesa_lookup_shader_program_err(ctx, program,
1775                                                "glUseShaderProgramEXT");
1776       if (shProg == NULL)
1777          return;
1778
1779       if (!shProg->LinkStatus) {
1780          _mesa_error(ctx, GL_INVALID_OPERATION,
1781                      "glUseShaderProgramEXT(program not linked)");
1782          return;
1783       }
1784    }
1785
1786    _mesa_use_shader_program(ctx, type, shProg);
1787 }
1788
1789
1790 /**
1791  * For GL_EXT_separate_shader_objects
1792  */
1793 void GLAPIENTRY
1794 _mesa_ActiveProgramEXT(GLuint program)
1795 {
1796    GET_CURRENT_CONTEXT(ctx);
1797    struct gl_shader_program *shProg = (program != 0)
1798       ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
1799       : NULL;
1800
1801    _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
1802    return;
1803 }
1804
1805
1806 /**
1807  * For GL_EXT_separate_shader_objects
1808  */
1809 GLuint GLAPIENTRY
1810 _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
1811 {
1812    GET_CURRENT_CONTEXT(ctx);
1813    const GLuint shader = create_shader(ctx, type);
1814    GLuint program = 0;
1815
1816    if (shader) {
1817       shader_source(ctx, shader, _mesa_strdup(string));
1818       compile_shader(ctx, shader);
1819
1820       program = create_shader_program(ctx);
1821       if (program) {
1822          struct gl_shader_program *shProg;
1823          struct gl_shader *sh;
1824          GLint compiled = GL_FALSE;
1825
1826          shProg = _mesa_lookup_shader_program(ctx, program);
1827          sh = _mesa_lookup_shader(ctx, shader);
1828
1829          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
1830          if (compiled) {
1831             attach_shader(ctx, program, shader);
1832             link_program(ctx, program);
1833             detach_shader(ctx, program, shader);
1834
1835 #if 0
1836             /* Possibly... */
1837             if (active-user-defined-varyings-in-linked-program) {
1838                append-error-to-info-log;
1839                shProg->LinkStatus = GL_FALSE;
1840             }
1841 #endif
1842          }
1843
1844          ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
1845       }
1846
1847       delete_shader(ctx, shader);
1848    }
1849
1850    return program;
1851 }
1852
1853
1854 /**
1855  * Copy program-specific data generated by linking from the gl_shader_program
1856  * object to a specific gl_program object.
1857  */
1858 void
1859 _mesa_copy_linked_program_data(gl_shader_type type,
1860                                const struct gl_shader_program *src,
1861                                struct gl_program *dst)
1862 {
1863    switch (type) {
1864    case MESA_SHADER_VERTEX: {
1865       struct gl_vertex_program *dst_vp = (struct gl_vertex_program *) dst;
1866       dst_vp->UsesClipDistance = src->Vert.UsesClipDistance;
1867    }
1868       break;
1869    case MESA_SHADER_GEOMETRY: {
1870       struct gl_geometry_program *dst_gp = (struct gl_geometry_program *) dst;
1871       dst_gp->VerticesIn = src->Geom.VerticesIn;
1872       dst_gp->VerticesOut = src->Geom.VerticesOut;
1873       dst_gp->InputType = src->Geom.InputType;
1874       dst_gp->OutputType = src->Geom.OutputType;
1875       dst_gp->UsesClipDistance = src->Geom.UsesClipDistance;
1876       dst_gp->UsesEndPrimitive = src->Geom.UsesEndPrimitive;
1877    }
1878       break;
1879    default:
1880       break;
1881    }
1882 }