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    if (shProg->GeometryProgram)
 929       printf("  geom prog %u\n", shProg->GeometryProgram->Base.Id);
 930 }
 931
 932
 933 /**
 934  * Use the named shader program for subsequent glUniform calls
 935  */
 936 void
 937 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
 938                      const char *caller)
 939 {
 940    if ((shProg != NULL) && !shProg->LinkStatus) {
 941       _mesa_error(ctx, GL_INVALID_OPERATION,
 942                   "%s(program %u not linked)", caller, shProg->Name);
 943       return;
 944    }
 945
 946    if (ctx->Shader.ActiveProgram != shProg) {
 947       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
 948    }
 949 }
 950
 951 /**
 952  */
 953 static bool
 954 use_shader_program(struct gl_context *ctx, GLenum type,
 955                    struct gl_shader_program *shProg)
 956 {
 957    struct gl_shader_program **target;
 958
 959    switch (type) {
 960 #if FEATURE_ARB_vertex_shader
 961    case GL_VERTEX_SHADER:
 962       target = &ctx->Shader.CurrentVertexProgram;
 963       if ((shProg == NULL)
 964           || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) {
 965          shProg = NULL;
 966       }
 967       break;
 968 #endif
 969 #if FEATURE_ARB_geometry_shader4
 970    case GL_GEOMETRY_SHADER_ARB:
 971       target = &ctx->Shader.CurrentGeometryProgram;
 972       if ((shProg == NULL)
 973           || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) {
 974          shProg = NULL;
 975       }
 976       break;
 977 #endif
 978 #if FEATURE_ARB_fragment_shader
 979    case GL_FRAGMENT_SHADER:
 980       target = &ctx->Shader.CurrentFragmentProgram;
 981       if ((shProg == NULL)
 982           || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) {
 983          shProg = NULL;
 984       }
 985       break;
 986 #endif
 987    default:
 988       return false;
 989    }
 990
 991    if (*target != shProg) {
 992       FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
 993       _mesa_reference_shader_program(ctx, target, shProg);
 994       return true;
 995    }
 996
 997    return false;
 998 }
 999
