src/mesa/main/shaderapi.c

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