src/mesa/main/shaderapi.c

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