1000 /**
1001  * Use the named shader program for subsequent rendering.
1002  */
1003 void
1004 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
1005 {
1006    use_shader_program(ctx, GL_VERTEX_SHADER, shProg);
1007    use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);
1008    use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);
1009    _mesa_active_program(ctx, shProg, "glUseProgram");
1010
1011    if (ctx->Driver.UseProgram)
1012       ctx->Driver.UseProgram(ctx, shProg);
1013 }
1014
1015
1016 /**
1017  * Validate a program's samplers.
1018  * Specifically, check that there aren't two samplers of different types
1019  * pointing to the same texture unit.
1020  * \return GL_TRUE if valid, GL_FALSE if invalid
1021  */
1022 static GLboolean
1023 validate_samplers(const struct gl_program *prog, char *errMsg)
1024 {
1025    static const char *targetName[] = {
1026       "TEXTURE_BUFFER",
1027       "TEXTURE_2D_ARRAY",
1028       "TEXTURE_1D_ARRAY",
1029       "TEXTURE_CUBE",
1030       "TEXTURE_3D",
1031       "TEXTURE_RECT",
1032       "TEXTURE_2D",
1033       "TEXTURE_1D",
1034    };
1035    GLint targetUsed[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
1036    GLbitfield samplersUsed = prog->SamplersUsed;
1037    GLuint i;
1038
1039    assert(Elements(targetName) == NUM_TEXTURE_TARGETS);
1040
1041    if (samplersUsed == 0x0)
1042       return GL_TRUE;
1043
1044    for (i = 0; i < Elements(targetUsed); i++)
1045       targetUsed[i] = -1;
1046
1047    /* walk over bits which are set in 'samplers' */
1048    while (samplersUsed) {
1049       GLuint unit;
1050       gl_texture_index target;
1051       GLint sampler = _mesa_ffs(samplersUsed) - 1;
1052       assert(sampler >= 0);
1053       assert(sampler < Elements(prog->SamplerUnits));
1054       unit = prog->SamplerUnits[sampler];
1055       target = prog->SamplerTargets[sampler];
1056       if (targetUsed[unit] != -1 && targetUsed[unit] != (int) target) {
1057          _mesa_snprintf(errMsg, 100,
1058                   "Texture unit %d is accessed both as %s and %s",
1059                   unit, targetName[targetUsed[unit]], targetName[target]);
1060          return GL_FALSE;
1061       }
1062       targetUsed[unit] = target;
1063       samplersUsed ^= (1 << sampler);
1064    }
1065
1066    return GL_TRUE;
1067 }
1068
1069
1070 /**
1071  * Do validation of the given shader program.
1072  * \param errMsg  returns error message if validation fails.
1073  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1074  */
1075 static GLboolean
1076 validate_shader_program(const struct gl_shader_program *shProg,
1077                         char *errMsg)
1078 {
1079    const struct gl_vertex_program *vp = shProg->VertexProgram;
1080    const struct gl_geometry_program *gp = shProg->GeometryProgram;
1081    const struct gl_fragment_program *fp = shProg->FragmentProgram;
1082
1083    if (!shProg->LinkStatus) {
1084       return GL_FALSE;
1085    }
1086
1087    /* From the GL spec, a program is invalid if any of these are true:
1088
1089      any two active samplers in the current program object are of
1090      different types, but refer to the same texture image unit,
1091
1092      any active sampler in the current program object refers to a texture
1093      image unit where fixed-function fragment processing accesses a
1094      texture target that does not match the sampler type, or
1095
1096      the sum of the number of active samplers in the program and the
1097      number of texture image units enabled for fixed-function fragment
1098      processing exceeds the combined limit on the total number of texture
1099      image units allowed.
1100    */
1101
1102
1103    /*
1104     * Check: any two active samplers in the current program object are of
1105     * different types, but refer to the same texture image unit,
1106     */
1107    if (vp && !validate_samplers(&vp->Base, errMsg)) {
1108       return GL_FALSE;
1109    }
1110    if (gp && !validate_samplers(&gp->Base, errMsg)) {
1111       return GL_FALSE;
1112    }
1113    if (fp && !validate_samplers(&fp->Base, errMsg)) {
1114       return GL_FALSE;
1115    }
1116
1117    return GL_TRUE;
1118 }
1119
1120
1121 /**
1122  * Called via glValidateProgram()
1123  */
1124 static void
1125 validate_program(struct gl_context *ctx, GLuint program)
1126 {
1127    struct gl_shader_program *shProg;
1128    char errMsg[100] = "";
1129
1130    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1131    if (!shProg) {
1132       return;
1133    }
1134
1135    shProg->Validated = validate_shader_program(shProg, errMsg);
1136    if (!shProg->Validated) {
1137       /* update info log */
1138       if (shProg->InfoLog) {
1139          ralloc_free(shProg->InfoLog);
1140       }
1141       shProg->InfoLog = ralloc_strdup(shProg, errMsg);
1142    }
1143 }
1144
1145
1146
1147 void GLAPIENTRY
1148 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
1149 {
1150    GET_CURRENT_CONTEXT(ctx);
1151    attach_shader(ctx, program, shader);
1152 }
1153
1154
1155 void GLAPIENTRY
1156 _mesa_AttachShader(GLuint program, GLuint shader)
1157 {
1158    GET_CURRENT_CONTEXT(ctx);
1159    attach_shader(ctx, program, shader);
1160 }
1161
1162
1163 void GLAPIENTRY
1164 _mesa_BindAttribLocationARB(GLhandleARB program, GLuint index,
1165                             const GLcharARB *name)
1166 {
1167    GET_CURRENT_CONTEXT(ctx);
1168    bind_attrib_location(ctx, program, index, name);
1169 }
1170
1171
1172 /* GL_EXT_gpu_shader4, GL3 */
1173 void GLAPIENTRY
1174 _mesa_BindFragDataLocation(GLuint program, GLuint colorNumber,
1175                            const GLchar *name)
1176 {
1177    GET_CURRENT_CONTEXT(ctx);
1178    bind_frag_data_location(ctx, program, colorNumber, name);
1179 }
1180
1181
1182 void GLAPIENTRY
1183 _mesa_CompileShaderARB(GLhandleARB shaderObj)
1184 {
1185    GET_CURRENT_CONTEXT(ctx);
1186    if (MESA_VERBOSE & VERBOSE_API)
1187       _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1188    compile_shader(ctx, shaderObj);
1189 }
1190
1191
1192 GLuint GLAPIENTRY
1193 _mesa_CreateShader(GLenum type)
1194 {
1195    GET_CURRENT_CONTEXT(ctx);
1196    if (MESA_VERBOSE & VERBOSE_API)
1197       _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));
1198    return create_shader(ctx, type);
1199 }
1200
1201
1202 GLhandleARB GLAPIENTRY
1203 _mesa_CreateShaderObjectARB(GLenum type)
1204 {
1205    GET_CURRENT_CONTEXT(ctx);
1206    return create_shader(ctx, type);
1207 }
1208
1209
1210 GLuint GLAPIENTRY
1211 _mesa_CreateProgram(void)
1212 {
1213    GET_CURRENT_CONTEXT(ctx);
1214    if (MESA_VERBOSE & VERBOSE_API)
1215       _mesa_debug(ctx, "glCreateProgram\n");
1216    return create_shader_program(ctx);
1217 }
1218
1219
1220 GLhandleARB GLAPIENTRY
1221 _mesa_CreateProgramObjectARB(void)
1222 {
1223    GET_CURRENT_CONTEXT(ctx);
1224    return create_shader_program(ctx);
1225 }
1226
1227
1228 void GLAPIENTRY
1229 _mesa_DeleteObjectARB(GLhandleARB obj)
1230 {
1231    if (MESA_VERBOSE & VERBOSE_API) {
1232       GET_CURRENT_CONTEXT(ctx);
1233       _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);
1234    }
1235
1236    if (obj) {
1237       GET_CURRENT_CONTEXT(ctx);
1238       FLUSH_VERTICES(ctx, 0);
1239       if (is_program(ctx, obj)) {
1240          delete_shader_program(ctx, obj);
1241       }
1242       else if (is_shader(ctx, obj)) {
1243          delete_shader(ctx, obj);
1244       }
1245       else {
1246          /* error? */
1247       }
1248    }
1249 }
1250
1251
1252 void GLAPIENTRY
1253 _mesa_DeleteProgram(GLuint name)
1254 {
1255    if (name) {
1256       GET_CURRENT_CONTEXT(ctx);
1257       FLUSH_VERTICES(ctx, 0);
1258       delete_shader_program(ctx, name);
1259    }
1260 }
1261
1262
1263 void GLAPIENTRY
1264 _mesa_DeleteShader(GLuint name)
1265 {
1266    if (name) {
1267       GET_CURRENT_CONTEXT(ctx);
1268       FLUSH_VERTICES(ctx, 0);
1269       delete_shader(ctx, name);
1270    }
1271 }
1272
1273
1274 void GLAPIENTRY
1275 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1276 {
1277    GET_CURRENT_CONTEXT(ctx);
1278    detach_shader(ctx, program, shader);
1279 }
1280
1281
1282 void GLAPIENTRY
1283 _mesa_DetachShader(GLuint program, GLuint shader)
1284 {
1285    GET_CURRENT_CONTEXT(ctx);
1286    detach_shader(ctx, program, shader);
1287 }
1288
1289
1290 void GLAPIENTRY
1291 _mesa_GetActiveAttribARB(GLhandleARB program, GLuint index,
1292                          GLsizei maxLength, GLsizei * length, GLint * size,
1293                          GLenum * type, GLcharARB * name)
1294 {
1295    GET_CURRENT_CONTEXT(ctx);
1296    get_active_attrib(ctx, program, index, maxLength, length, size, type, name);
1297 }
1298
1299
1300 void GLAPIENTRY
1301 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1302                             GLsizei * count, GLhandleARB * obj)
1303 {
1304    GET_CURRENT_CONTEXT(ctx);
1305    get_attached_shaders(ctx, container, maxCount, count, obj);
1306 }
1307
1308
1309 void GLAPIENTRY
1310 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1311                          GLsizei *count, GLuint *obj)
1312 {
1313    GET_CURRENT_CONTEXT(ctx);
1314    get_attached_shaders(ctx, program, maxCount, count, obj);
1315 }
1316
1317
1318 GLint GLAPIENTRY
1319 _mesa_GetAttribLocationARB(GLhandleARB program, const GLcharARB * name)
1320 {
1321    GET_CURRENT_CONTEXT(ctx);
1322    return get_attrib_location(ctx, program, name);
1323 }
1324
1325
1326 /* GL_EXT_gpu_shader4, GL3 */
1327 GLint GLAPIENTRY
1328 _mesa_GetFragDataLocation(GLuint program, const GLchar *name)
1329 {
1330    GET_CURRENT_CONTEXT(ctx);
1331    return get_frag_data_location(ctx, program, name);
1332 }
1333
1334
1335
1336 void GLAPIENTRY
1337 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1338                     GLcharARB * infoLog)
1339 {
1340    GET_CURRENT_CONTEXT(ctx);
1341    if (is_program(ctx, object)) {
1342       get_program_info_log(ctx, object, maxLength, length, infoLog);
1343    }
1344    else if (is_shader(ctx, object)) {
1345       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1346    }
1347    else {
1348       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1349    }
1350 }
1351
1352
1353 void GLAPIENTRY
1354 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1355 {
1356    GET_CURRENT_CONTEXT(ctx);
1357    /* Implement in terms of GetProgramiv, GetShaderiv */
1358    if (is_program(ctx, object)) {
1359       if (pname == GL_OBJECT_TYPE_ARB) {
1360          *params = GL_PROGRAM_OBJECT_ARB;
1361       }
1362       else {
1363          get_programiv(ctx, object, pname, params);
1364       }
1365    }
1366    else if (is_shader(ctx, object)) {
1367       if (pname == GL_OBJECT_TYPE_ARB) {
1368          *params = GL_SHADER_OBJECT_ARB;
1369       }
1370       else {
1371          get_shaderiv(ctx, object, pname, params);
1372       }
1373    }
1374    else {
1375       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1376    }
1377 }
1378
1379
1380 void GLAPIENTRY
1381 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1382                               GLfloat *params)
1383 {
1384    GLint iparams[1];  /* XXX is one element enough? */
1385    _mesa_GetObjectParameterivARB(object, pname, iparams);
1386    params[0] = (GLfloat) iparams[0];
1387 }
1388
1389
1390 void GLAPIENTRY
1391 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1392 {
1393    GET_CURRENT_CONTEXT(ctx);
1394    get_programiv(ctx, program, pname, params);
1395 }
1396
1397
1398 void GLAPIENTRY
1399 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1400 {
1401    GET_CURRENT_CONTEXT(ctx);
1402    get_shaderiv(ctx, shader, pname, params);
1403 }
1404
1405
1406 void GLAPIENTRY
1407 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1408                         GLsizei *length, GLchar *infoLog)
1409 {
1410    GET_CURRENT_CONTEXT(ctx);
1411    get_program_info_log(ctx, program, bufSize, length, infoLog);
1412 }
1413
1414
1415 void GLAPIENTRY
1416 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1417                        GLsizei *length, GLchar *infoLog)
1418 {
1419    GET_CURRENT_CONTEXT(ctx);
1420    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1421 }
1422
1423
1424 void GLAPIENTRY
1425 _mesa_GetShaderSourceARB(GLhandleARB shader, GLsizei maxLength,
1426                          GLsizei *length, GLcharARB *sourceOut)
1427 {
1428    GET_CURRENT_CONTEXT(ctx);
1429    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1430 }
1431
1432
1433 GLhandleARB GLAPIENTRY
1434 _mesa_GetHandleARB(GLenum pname)
1435 {
1436    GET_CURRENT_CONTEXT(ctx);
1437    return get_handle(ctx, pname);
1438 }
1439
1440
1441 GLboolean GLAPIENTRY
1442 _mesa_IsProgram(GLuint name)
1443 {
1444    GET_CURRENT_CONTEXT(ctx);
1445    return is_program(ctx, name);
1446 }
1447
1448
1449 GLboolean GLAPIENTRY
1450 _mesa_IsShader(GLuint name)
1451 {
1452    GET_CURRENT_CONTEXT(ctx);
1453    return is_shader(ctx, name);
1454 }
1455
1456
1457 void GLAPIENTRY
1458 _mesa_LinkProgramARB(GLhandleARB programObj)
1459 {
1460    GET_CURRENT_CONTEXT(ctx);
1461    link_program(ctx, programObj);
1462 }
1463
1464
1465
1466 /**
1467  * Read shader source code from a file.
1468  * Useful for debugging to override an app's shader.
1469  */
1470 static GLcharARB *
1471 read_shader(const char *fname)
1472 {
1473    const int max = 50*1000;
1474    FILE *f = fopen(fname, "r");
1475    GLcharARB *buffer, *shader;
1476    int len;
1477
1478    if (!f) {
1479       return NULL;
1480    }
1481
1482    buffer = (char *) malloc(max);
1483    len = fread(buffer, 1, max, f);
1484    buffer[len] = 0;
1485
1486    fclose(f);
1487
1488    shader = _mesa_strdup(buffer);
1489    free(buffer);
1490
1491    return shader;
1492 }
1493
1494
1495 /**
1496  * Called via glShaderSource() and glShaderSourceARB() API functions.
1497  * Basically, concatenate the source code strings into one long string
1498  * and pass it to _mesa_shader_source().
1499  */
1500 void GLAPIENTRY
1501 _mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
1502                       const GLcharARB ** string, const GLint * length)
1503 {
1504    GET_CURRENT_CONTEXT(ctx);
1505    GLint *offsets;
1506    GLsizei i, totalLength;
1507    GLcharARB *source;
1508    GLuint checksum;
1509
1510    if (!shaderObj || string == NULL) {
1511       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1512       return;
1513    }
1514
1515    /*
1516     * This array holds offsets of where the appropriate string ends, thus the
1517     * last element will be set to the total length of the source code.
1518     */
1519    offsets = (GLint *) malloc(count * sizeof(GLint));
1520    if (offsets == NULL) {
1521       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1522       return;
1523    }
1524
1525    for (i = 0; i < count; i++) {
1526       if (string[i] == NULL) {
1527          free((GLvoid *) offsets);
1528          _mesa_error(ctx, GL_INVALID_OPERATION,
1529                      "glShaderSourceARB(null string)");
1530          return;
1531       }
1532       if (length == NULL || length[i] < 0)
1533          offsets[i] = strlen(string[i]);
1534       else
1535          offsets[i] = length[i];
1536       /* accumulate string lengths */
1537       if (i > 0)
1538          offsets[i] += offsets[i - 1];
1539    }
1540
1541    /* Total length of source string is sum off all strings plus two.
1542     * One extra byte for terminating zero, another extra byte to silence
1543     * valgrind warnings in the parser/grammer code.
1544     */
1545    totalLength = offsets[count - 1] + 2;
1546    source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB));
1547    if (source == NULL) {
1548       free((GLvoid *) offsets);
1549       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1550       return;
1551    }
1552
1553    for (i = 0; i < count; i++) {
1554       GLint start = (i > 0) ? offsets[i - 1] : 0;
1555       memcpy(source + start, string[i],
1556              (offsets[i] - start) * sizeof(GLcharARB));
1557    }
1558    source[totalLength - 1] = '\0';
1559    source[totalLength - 2] = '\0';
1560
1561    if (SHADER_SUBST) {
1562       /* Compute the shader's source code checksum then try to open a file
1563        * named newshader_<CHECKSUM>.  If it exists, use it in place of the
1564        * original shader source code.  For debugging.
1565        */
1566       char filename[100];
1567       GLcharARB *newSource;
1568
1569       checksum = _mesa_str_checksum(source);
1570
1571       _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
1572
1573       newSource = read_shader(filename);
1574       if (newSource) {
1575          fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
1576                        shaderObj, checksum, filename);
1577          free(source);
1578          source = newSource;
1579       }
1580    }
1581
1582    shader_source(ctx, shaderObj, source);
1583
1584    if (SHADER_SUBST) {
1585       struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
1586       if (sh)
1587          sh->SourceChecksum = checksum; /* save original checksum */
1588    }
1589
1590    free(offsets);
1591 }
1592
1593
1594 void GLAPIENTRY
1595 _mesa_UseProgramObjectARB(GLhandleARB program)
1596 {
1597    GET_CURRENT_CONTEXT(ctx);
1598    struct gl_shader_program *shProg;
1599    struct gl_transform_feedback_object *obj =
1600       ctx->TransformFeedback.CurrentObject;
1601
1602    ASSERT_OUTSIDE_BEGIN_END(ctx);
1603
1604    if (obj->Active) {
1605       _mesa_error(ctx, GL_INVALID_OPERATION,
1606                   "glUseProgram(transform feedback active)");
1607       return;
1608    }
1609
1610    if (program) {
1611       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1612       if (!shProg) {
1613          return;
1614       }
1615       if (!shProg->LinkStatus) {
1616          _mesa_error(ctx, GL_INVALID_OPERATION,
1617                      "glUseProgram(program %u not linked)", program);
1618          return;
1619       }
1620
1621       /* debug code */
1622       if (ctx->Shader.Flags & GLSL_USE_PROG) {
1623          print_shader_info(shProg);
1624       }
1625    }
1626    else {
1627       shProg = NULL;
1628    }
1629
1630    _mesa_use_program(ctx, shProg);
1631 }
1632
1633
1634 void GLAPIENTRY
1635 _mesa_ValidateProgramARB(GLhandleARB program)
1636 {
1637    GET_CURRENT_CONTEXT(ctx);
1638    validate_program(ctx, program);
1639 }
1640
1641 #ifdef FEATURE_ES2
1642
1643 void GLAPIENTRY
1644 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1645                                GLint* range, GLint* precision)
1646 {
1647    const struct gl_program_constants *limits;
1648    const struct gl_precision *p;
1649    GET_CURRENT_CONTEXT(ctx);
1650
1651    switch (shadertype) {
1652    case GL_VERTEX_SHADER:
1653       limits = &ctx->Const.VertexProgram;
1654       break;
1655    case GL_FRAGMENT_SHADER:
1656       limits = &ctx->Const.FragmentProgram;
1657       break;
1658    default:
1659       _mesa_error(ctx, GL_INVALID_ENUM,
1660                   "glGetShaderPrecisionFormat(shadertype)");
1661       return;
1662    }
1663
1664    switch (precisiontype) {
1665    case GL_LOW_FLOAT:
1666       p = &limits->LowFloat;
1667       break;
1668    case GL_MEDIUM_FLOAT:
1669       p = &limits->MediumFloat;
1670       break;
1671    case GL_HIGH_FLOAT:
1672       p = &limits->HighFloat;
1673       break;
1674    case GL_LOW_INT:
1675       p = &limits->LowInt;
1676       break;
1677    case GL_MEDIUM_INT:
1678       p = &limits->MediumInt;
1679       break;
1680    case GL_HIGH_INT:
1681       p = &limits->HighInt;
1682       break;
1683    default:
1684       _mesa_error(ctx, GL_INVALID_ENUM,
1685                   "glGetShaderPrecisionFormat(precisiontype)");
1686       return;
1687    }
1688
1689    range[0] = p->RangeMin;
1690    range[1] = p->RangeMax;
1691    precision[0] = p->Precision;
1692 }
1693
1694
1695 void GLAPIENTRY
1696 _mesa_ReleaseShaderCompiler(void)
1697 {
1698    _mesa_destroy_shader_compiler_caches();
1699 }
1700
1701
1702 void GLAPIENTRY
1703 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1704                    const void* binary, GLint length)
1705 {
1706    GET_CURRENT_CONTEXT(ctx);
1707    (void) n;
1708    (void) shaders;
1709    (void) binaryformat;
1710    (void) binary;
1711    (void) length;
1712    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1713 }
1714
1715 #endif /* FEATURE_ES2 */
1716
1717
1718 #if FEATURE_ARB_geometry_shader4
1719
1720 void GLAPIENTRY
1721 _mesa_ProgramParameteriARB(GLuint program, GLenum pname, GLint value)
1722 {
1723    struct gl_shader_program *shProg;
1724    GET_CURRENT_CONTEXT(ctx);
1725
1726    ASSERT_OUTSIDE_BEGIN_END(ctx);
1727
1728    shProg = _mesa_lookup_shader_program_err(ctx, program,
1729                                             "glProgramParameteri");
1730    if (!shProg)
1731       return;
1732
1733    switch (pname) {
1734    case GL_GEOMETRY_VERTICES_OUT_ARB:
1735       if (value < 1 ||
1736           (unsigned) value > ctx->Const.MaxGeometryOutputVertices) {
1737          _mesa_error(ctx, GL_INVALID_VALUE,
1738                      "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1739                      value);
1740          return;
1741       }
1742       shProg->Geom.VerticesOut = value;
1743       break;
1744    case GL_GEOMETRY_INPUT_TYPE_ARB:
1745       switch (value) {
1746       case GL_POINTS:
1747       case GL_LINES:
1748       case GL_LINES_ADJACENCY_ARB:
1749       case GL_TRIANGLES:
1750       case GL_TRIANGLES_ADJACENCY_ARB:
1751          shProg->Geom.InputType = value;
1752          break;
1753       default:
1754          _mesa_error(ctx, GL_INVALID_VALUE,
1755                      "glProgramParameteri(geometry input type = %s",
1756                      _mesa_lookup_enum_by_nr(value));
1757          return;
1758       }
1759       break;
1760    case GL_GEOMETRY_OUTPUT_TYPE_ARB:
1761       switch (value) {
1762       case GL_POINTS:
1763       case GL_LINE_STRIP:
1764       case GL_TRIANGLE_STRIP:
1765          shProg->Geom.OutputType = value;
1766          break;
1767       default:
1768          _mesa_error(ctx, GL_INVALID_VALUE,
1769                      "glProgramParameteri(geometry output type = %s",
1770                      _mesa_lookup_enum_by_nr(value));
1771          return;
1772       }
1773       break;
1774    default:
1775       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteriARB(pname=%s)",
1776                   _mesa_lookup_enum_by_nr(pname));
1777       break;
1778    }
1779 }
1780
1781 #endif
1782
1783 void
1784 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
1785                          struct gl_shader_program *shProg)
1786 {
1787    use_shader_program(ctx, type, shProg);
1788
1789    if (ctx->Driver.UseProgram)
1790       ctx->Driver.UseProgram(ctx, shProg);
1791 }
1792
1793 void GLAPIENTRY
1794 _mesa_UseShaderProgramEXT(GLenum type, GLuint program)
1795 {
1796    GET_CURRENT_CONTEXT(ctx);
1797    struct gl_shader_program *shProg = NULL;
1798
1799    ASSERT_OUTSIDE_BEGIN_END(ctx);
1800
1801    if (!validate_shader_target(ctx, type)) {
1802       _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");
1803       return;
1804    }
1805
1806    if (ctx->TransformFeedback.CurrentObject->Active) {
1807       _mesa_error(ctx, GL_INVALID_OPERATION,
1808                   "glUseShaderProgramEXT(transform feedback is active)");
1809       return;
1810    }
1811
1812    if (program) {
1813       shProg = _mesa_lookup_shader_program_err(ctx, program,
1814                                                "glUseShaderProgramEXT");
1815       if (shProg == NULL)
1816          return;
1817
1818       if (!shProg->LinkStatus) {
1819          _mesa_error(ctx, GL_INVALID_OPERATION,
1820                      "glUseShaderProgramEXT(program not linked)");
1821          return;
1822       }
1823    }
1824
1825    _mesa_use_shader_program(ctx, type, shProg);
1826 }
1827
1828 void GLAPIENTRY
1829 _mesa_ActiveProgramEXT(GLuint program)
1830 {
1831    GET_CURRENT_CONTEXT(ctx);
1832    struct gl_shader_program *shProg = (program != 0)
1833       ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
1834       : NULL;
1835
1836    _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
1837    return;
1838 }
1839
1840 GLuint GLAPIENTRY
1841 _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
1842 {
1843    GET_CURRENT_CONTEXT(ctx);
1844    const GLuint shader = create_shader(ctx, type);
1845    GLuint program = 0;
1846
1847    if (shader) {
1848       shader_source(ctx, shader, _mesa_strdup(string));
1849       compile_shader(ctx, shader);
1850
1851       program = create_shader_program(ctx);
1852       if (program) {
1853          struct gl_shader_program *shProg;
1854          struct gl_shader *sh;
1855          GLint compiled = GL_FALSE;
1856
1857          shProg = _mesa_lookup_shader_program(ctx, program);
1858          sh = _mesa_lookup_shader(ctx, shader);
1859
1860          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
1861          if (compiled) {
1862             attach_shader(ctx, program, shader);
1863             link_program(ctx, program);
1864             detach_shader(ctx, program, shader);
1865
1866 #if 0
1867             /* Possibly... */
1868             if (active-user-defined-varyings-in-linked-program) {
1869                append-error-to-info-log;
1870                shProg->LinkStatus = GL_FALSE;
1871             }
1872 #endif
1873          }
1874
1875          ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
1876       }
1877
1878       delete_shader(ctx, shader);
1879    }
1880
1881    return program;
1882 }
1883
1884 /**
1885  * Plug in shader-related functions into API dispatch table.
1886  */
1887 void
1888 _mesa_init_shader_dispatch(struct _glapi_table *exec)
1889 {
1890 #if FEATURE_GL
1891    /* GL_ARB_vertex/fragment_shader */
1892    SET_DeleteObjectARB(exec, _mesa_DeleteObjectARB);
1893    SET_GetHandleARB(exec, _mesa_GetHandleARB);
1894    SET_DetachObjectARB(exec, _mesa_DetachObjectARB);
1895    SET_CreateShaderObjectARB(exec, _mesa_CreateShaderObjectARB);
1896    SET_ShaderSourceARB(exec, _mesa_ShaderSourceARB);
1897    SET_CompileShaderARB(exec, _mesa_CompileShaderARB);
1898    SET_CreateProgramObjectARB(exec, _mesa_CreateProgramObjectARB);
1899    SET_AttachObjectARB(exec, _mesa_AttachObjectARB);
1900    SET_LinkProgramARB(exec, _mesa_LinkProgramARB);
1901    SET_UseProgramObjectARB(exec, _mesa_UseProgramObjectARB);
1902    SET_ValidateProgramARB(exec, _mesa_ValidateProgramARB);
1903    SET_GetObjectParameterfvARB(exec, _mesa_GetObjectParameterfvARB);
1904    SET_GetObjectParameterivARB(exec, _mesa_GetObjectParameterivARB);
1905    SET_GetInfoLogARB(exec, _mesa_GetInfoLogARB);
1906    SET_GetAttachedObjectsARB(exec, _mesa_GetAttachedObjectsARB);
1907    SET_GetShaderSourceARB(exec, _mesa_GetShaderSourceARB);
1908
1909    /* OpenGL 2.0 */
1910    SET_AttachShader(exec, _mesa_AttachShader);
1911    SET_CreateProgram(exec, _mesa_CreateProgram);
1912    SET_CreateShader(exec, _mesa_CreateShader);
1913    SET_DeleteProgram(exec, _mesa_DeleteProgram);
1914    SET_DeleteShader(exec, _mesa_DeleteShader);
1915    SET_DetachShader(exec, _mesa_DetachShader);
1916    SET_GetAttachedShaders(exec, _mesa_GetAttachedShaders);
1917    SET_GetProgramiv(exec, _mesa_GetProgramiv);
1918    SET_GetProgramInfoLog(exec, _mesa_GetProgramInfoLog);
1919    SET_GetShaderiv(exec, _mesa_GetShaderiv);
1920    SET_GetShaderInfoLog(exec, _mesa_GetShaderInfoLog);
1921    SET_IsProgram(exec, _mesa_IsProgram);
1922    SET_IsShader(exec, _mesa_IsShader);
1923
1924 #if FEATURE_ARB_vertex_shader
1925    SET_BindAttribLocationARB(exec, _mesa_BindAttribLocationARB);
1926    SET_GetActiveAttribARB(exec, _mesa_GetActiveAttribARB);
1927    SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB);
1928 #endif
1929
1930 #if FEATURE_ARB_geometry_shader4
1931    SET_ProgramParameteriARB(exec, _mesa_ProgramParameteriARB);
1932 #endif
1933
1934    SET_UseShaderProgramEXT(exec, _mesa_UseShaderProgramEXT);
1935    SET_ActiveProgramEXT(exec, _mesa_ActiveProgramEXT);
1936    SET_CreateShaderProgramEXT(exec, _mesa_CreateShaderProgramEXT);
1937
1938    /* GL_EXT_gpu_shader4 / GL 3.0 */
1939    SET_BindFragDataLocationEXT(exec, _mesa_BindFragDataLocation);
1940    SET_GetFragDataLocationEXT(exec, _mesa_GetFragDataLocation);
1941
1942    /* GL_ARB_ES2_compatibility */
1943    SET_ReleaseShaderCompiler(exec, _mesa_ReleaseShaderCompiler);
1944    SET_GetShaderPrecisionFormat(exec, _mesa_GetShaderPrecisionFormat);
1945
1946 #endif /* FEATURE_GL */
1947 }
1948