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 "talloc.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, oldIndex;
 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    if (shProg->LinkStatus) {
 389       /* get current index/location for the attribute */
 390       oldIndex = get_attrib_location(ctx, program, name);
 391    }
 392    else {
 393       oldIndex = -1;
 394    }
 395
 396    /* this will replace the current value if it's already in the list */
 397    i = _mesa_add_attribute(shProg->Attributes, name, size, datatype, index);
 398    if (i < 0) {
 399       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");
 400       return;
 401    }
 402
 403    /*
 404     * Note that this attribute binding won't go into effect until
 405     * glLinkProgram is called again.
 406     */
 407 }
 408
 409
 410 static void
 411 bind_frag_data_location(struct gl_context *ctx, GLuint program,
 412                         GLuint colorNumber, const GLchar *name)
 413 {
 414    _mesa_problem(ctx, "bind_frag_data_location() not implemented yet");
 415 }
 416
 417
 418 static GLuint
 419 create_shader(struct gl_context *ctx, GLenum type)
 420 {
 421    struct gl_shader *sh;
 422    GLuint name;
 423
 424    if (!validate_shader_target(ctx, type)) {
 425       _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
 426       return 0;
 427    }
 428
 429    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 430    sh = ctx->Driver.NewShader(ctx, name, type);
 431    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
 432
 433    return name;
 434 }
 435
 436
 437 static GLuint
 438 create_shader_program(struct gl_context *ctx)
 439 {
 440    GLuint name;
 441    struct gl_shader_program *shProg;
 442
 443    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 444
 445    shProg = ctx->Driver.NewShaderProgram(ctx, name);
 446
 447    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);
 448
 449    assert(shProg->RefCount == 1);
 450
 451    return name;
 452 }
 453
 454
 455 /**
 456  * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
 457  * DeleteProgramARB.
 458  */
 459 static void
 460 delete_shader_program(struct gl_context *ctx, GLuint name)
 461 {
 462    /*
 463     * NOTE: deleting shaders/programs works a bit differently than
 464     * texture objects (and buffer objects, etc).  Shader/program
 465     * handles/IDs exist in the hash table until the object is really
 466     * deleted (refcount==0).  With texture objects, the handle/ID is
 467     * removed from the hash table in glDeleteTextures() while the tex
 468     * object itself might linger until its refcount goes to zero.
 469     */
 470    struct gl_shader_program *shProg;
 471
 472    shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
 473    if (!shProg)
 474       return;
 475
 476    shProg->DeletePending = GL_TRUE;
 477
 478    /* effectively, decr shProg's refcount */
 479    _mesa_reference_shader_program(ctx, &shProg, NULL);
 480 }
 481
 482
 483 static void
 484 delete_shader(struct gl_context *ctx, GLuint shader)
 485 {
 486    struct gl_shader *sh;
 487
 488    sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
 489    if (!sh)
 490       return;
 491
 492    sh->DeletePending = GL_TRUE;
 493
 494    /* effectively, decr sh's refcount */
 495    _mesa_reference_shader(ctx, &sh, NULL);
 496 }
 497
 498
 499 static void
 500 detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
 501 {
 502    struct gl_shader_program *shProg;
 503    GLuint n;
 504    GLuint i, j;
 505
 506    shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
 507    if (!shProg)
 508       return;
 509
 510    n = shProg->NumShaders;
 511
 512    for (i = 0; i < n; i++) {
 513       if (shProg->Shaders[i]->Name == shader) {
 514          /* found it */
 515          struct gl_shader **newList;
 516
 517          /* release */
 518          _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
 519
 520          /* alloc new, smaller array */
 521          newList = (struct gl_shader **)
 522             malloc((n - 1) * sizeof(struct gl_shader *));
 523          if (!newList) {
 524             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
 525             return;
 526          }
 527          for (j = 0; j < i; j++) {
 528             newList[j] = shProg->Shaders[j];
 529          }
 530          while (++i < n)
 531             newList[j++] = shProg->Shaders[i];
 532          free(shProg->Shaders);
 533
 534          shProg->Shaders = newList;
 535          shProg->NumShaders = n - 1;
 536
 537 #ifdef DEBUG
 538          /* sanity check */
 539          {
 540             for (j = 0; j < shProg->NumShaders; j++) {
 541                assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
 542                       shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
 543                assert(shProg->Shaders[j]->RefCount > 0);
 544             }
 545          }
 546 #endif
 547
 548          return;
 549       }
 550    }
 551
 552    /* not found */
 553    {
 554       GLenum err;
 555       if (is_shader(ctx, shader))
 556          err = GL_INVALID_OPERATION;
 557       else if (is_program(ctx, shader))
 558          err = GL_INVALID_OPERATION;
 559       else
 560          err = GL_INVALID_VALUE;
 561       _mesa_error(ctx, err, "glDetachProgram(shader)");
 562       return;
 563    }
 564 }
 565
 566
 567 static void
 568 get_active_attrib(struct gl_context *ctx, GLuint program, GLuint index,
 569                   GLsizei maxLength, GLsizei *length, GLint *size,
 570                   GLenum *type, GLchar *nameOut)
 571 {
 572    const struct gl_program_parameter_list *attribs = NULL;
 573    struct gl_shader_program *shProg;
 574
 575    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");
 576    if (!shProg)
 577       return;
 578
 579    if (shProg->VertexProgram)
 580       attribs = shProg->VertexProgram->Base.Attributes;
 581
 582    if (!attribs || index >= attribs->NumParameters) {
 583       _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
 584       return;
 585    }
 586
 587    _mesa_copy_string(nameOut, maxLength, length,
 588                      attribs->Parameters[index].Name);
 589
 590    if (size)
 591       *size = attribs->Parameters[index].Size
 592          / _mesa_sizeof_glsl_type(attribs->Parameters[index].DataType);
 593
 594    if (type)
 595       *type = attribs->Parameters[index].DataType;
 596 }
 597
 598
 599 /**
 600  * Return list of shaders attached to shader program.
 601  */
 602 static void
 603 get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,
 604                      GLsizei *count, GLuint *obj)
 605 {
 606    struct gl_shader_program *shProg =
 607       _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
 608    if (shProg) {
 609       GLuint i;
 610       for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {
 611          obj[i] = shProg->Shaders[i]->Name;
 612       }
 613       if (count)
 614          *count = i;
 615    }
 616 }
 617
 618
 619 static GLint
 620 get_frag_data_location(struct gl_context *ctx, GLuint program,
 621                        const GLchar *name)
 622 {
 623    _mesa_problem(ctx, "get_frag_data_location() not implemented yet");
 624    return -1;
 625 }
 626
 627
 628
 629 /**
 630  * glGetHandleARB() - return ID/name of currently bound shader program.
 631  */
 632 static GLuint
 633 get_handle(struct gl_context *ctx, GLenum pname)
 634 {
 635    if (pname == GL_PROGRAM_OBJECT_ARB) {
 636       if (ctx->Shader.ActiveProgram)
 637          return ctx->Shader.ActiveProgram->Name;
 638       else
 639          return 0;
 640    }
 641    else {
 642       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
 643       return 0;
 644    }
 645 }
 646
 647
 648 /**
 649  * glGetProgramiv() - get shader program state.
 650  * Note that this is for GLSL shader programs, not ARB vertex/fragment
 651  * programs (see glGetProgramivARB).
 652  */
 653 static void
 654 get_programiv(struct gl_context *ctx, GLuint program, GLenum pname, GLint *params)
 655 {
 656    const struct gl_program_parameter_list *attribs;
 657    struct gl_shader_program *shProg
 658       = _mesa_lookup_shader_program(ctx, program);
 659
 660    if (!shProg) {
 661       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
 662       return;
 663    }
 664
 665    if (shProg->VertexProgram)
 666       attribs = shProg->VertexProgram->Base.Attributes;
 667    else
 668       attribs = NULL;
 669
 670    switch (pname) {
 671    case GL_DELETE_STATUS:
 672       *params = shProg->DeletePending;
 673       break;
 674    case GL_LINK_STATUS:
 675       *params = shProg->LinkStatus;
 676       break;
 677    case GL_VALIDATE_STATUS:
 678       *params = shProg->Validated;
 679       break;
 680    case GL_INFO_LOG_LENGTH:
 681       *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
 682       break;
 683    case GL_ATTACHED_SHADERS:
 684       *params = shProg->NumShaders;
 685       break;
 686    case GL_ACTIVE_ATTRIBUTES:
 687       *params = attribs ? attribs->NumParameters : 0;
 688       break;
 689    case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
 690       *params = _mesa_longest_parameter_name(attribs, PROGRAM_INPUT) + 1;
 691       break;
 692    case GL_ACTIVE_UNIFORMS:
 693       *params = shProg->Uniforms ? shProg->Uniforms->NumUniforms : 0;
 694       break;
 695    case GL_ACTIVE_UNIFORM_MAX_LENGTH:
 696       *params = _mesa_longest_uniform_name(shProg->Uniforms);
 697       if (*params > 0)
 698          (*params)++;  /* add one for terminating zero */
 699       break;
 700    case GL_PROGRAM_BINARY_LENGTH_OES:
 701       *params = 0;
 702       break;
 703 #if FEATURE_EXT_transform_feedback
 704    case GL_TRANSFORM_FEEDBACK_VARYINGS:
 705       *params = shProg->TransformFeedback.NumVarying;
 706       break;
 707    case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
 708       *params = longest_feedback_varying_name(shProg) + 1;
 709       break;
 710    case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
 711       *params = shProg->TransformFeedback.BufferMode;
 712       break;
 713 #endif
 714 #if FEATURE_ARB_geometry_shader4
 715    case GL_GEOMETRY_VERTICES_OUT_ARB:
 716       *params = shProg->Geom.VerticesOut;
 717       break;
 718    case GL_GEOMETRY_INPUT_TYPE_ARB:
 719       *params = shProg->Geom.InputType;
 720       break;
 721    case GL_GEOMETRY_OUTPUT_TYPE_ARB:
 722       *params = shProg->Geom.OutputType;
 723       break;
 724 #endif
 725    default:
 726       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");
 727       return;
 728    }
 729 }
 730
 731
 732 /**
 733  * glGetShaderiv() - get GLSL shader state
 734  */
 735 static void
 736 get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)
 737 {
 738    struct gl_shader *shader =
 739       _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
 740
 741    if (!shader) {
 742       return;
 743    }
 744
 745    switch (pname) {
 746    case GL_SHADER_TYPE:
 747       *params = shader->Type;
 748       break;
 749    case GL_DELETE_STATUS:
 750       *params = shader->DeletePending;
 751       break;
 752    case GL_COMPILE_STATUS:
 753       *params = shader->CompileStatus;
 754       break;
 755    case GL_INFO_LOG_LENGTH:
 756       *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
 757       break;
 758    case GL_SHADER_SOURCE_LENGTH:
 759       *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
 760       break;
 761    default:
 762       _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
 763       return;
 764    }
 765 }
 766
 767
 768 static void
 769 get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,
 770                      GLsizei *length, GLchar *infoLog)
 771 {
 772    struct gl_shader_program *shProg
 773       = _mesa_lookup_shader_program(ctx, program);
 774    if (!shProg) {
 775       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
 776       return;
 777    }
 778    _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);
 779 }
 780
 781
 782 static void
 783 get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,
 784                     GLsizei *length, GLchar *infoLog)
 785 {
 786    struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
 787    if (!sh) {
 788       _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
 789       return;
 790    }
 791    _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);
 792 }
 793
 794
 795 /**
 796  * Return shader source code.
 797  */
 798 static void
 799 get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,
 800                   GLsizei *length, GLchar *sourceOut)
 801 {
 802    struct gl_shader *sh;
 803    sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
 804    if (!sh) {
 805       return;
 806    }
 807    _mesa_copy_string(sourceOut, maxLength, length, sh->Source);
 808 }
 809
 810
 811 /**
 812  * Set/replace shader source code.
 813  */
 814 static void
 815 shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)
 816 {
 817    struct gl_shader *sh;
 818
 819    sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");
 820    if (!sh)
 821       return;
 822
 823    /* free old shader source string and install new one */
 824    if (sh->Source) {
 825       free((void *) sh->Source);
 826    }
 827    sh->Source = source;
 828    sh->CompileStatus = GL_FALSE;
 829 #ifdef DEBUG
 830    sh->SourceChecksum = _mesa_str_checksum(sh->Source);
 831 #endif
 832 }
 833
 834
 835 /**
 836  * Compile a shader.
 837  */
 838 static void
 839 compile_shader(struct gl_context *ctx, GLuint shaderObj)
 840 {
 841    struct gl_shader *sh;
 842    struct gl_shader_compiler_options *options;
 843
 844    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
 845    if (!sh)
 846       return;
 847
 848    options = &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(sh->Type)];
 849
 850    /* set default pragma state for shader */
 851    sh->Pragmas = options->DefaultPragmas;
 852
 853    /* this call will set the sh->CompileStatus field to indicate if
 854     * compilation was successful.
 855     */
 856    _mesa_glsl_compile_shader(ctx, sh);
 857 }
 858
 859
 860 /**
 861  * Link a program's shaders.
 862  */
 863 static void
 864 link_program(struct gl_context *ctx, GLuint program)
 865 {
 866    struct gl_shader_program *shProg;
 867    struct gl_transform_feedback_object *obj =
 868       ctx->TransformFeedback.CurrentObject;
 869
 870    shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
 871    if (!shProg)
 872       return;
 873
 874    if (obj->Active
 875        && (shProg == ctx->Shader.CurrentVertexProgram
 876            || shProg == ctx->Shader.CurrentGeometryProgram
 877            || shProg == ctx->Shader.CurrentFragmentProgram)) {
 878       _mesa_error(ctx, GL_INVALID_OPERATION,
 879                   "glLinkProgram(transform feedback active");
 880       return;
 881    }
 882
 883    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 884
 885    _mesa_glsl_link_shader(ctx, shProg);
 886
 887    /* debug code */
 888    if (0) {
 889       GLuint i;
 890
 891       printf("Link %u shaders in program %u: %s\n",
 892                    shProg->NumShaders, shProg->Name,
 893                    shProg->LinkStatus ? "Success" : "Failed");
 894
 895       for (i = 0; i < shProg->NumShaders; i++) {
 896          printf(" shader %u, type 0x%x\n",
 897                       shProg->Shaders[i]->Name,
 898                       shProg->Shaders[i]->Type);
 899       }
 900    }
 901 }
 902
 903
 904 /**
 905  * Print basic shader info (for debug).
 906  */
 907 static void
 908 print_shader_info(const struct gl_shader_program *shProg)
 909 {
 910    GLuint i;
 911
 912    printf("Mesa: glUseProgram(%u)\n", shProg->Name);
 913    for (i = 0; i < shProg->NumShaders; i++) {
 914       const char *s;
 915       switch (shProg->Shaders[i]->Type) {
 916       case GL_VERTEX_SHADER:
 917          s = "vertex";
 918          break;
 919       case GL_FRAGMENT_SHADER:
 920          s = "fragment";
 921          break;
 922       case GL_GEOMETRY_SHADER:
 923          s = "geometry";
 924          break;
 925       default:
 926          s = "";
 927       }
 928       printf("  %s shader %u, checksum %u\n", s,
 929              shProg->Shaders[i]->Name,
 930              shProg->Shaders[i]->SourceChecksum);
 931    }
 932    if (shProg->VertexProgram)
 933       printf("  vert prog %u\n", shProg->VertexProgram->Base.Id);
 934    if (shProg->FragmentProgram)
 935       printf("  frag prog %u\n", shProg->FragmentProgram->Base.Id);
 936 }
 937
 938
 939 /**
 940  * Use the named shader program for subsequent glUniform calls
 941  */
 942 void
 943 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
 944                      const char *caller)
 945 {
 946    if ((shProg != NULL) && !shProg->LinkStatus) {
 947       _mesa_error(ctx, GL_INVALID_OPERATION,
 948                   "%s(program %u not linked)", caller, shProg->Name);
 949       return;
 950    }
 951
 952    if (ctx->Shader.ActiveProgram != shProg) {
 953       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
 954    }
 955 }
 956
 957 /**
 958  */
 959 static bool
 960 use_shader_program(struct gl_context *ctx, GLenum type,
 961                    struct gl_shader_program *shProg)
 962 {
 963    struct gl_shader_program **target;
 964
 965    switch (type) {
 966 #if FEATURE_ARB_vertex_shader
 967    case GL_VERTEX_SHADER:
 968       target = &ctx->Shader.CurrentVertexProgram;
 969       if ((shProg == NULL)
 970           || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) {
 971          shProg = NULL;
 972       }
 973       break;
 974 #endif
 975 #if FEATURE_ARB_geometry_shader4
 976    case GL_GEOMETRY_SHADER_ARB:
 977       target = &ctx->Shader.CurrentGeometryProgram;
 978       if ((shProg == NULL)
 979           || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) {
 980          shProg = NULL;
 981       }
 982       break;
 983 #endif
 984 #if FEATURE_ARB_fragment_shader
 985    case GL_FRAGMENT_SHADER:
 986       target = &ctx->Shader.CurrentFragmentProgram;
 987       if ((shProg == NULL)
 988           || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) {
 989          shProg = NULL;
 990       }
 991       break;
 992 #endif
 993    default:
 994       return false;
 995    }
 996
 997    if (*target != shProg) {
 998       FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
 999       _mesa_reference_shader_program(ctx, target, shProg);
1000       return true;
1001    }
1002
1003    return false;
1004 }
1005
1006 /**
1007  * Use the named shader program for subsequent rendering.
1008  */
1009 void
1010 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
1011 {
1012    use_shader_program(ctx, GL_VERTEX_SHADER, shProg);
1013    use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);
1014    use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);
1015    _mesa_active_program(ctx, shProg, "glUseProgram");
1016
1017    if (ctx->Driver.UseProgram)
1018       ctx->Driver.UseProgram(ctx, shProg);
1019 }
1020
1021
1022 /**
1023  * Validate a program's samplers.
1024  * Specifically, check that there aren't two samplers of different types
1025  * pointing to the same texture unit.
1026  * \return GL_TRUE if valid, GL_FALSE if invalid
1027  */
1028 static GLboolean
1029 validate_samplers(const struct gl_program *prog, char *errMsg)
1030 {
1031    static const char *targetName[] = {
1032       "TEXTURE_2D_ARRAY",
1033       "TEXTURE_1D_ARRAY",
1034       "TEXTURE_CUBE",
1035       "TEXTURE_3D",
1036       "TEXTURE_RECT",
1037       "TEXTURE_2D",
1038       "TEXTURE_1D",
1039    };
1040    GLint targetUsed[MAX_TEXTURE_IMAGE_UNITS];
1041    GLbitfield samplersUsed = prog->SamplersUsed;
1042    GLuint i;
1043
1044    assert(Elements(targetName) == NUM_TEXTURE_TARGETS);
1045
1046    if (samplersUsed == 0x0)
1047       return GL_TRUE;
1048
1049    for (i = 0; i < Elements(targetUsed); i++)
1050       targetUsed[i] = -1;
1051
1052    /* walk over bits which are set in 'samplers' */
1053    while (samplersUsed) {
1054       GLuint unit;
1055       gl_texture_index target;
1056       GLint sampler = _mesa_ffs(samplersUsed) - 1;
1057       assert(sampler >= 0);
1058       assert(sampler < MAX_TEXTURE_IMAGE_UNITS);
1059       unit = prog->SamplerUnits[sampler];
1060       target = prog->SamplerTargets[sampler];
1061       if (targetUsed[unit] != -1 && targetUsed[unit] != (int) target) {
1062          _mesa_snprintf(errMsg, 100,
1063                   "Texture unit %d is accessed both as %s and %s",
1064                   unit, targetName[targetUsed[unit]], targetName[target]);
1065          return GL_FALSE;
1066       }
1067       targetUsed[unit] = target;
1068       samplersUsed ^= (1 << sampler);
1069    }
1070
1071    return GL_TRUE;
1072 }
1073
1074
1075 /**
1076  * Do validation of the given shader program.
1077  * \param errMsg  returns error message if validation fails.
1078  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1079  */
1080 static GLboolean
1081 validate_shader_program(const struct gl_shader_program *shProg,
1082                         char *errMsg)
1083 {
1084    const struct gl_vertex_program *vp = shProg->VertexProgram;
1085    const struct gl_fragment_program *fp = shProg->FragmentProgram;
1086
1087    if (!shProg->LinkStatus) {
1088       return GL_FALSE;
1089    }
1090
1091    /* From the GL spec, a program is invalid if any of these are true:
1092
1093      any two active samplers in the current program object are of
1094      different types, but refer to the same texture image unit,
1095
1096      any active sampler in the current program object refers to a texture
1097      image unit where fixed-function fragment processing accesses a
1098      texture target that does not match the sampler type, or
1099
1100      the sum of the number of active samplers in the program and the
1101      number of texture image units enabled for fixed-function fragment
1102      processing exceeds the combined limit on the total number of texture
1103      image units allowed.
1104    */
1105
1106
1107    /*
1108     * Check: any two active samplers in the current program object are of
1109     * different types, but refer to the same texture image unit,
1110     */
1111    if (vp && !validate_samplers(&vp->Base, errMsg)) {
1112       return GL_FALSE;
1113    }
1114    if (fp && !validate_samplers(&fp->Base, errMsg)) {
1115       return GL_FALSE;
1116    }
1117
1118    return GL_TRUE;
1119 }
1120
1121
1122 /**
1123  * Called via glValidateProgram()
1124  */
1125 static void
1126 validate_program(struct gl_context *ctx, GLuint program)
1127 {
1128    struct gl_shader_program *shProg;
1129    char errMsg[100];
1130
1131    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1132    if (!shProg) {
1133       return;
1134    }
1135
1136    shProg->Validated = validate_shader_program(shProg, errMsg);
1137    if (!shProg->Validated) {
1138       /* update info log */
1139       if (shProg->InfoLog) {
1140          talloc_free(shProg->InfoLog);
1141       }
1142       shProg->InfoLog = talloc_strdup(shProg, errMsg);
1143    }
1144 }
1145
1146
1147
1148 void GLAPIENTRY
1149 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
1150 {
1151    GET_CURRENT_CONTEXT(ctx);
1152    attach_shader(ctx, program, shader);
1153 }
1154
1155
1156 void GLAPIENTRY
1157 _mesa_AttachShader(GLuint program, GLuint shader)
1158 {
1159    GET_CURRENT_CONTEXT(ctx);
1160    attach_shader(ctx, program, shader);
1161 }
1162
1163
1164 void GLAPIENTRY
1165 _mesa_BindAttribLocationARB(GLhandleARB program, GLuint index,
1166                             const GLcharARB *name)
1167 {
1168    GET_CURRENT_CONTEXT(ctx);
1169    bind_attrib_location(ctx, program, index, name);
1170 }
1171
1172
1173 /* GL_EXT_gpu_shader4, GL3 */
1174 void GLAPIENTRY
1175 _mesa_BindFragDataLocation(GLuint program, GLuint colorNumber,
1176                            const GLchar *name)
1177 {
1178    GET_CURRENT_CONTEXT(ctx);
1179    bind_frag_data_location(ctx, program, colorNumber, name);
1180 }
1181
1182
1183 void GLAPIENTRY
1184 _mesa_CompileShaderARB(GLhandleARB shaderObj)
1185 {
1186    GET_CURRENT_CONTEXT(ctx);
1187    compile_shader(ctx, shaderObj);
1188 }
1189
1190
1191 GLuint GLAPIENTRY
1192 _mesa_CreateShader(GLenum type)
1193 {
1194    GET_CURRENT_CONTEXT(ctx);
1195    return create_shader(ctx, type);
1196 }
1197
1198
1199 GLhandleARB GLAPIENTRY
1200 _mesa_CreateShaderObjectARB(GLenum type)
1201 {
1202    GET_CURRENT_CONTEXT(ctx);
1203    return create_shader(ctx, type);
1204 }
1205
1206
1207 GLuint GLAPIENTRY
1208 _mesa_CreateProgram(void)
1209 {
1210    GET_CURRENT_CONTEXT(ctx);
1211    return create_shader_program(ctx);
1212 }
1213
1214
1215 GLhandleARB GLAPIENTRY
1216 _mesa_CreateProgramObjectARB(void)
1217 {
1218    GET_CURRENT_CONTEXT(ctx);
1219    return create_shader_program(ctx);
1220 }
1221
1222
1223 void GLAPIENTRY
1224 _mesa_DeleteObjectARB(GLhandleARB obj)
1225 {
1226    if (obj) {
1227       GET_CURRENT_CONTEXT(ctx);
1228       if (is_program(ctx, obj)) {
1229          delete_shader_program(ctx, obj);
1230       }
1231       else if (is_shader(ctx, obj)) {
1232          delete_shader(ctx, obj);
1233       }
1234       else {
1235          /* error? */
1236       }
1237    }
1238 }
1239
1240
1241 void GLAPIENTRY
1242 _mesa_DeleteProgram(GLuint name)
1243 {
1244    if (name) {
1245       GET_CURRENT_CONTEXT(ctx);
1246       delete_shader_program(ctx, name);
1247    }
1248 }
1249
1250
1251 void GLAPIENTRY
1252 _mesa_DeleteShader(GLuint name)
1253 {
1254    if (name) {
1255       GET_CURRENT_CONTEXT(ctx);
1256       delete_shader(ctx, name);
1257    }
1258 }
1259
1260
1261 void GLAPIENTRY
1262 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1263 {
1264    GET_CURRENT_CONTEXT(ctx);
1265    detach_shader(ctx, program, shader);
1266 }
1267
1268
1269 void GLAPIENTRY
1270 _mesa_DetachShader(GLuint program, GLuint shader)
1271 {
1272    GET_CURRENT_CONTEXT(ctx);
1273    detach_shader(ctx, program, shader);
1274 }
1275
1276
1277 void GLAPIENTRY
1278 _mesa_GetActiveAttribARB(GLhandleARB program, GLuint index,
1279                          GLsizei maxLength, GLsizei * length, GLint * size,
1280                          GLenum * type, GLcharARB * name)
1281 {
1282    GET_CURRENT_CONTEXT(ctx);
1283    get_active_attrib(ctx, program, index, maxLength, length, size, type, name);
1284 }
1285
1286
1287 void GLAPIENTRY
1288 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1289                             GLsizei * count, GLhandleARB * obj)
1290 {
1291    GET_CURRENT_CONTEXT(ctx);
1292    get_attached_shaders(ctx, container, maxCount, count, obj);
1293 }
1294
1295
1296 void GLAPIENTRY
1297 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1298                          GLsizei *count, GLuint *obj)
1299 {
1300    GET_CURRENT_CONTEXT(ctx);
1301    get_attached_shaders(ctx, program, maxCount, count, obj);
1302 }
1303
1304
1305 GLint GLAPIENTRY
1306 _mesa_GetAttribLocationARB(GLhandleARB program, const GLcharARB * name)
1307 {
1308    GET_CURRENT_CONTEXT(ctx);
1309    return get_attrib_location(ctx, program, name);
1310 }
1311
1312
1313 /* GL_EXT_gpu_shader4, GL3 */
1314 GLint GLAPIENTRY
1315 _mesa_GetFragDataLocation(GLuint program, const GLchar *name)
1316 {
1317    GET_CURRENT_CONTEXT(ctx);
1318    return get_frag_data_location(ctx, program, name);
1319 }
1320
1321
1322
1323 void GLAPIENTRY
1324 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1325                     GLcharARB * infoLog)
1326 {
1327    GET_CURRENT_CONTEXT(ctx);
1328    if (is_program(ctx, object)) {
1329       get_program_info_log(ctx, object, maxLength, length, infoLog);
1330    }
1331    else if (is_shader(ctx, object)) {
1332       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1333    }
1334    else {
1335       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1336    }
1337 }
1338
1339
1340 void GLAPIENTRY
1341 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1342 {
1343    GET_CURRENT_CONTEXT(ctx);
1344    /* Implement in terms of GetProgramiv, GetShaderiv */
1345    if (is_program(ctx, object)) {
1346       if (pname == GL_OBJECT_TYPE_ARB) {
1347          *params = GL_PROGRAM_OBJECT_ARB;
1348       }
1349       else {
1350          get_programiv(ctx, object, pname, params);
1351       }
1352    }
1353    else if (is_shader(ctx, object)) {
1354       if (pname == GL_OBJECT_TYPE_ARB) {
1355          *params = GL_SHADER_OBJECT_ARB;
1356       }
1357       else {
1358          get_shaderiv(ctx, object, pname, params);
1359       }
1360    }
1361    else {
1362       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1363    }
1364 }
1365
1366
1367 void GLAPIENTRY
1368 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1369                               GLfloat *params)
1370 {
1371    GLint iparams[1];  /* XXX is one element enough? */
1372    _mesa_GetObjectParameterivARB(object, pname, iparams);
1373    params[0] = (GLfloat) iparams[0];
1374 }
1375
1376
1377 void GLAPIENTRY
1378 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1379 {
1380    GET_CURRENT_CONTEXT(ctx);
1381    get_programiv(ctx, program, pname, params);
1382 }
1383
1384
1385 void GLAPIENTRY
1386 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1387 {
1388    GET_CURRENT_CONTEXT(ctx);
1389    get_shaderiv(ctx, shader, pname, params);
1390 }
1391
1392
1393 void GLAPIENTRY
1394 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1395                         GLsizei *length, GLchar *infoLog)
1396 {
1397    GET_CURRENT_CONTEXT(ctx);
1398    get_program_info_log(ctx, program, bufSize, length, infoLog);
1399 }
1400
1401
1402 void GLAPIENTRY
1403 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1404                        GLsizei *length, GLchar *infoLog)
1405 {
1406    GET_CURRENT_CONTEXT(ctx);
1407    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1408 }
1409
1410
1411 void GLAPIENTRY
1412 _mesa_GetShaderSourceARB(GLhandleARB shader, GLsizei maxLength,
1413                          GLsizei *length, GLcharARB *sourceOut)
1414 {
1415    GET_CURRENT_CONTEXT(ctx);
1416    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1417 }
1418
1419
1420 GLhandleARB GLAPIENTRY
1421 _mesa_GetHandleARB(GLenum pname)
1422 {
1423    GET_CURRENT_CONTEXT(ctx);
1424    return get_handle(ctx, pname);
1425 }
1426
1427
1428 GLboolean GLAPIENTRY
1429 _mesa_IsProgram(GLuint name)
1430 {
1431    GET_CURRENT_CONTEXT(ctx);
1432    return is_program(ctx, name);
1433 }
1434
1435
1436 GLboolean GLAPIENTRY
1437 _mesa_IsShader(GLuint name)
1438 {
1439    GET_CURRENT_CONTEXT(ctx);
1440    return is_shader(ctx, name);
1441 }
1442
1443
1444 void GLAPIENTRY
1445 _mesa_LinkProgramARB(GLhandleARB programObj)
1446 {
1447    GET_CURRENT_CONTEXT(ctx);
1448    link_program(ctx, programObj);
1449 }
1450
1451
1452
1453 /**
1454  * Read shader source code from a file.
1455  * Useful for debugging to override an app's shader.
1456  */
1457 static GLcharARB *
1458 read_shader(const char *fname)
1459 {
1460    const int max = 50*1000;
1461    FILE *f = fopen(fname, "r");
1462    GLcharARB *buffer, *shader;
1463    int len;
1464
1465    if (!f) {
1466       return NULL;
1467    }
1468
1469    buffer = (char *) malloc(max);
1470    len = fread(buffer, 1, max, f);
1471    buffer[len] = 0;
1472
1473    fclose(f);
1474
1475    shader = _mesa_strdup(buffer);
1476    free(buffer);
1477
1478    return shader;
1479 }
1480
1481
1482 /**
1483  * Called via glShaderSource() and glShaderSourceARB() API functions.
1484  * Basically, concatenate the source code strings into one long string
1485  * and pass it to _mesa_shader_source().
1486  */
1487 void GLAPIENTRY
1488 _mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
1489                       const GLcharARB ** string, const GLint * length)
1490 {
1491    GET_CURRENT_CONTEXT(ctx);
1492    GLint *offsets;
1493    GLsizei i, totalLength;
1494    GLcharARB *source;
1495    GLuint checksum;
1496
1497    if (!shaderObj || string == NULL) {
1498       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1499       return;
1500    }
1501
1502    /*
1503     * This array holds offsets of where the appropriate string ends, thus the
1504     * last element will be set to the total length of the source code.
1505     */
1506    offsets = (GLint *) malloc(count * sizeof(GLint));
1507    if (offsets == NULL) {
1508       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1509       return;
1510    }
1511
1512    for (i = 0; i < count; i++) {
1513       if (string[i] == NULL) {
1514          free((GLvoid *) offsets);
1515          _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderSourceARB(null string)");
1516          return;
1517       }
1518       if (length == NULL || length[i] < 0)
1519          offsets[i] = strlen(string[i]);
1520       else
1521          offsets[i] = length[i];
1522       /* accumulate string lengths */
1523       if (i > 0)
1524          offsets[i] += offsets[i - 1];
1525    }
1526
1527    /* Total length of source string is sum off all strings plus two.
1528     * One extra byte for terminating zero, another extra byte to silence
1529     * valgrind warnings in the parser/grammer code.
1530     */
1531    totalLength = offsets[count - 1] + 2;
1532    source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB));
1533    if (source == NULL) {
1534       free((GLvoid *) offsets);
1535       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1536       return;
1537    }
1538
1539    for (i = 0; i < count; i++) {
1540       GLint start = (i > 0) ? offsets[i - 1] : 0;
1541       memcpy(source + start, string[i],
1542              (offsets[i] - start) * sizeof(GLcharARB));
1543    }
1544    source[totalLength - 1] = '\0';
1545    source[totalLength - 2] = '\0';
1546
1547    if (SHADER_SUBST) {
1548       /* Compute the shader's source code checksum then try to open a file
1549        * named newshader_<CHECKSUM>.  If it exists, use it in place of the
1550        * original shader source code.  For debugging.
1551        */
1552       char filename[100];
1553       GLcharARB *newSource;
1554
1555       checksum = _mesa_str_checksum(source);
1556
1557       _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
1558
1559       newSource = read_shader(filename);
1560       if (newSource) {
1561          fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
1562                        shaderObj, checksum, filename);
1563          free(source);
1564          source = newSource;
1565       }
1566    }
1567
1568    shader_source(ctx, shaderObj, source);
1569
1570    if (SHADER_SUBST) {
1571       struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
1572       if (sh)
1573          sh->SourceChecksum = checksum; /* save original checksum */
1574    }
1575
1576    free(offsets);
1577 }
1578
1579
1580 void GLAPIENTRY
1581 _mesa_UseProgramObjectARB(GLhandleARB program)
1582 {
1583    GET_CURRENT_CONTEXT(ctx);
1584    struct gl_shader_program *shProg;
1585    struct gl_transform_feedback_object *obj =
1586       ctx->TransformFeedback.CurrentObject;
1587
1588    if (obj->Active) {
1589       _mesa_error(ctx, GL_INVALID_OPERATION,
1590                   "glUseProgram(transform feedback active)");
1591       return;
1592    }
1593
1594    if (program) {
1595       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1596       if (!shProg) {
1597          return;
1598       }
1599       if (!shProg->LinkStatus) {
1600          _mesa_error(ctx, GL_INVALID_OPERATION,
1601                      "glUseProgram(program %u not linked)", program);
1602          return;
1603       }
1604
1605       /* debug code */
1606       if (ctx->Shader.Flags & GLSL_USE_PROG) {
1607          print_shader_info(shProg);
1608       }
1609    }
1610    else {
1611       shProg = NULL;
1612    }
1613
1614    _mesa_use_program(ctx, shProg);
1615 }
1616
1617
1618 void GLAPIENTRY
1619 _mesa_ValidateProgramARB(GLhandleARB program)
1620 {
1621    GET_CURRENT_CONTEXT(ctx);
1622    validate_program(ctx, program);
1623 }
1624
1625 #ifdef FEATURE_ES2
1626
1627 void GLAPIENTRY
1628 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1629                                GLint* range, GLint* precision)
1630 {
1631    const struct gl_program_constants *limits;
1632    const struct gl_precision *p;
1633    GET_CURRENT_CONTEXT(ctx);
1634
1635    switch (shadertype) {
1636    case GL_VERTEX_SHADER:
1637       limits = &ctx->Const.VertexProgram;
1638       break;
1639    case GL_FRAGMENT_SHADER:
1640       limits = &ctx->Const.FragmentProgram;
1641       break;
1642    default:
1643       _mesa_error(ctx, GL_INVALID_ENUM,
1644                   "glGetShaderPrecisionFormat(shadertype)");
1645       return;
1646    }
1647
1648    switch (precisiontype) {
1649    case GL_LOW_FLOAT:
1650       p = &limits->LowFloat;
1651       break;
1652    case GL_MEDIUM_FLOAT:
1653       p = &limits->MediumFloat;
1654       break;
1655    case GL_HIGH_FLOAT:
1656       p = &limits->HighFloat;
1657       break;
1658    case GL_LOW_INT:
1659       p = &limits->LowInt;
1660       break;
1661    case GL_MEDIUM_INT:
1662       p = &limits->MediumInt;
1663       break;
1664    case GL_HIGH_INT:
1665       p = &limits->HighInt;
1666       break;
1667    default:
1668       _mesa_error(ctx, GL_INVALID_ENUM,
1669                   "glGetShaderPrecisionFormat(precisiontype)");
1670       return;
1671    }
1672
1673    range[0] = p->RangeMin;
1674    range[1] = p->RangeMax;
1675    precision[0] = p->Precision;
1676 }
1677
1678
1679 void GLAPIENTRY
1680 _mesa_ReleaseShaderCompiler(void)
1681 {
1682    _mesa_destroy_shader_compiler_caches();
1683 }
1684
1685
1686 void GLAPIENTRY
1687 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1688                    const void* binary, GLint length)
1689 {
1690    GET_CURRENT_CONTEXT(ctx);
1691    (void) n;
1692    (void) shaders;
1693    (void) binaryformat;
1694    (void) binary;
1695    (void) length;
1696    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1697 }
1698
1699 #endif /* FEATURE_ES2 */
1700
1701
1702 #if FEATURE_ARB_geometry_shader4
1703
1704 void GLAPIENTRY
1705 _mesa_ProgramParameteriARB(GLuint program, GLenum pname,
1706                            GLint value)
1707 {
1708    struct gl_shader_program *shProg;
1709    GET_CURRENT_CONTEXT(ctx);
1710
1711    ASSERT_OUTSIDE_BEGIN_END(ctx);
1712
1713    shProg = _mesa_lookup_shader_program_err(ctx, program,
1714                                             "glProgramParameteri");
1715    if (!shProg)
1716       return;
1717
1718    switch (pname) {
1719    case GL_GEOMETRY_VERTICES_OUT_ARB:
1720       if (value < 1 ||
1721           (unsigned) value > ctx->Const.GeometryProgram.MaxGeometryOutputVertices) {
1722          _mesa_error(ctx, GL_INVALID_VALUE,
1723                      "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1724                      value);
1725          return;
1726       }
1727       shProg->Geom.VerticesOut = value;
1728       break;
1729    case GL_GEOMETRY_INPUT_TYPE_ARB:
1730       switch (value) {
1731       case GL_POINTS:
1732       case GL_LINES:
1733       case GL_LINES_ADJACENCY_ARB:
1734       case GL_TRIANGLES:
1735       case GL_TRIANGLES_ADJACENCY_ARB:
1736          shProg->Geom.InputType = value;
1737          break;
1738       default:
1739          _mesa_error(ctx, GL_INVALID_VALUE,
1740                      "glProgramParameteri(geometry input type = %s",
1741                      _mesa_lookup_enum_by_nr(value));
1742          return;
1743       }
1744       break;
1745    case GL_GEOMETRY_OUTPUT_TYPE_ARB:
1746       switch (value) {
1747       case GL_POINTS:
1748       case GL_LINE_STRIP:
1749       case GL_TRIANGLE_STRIP:
1750          shProg->Geom.OutputType = value;
1751          break;
1752       default:
1753          _mesa_error(ctx, GL_INVALID_VALUE,
1754                      "glProgramParameteri(geometry output type = %s",
1755                      _mesa_lookup_enum_by_nr(value));
1756          return;
1757       }
1758       break;
1759    default:
1760       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteriARB(pname=%s)",
1761                   _mesa_lookup_enum_by_nr(pname));
1762       break;
1763    }
1764 }
1765
1766 #endif
1767
1768 void
1769 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
1770                          struct gl_shader_program *shProg)
1771 {
1772    use_shader_program(ctx, type, shProg);
1773
1774    if (ctx->Driver.UseProgram)
1775       ctx->Driver.UseProgram(ctx, shProg);
1776 }
1777
1778 void GLAPIENTRY
1779 _mesa_UseShaderProgramEXT(GLenum type, GLuint program)
1780 {
1781    GET_CURRENT_CONTEXT(ctx);
1782    struct gl_shader_program *shProg = NULL;
1783
1784    if (!validate_shader_target(ctx, type)) {
1785       _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");
1786       return;
1787    }
1788
1789    if (ctx->TransformFeedback.CurrentObject->Active) {
1790       _mesa_error(ctx, GL_INVALID_OPERATION,
1791                   "glUseShaderProgramEXT(transform feedback is active)");
1792       return;
1793    }
1794
1795    if (program) {
1796       shProg = _mesa_lookup_shader_program_err(ctx, program,
1797                                                "glUseShaderProgramEXT");
1798       if (shProg == NULL)
1799          return;
1800
1801       if (!shProg->LinkStatus) {
1802          _mesa_error(ctx, GL_INVALID_OPERATION,
1803                      "glUseShaderProgramEXT(program not linked)");
1804          return;
1805       }
1806    }
1807
1808    _mesa_use_shader_program(ctx, type, shProg);
1809 }
1810
1811 void GLAPIENTRY
1812 _mesa_ActiveProgramEXT(GLuint program)
1813 {
1814    GET_CURRENT_CONTEXT(ctx);
1815    struct gl_shader_program *shProg = (program != 0)
1816       ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
1817       : NULL;
1818
1819    _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
1820    return;
1821 }
1822
1823 GLuint GLAPIENTRY
1824 _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
1825 {
1826    GET_CURRENT_CONTEXT(ctx);
1827    const GLuint shader = create_shader(ctx, type);
1828    GLuint program = 0;
1829
1830    if (shader) {
1831       shader_source(ctx, shader, _mesa_strdup(string));
1832       compile_shader(ctx, shader);
1833
1834       program = create_shader_program(ctx);
1835       if (program) {
1836          struct gl_shader_program *shProg;
1837          struct gl_shader *sh;
1838          GLint compiled = GL_FALSE;
1839
1840          shProg = _mesa_lookup_shader_program(ctx, program);
1841          sh = _mesa_lookup_shader(ctx, shader);
1842
1843          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
1844          if (compiled) {
1845             attach_shader(ctx, program, shader);
1846             link_program(ctx, program);
1847             detach_shader(ctx, program, shader);
1848
1849 #if 0
1850             /* Possibly... */
1851             if (active-user-defined-varyings-in-linked-program) {
1852                append-error-to-info-log;
1853                shProg->LinkStatus = GL_FALSE;
1854             }
1855 #endif
1856          }
1857
1858          shProg->InfoLog = talloc_strdup_append(shProg->InfoLog, sh->InfoLog);
1859       }
1860
1861       delete_shader(ctx, shader);
1862    }
1863
1864    return program;
1865 }
1866
1867 /**
1868  * Plug in shader-related functions into API dispatch table.
1869  */
1870 void
1871 _mesa_init_shader_dispatch(struct _glapi_table *exec)
1872 {
1873 #if FEATURE_GL
1874    /* GL_ARB_vertex/fragment_shader */
1875    SET_DeleteObjectARB(exec, _mesa_DeleteObjectARB);
1876    SET_GetHandleARB(exec, _mesa_GetHandleARB);
1877    SET_DetachObjectARB(exec, _mesa_DetachObjectARB);
1878    SET_CreateShaderObjectARB(exec, _mesa_CreateShaderObjectARB);
1879    SET_ShaderSourceARB(exec, _mesa_ShaderSourceARB);
1880    SET_CompileShaderARB(exec, _mesa_CompileShaderARB);
1881    SET_CreateProgramObjectARB(exec, _mesa_CreateProgramObjectARB);
1882    SET_AttachObjectARB(exec, _mesa_AttachObjectARB);
1883    SET_LinkProgramARB(exec, _mesa_LinkProgramARB);
1884    SET_UseProgramObjectARB(exec, _mesa_UseProgramObjectARB);
1885    SET_ValidateProgramARB(exec, _mesa_ValidateProgramARB);
1886    SET_GetObjectParameterfvARB(exec, _mesa_GetObjectParameterfvARB);
1887    SET_GetObjectParameterivARB(exec, _mesa_GetObjectParameterivARB);
1888    SET_GetInfoLogARB(exec, _mesa_GetInfoLogARB);
1889    SET_GetAttachedObjectsARB(exec, _mesa_GetAttachedObjectsARB);
1890    SET_GetShaderSourceARB(exec, _mesa_GetShaderSourceARB);
1891
1892    /* OpenGL 2.0 */
1893    SET_AttachShader(exec, _mesa_AttachShader);
1894    SET_CreateProgram(exec, _mesa_CreateProgram);
1895    SET_CreateShader(exec, _mesa_CreateShader);
1896    SET_DeleteProgram(exec, _mesa_DeleteProgram);
1897    SET_DeleteShader(exec, _mesa_DeleteShader);
1898    SET_DetachShader(exec, _mesa_DetachShader);
1899    SET_GetAttachedShaders(exec, _mesa_GetAttachedShaders);
1900    SET_GetProgramiv(exec, _mesa_GetProgramiv);
1901    SET_GetProgramInfoLog(exec, _mesa_GetProgramInfoLog);
1902    SET_GetShaderiv(exec, _mesa_GetShaderiv);
1903    SET_GetShaderInfoLog(exec, _mesa_GetShaderInfoLog);
1904    SET_IsProgram(exec, _mesa_IsProgram);
1905    SET_IsShader(exec, _mesa_IsShader);
1906
1907 #if FEATURE_ARB_vertex_shader
1908    SET_BindAttribLocationARB(exec, _mesa_BindAttribLocationARB);
1909    SET_GetActiveAttribARB(exec, _mesa_GetActiveAttribARB);
1910    SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB);
1911 #endif
1912
1913 #if FEATURE_ARB_geometry_shader4
1914    SET_ProgramParameteriARB(exec, _mesa_ProgramParameteriARB);
1915 #endif
1916
1917    SET_UseShaderProgramEXT(exec, _mesa_UseShaderProgramEXT);
1918    SET_ActiveProgramEXT(exec, _mesa_ActiveProgramEXT);
1919    SET_CreateShaderProgramEXT(exec, _mesa_CreateShaderProgramEXT);
1920
1921    /* GL_EXT_gpu_shader4 / GL 3.0 */
1922    SET_BindFragDataLocationEXT(exec, _mesa_BindFragDataLocation);
1923    SET_GetFragDataLocationEXT(exec, _mesa_GetFragDataLocation);
1924
1925    /* GL_ARB_ES2_compatibility */
1926    SET_ReleaseShaderCompiler(exec, _mesa_ReleaseShaderCompiler);
1927
1928 #endif /* FEATURE_GL */
1929 }
1930