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, 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          ralloc_free(shProg->InfoLog);
1141       }
1142       shProg->InfoLog = ralloc_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    if (MESA_VERBOSE & VERBOSE_API)
1188       _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1189    compile_shader(ctx, shaderObj);
1190 }
1191
1192
1193 GLuint GLAPIENTRY
1194 _mesa_CreateShader(GLenum type)
1195 {
1196    GET_CURRENT_CONTEXT(ctx);
1197    if (MESA_VERBOSE & VERBOSE_API)
1198       _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));
1199    return create_shader(ctx, type);
1200 }
1201
1202
1203 GLhandleARB GLAPIENTRY
1204 _mesa_CreateShaderObjectARB(GLenum type)
1205 {
1206    GET_CURRENT_CONTEXT(ctx);
1207    return create_shader(ctx, type);
1208 }
1209
1210
1211 GLuint GLAPIENTRY
1212 _mesa_CreateProgram(void)
1213 {
1214    GET_CURRENT_CONTEXT(ctx);
1215    if (MESA_VERBOSE & VERBOSE_API)
1216       _mesa_debug(ctx, "glCreateProgram\n");
1217    return create_shader_program(ctx);
1218 }
1219
1220
1221 GLhandleARB GLAPIENTRY
1222 _mesa_CreateProgramObjectARB(void)
1223 {
1224    GET_CURRENT_CONTEXT(ctx);
1225    return create_shader_program(ctx);
1226 }
1227
1228
1229 void GLAPIENTRY
1230 _mesa_DeleteObjectARB(GLhandleARB obj)
1231 {
1232    if (MESA_VERBOSE & VERBOSE_API) {
1233       GET_CURRENT_CONTEXT(ctx);
1234       _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);
1235    }
1236
1237    if (obj) {
1238       GET_CURRENT_CONTEXT(ctx);
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       delete_shader_program(ctx, name);
1258    }
1259 }
1260
1261
1262 void GLAPIENTRY
1263 _mesa_DeleteShader(GLuint name)
1264 {
1265    if (name) {
1266       GET_CURRENT_CONTEXT(ctx);
1267       delete_shader(ctx, name);
1268    }
1269 }
1270
1271
1272 void GLAPIENTRY
1273 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1274 {
1275    GET_CURRENT_CONTEXT(ctx);
1276    detach_shader(ctx, program, shader);
1277 }
1278
1279
1280 void GLAPIENTRY
1281 _mesa_DetachShader(GLuint program, GLuint shader)
1282 {
1283    GET_CURRENT_CONTEXT(ctx);
1284    detach_shader(ctx, program, shader);
1285 }
1286
1287
1288 void GLAPIENTRY
1289 _mesa_GetActiveAttribARB(GLhandleARB program, GLuint index,
1290                          GLsizei maxLength, GLsizei * length, GLint * size,
1291                          GLenum * type, GLcharARB * name)
1292 {
1293    GET_CURRENT_CONTEXT(ctx);
1294    get_active_attrib(ctx, program, index, maxLength, length, size, type, name);
1295 }
1296
1297
1298 void GLAPIENTRY
1299 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1300                             GLsizei * count, GLhandleARB * obj)
1301 {
1302    GET_CURRENT_CONTEXT(ctx);
1303    get_attached_shaders(ctx, container, maxCount, count, obj);
1304 }
1305
1306
1307 void GLAPIENTRY
1308 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1309                          GLsizei *count, GLuint *obj)
1310 {
1311    GET_CURRENT_CONTEXT(ctx);
1312    get_attached_shaders(ctx, program, maxCount, count, obj);
1313 }
1314
1315
1316 GLint GLAPIENTRY
1317 _mesa_GetAttribLocationARB(GLhandleARB program, const GLcharARB * name)
1318 {
1319    GET_CURRENT_CONTEXT(ctx);
1320    return get_attrib_location(ctx, program, name);
1321 }
1322
1323
1324 /* GL_EXT_gpu_shader4, GL3 */
1325 GLint GLAPIENTRY
1326 _mesa_GetFragDataLocation(GLuint program, const GLchar *name)
1327 {
1328    GET_CURRENT_CONTEXT(ctx);
1329    return get_frag_data_location(ctx, program, name);
1330 }
1331
1332
1333
1334 void GLAPIENTRY
1335 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1336                     GLcharARB * infoLog)
1337 {
1338    GET_CURRENT_CONTEXT(ctx);
1339    if (is_program(ctx, object)) {
1340       get_program_info_log(ctx, object, maxLength, length, infoLog);
1341    }
1342    else if (is_shader(ctx, object)) {
1343       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1344    }
1345    else {
1346       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1347    }
1348 }
1349
1350
1351 void GLAPIENTRY
1352 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1353 {
1354    GET_CURRENT_CONTEXT(ctx);
1355    /* Implement in terms of GetProgramiv, GetShaderiv */
1356    if (is_program(ctx, object)) {
1357       if (pname == GL_OBJECT_TYPE_ARB) {
1358          *params = GL_PROGRAM_OBJECT_ARB;
1359       }
1360       else {
1361          get_programiv(ctx, object, pname, params);
1362       }
1363    }
1364    else if (is_shader(ctx, object)) {
1365       if (pname == GL_OBJECT_TYPE_ARB) {
1366          *params = GL_SHADER_OBJECT_ARB;
1367       }
1368       else {
1369          get_shaderiv(ctx, object, pname, params);
1370       }
1371    }
1372    else {
1373       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1374    }
1375 }
1376
1377
1378 void GLAPIENTRY
1379 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1380                               GLfloat *params)
1381 {
1382    GLint iparams[1];  /* XXX is one element enough? */
1383    _mesa_GetObjectParameterivARB(object, pname, iparams);
1384    params[0] = (GLfloat) iparams[0];
1385 }
1386
1387
1388 void GLAPIENTRY
1389 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1390 {
1391    GET_CURRENT_CONTEXT(ctx);
1392    get_programiv(ctx, program, pname, params);
1393 }
1394
1395
1396 void GLAPIENTRY
1397 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1398 {
1399    GET_CURRENT_CONTEXT(ctx);
1400    get_shaderiv(ctx, shader, pname, params);
1401 }
1402
1403
1404 void GLAPIENTRY
1405 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1406                         GLsizei *length, GLchar *infoLog)
1407 {
1408    GET_CURRENT_CONTEXT(ctx);
1409    get_program_info_log(ctx, program, bufSize, length, infoLog);
1410 }
1411
1412
1413 void GLAPIENTRY
1414 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1415                        GLsizei *length, GLchar *infoLog)
1416 {
1417    GET_CURRENT_CONTEXT(ctx);
1418    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1419 }
1420
1421
1422 void GLAPIENTRY
1423 _mesa_GetShaderSourceARB(GLhandleARB shader, GLsizei maxLength,
1424                          GLsizei *length, GLcharARB *sourceOut)
1425 {
1426    GET_CURRENT_CONTEXT(ctx);
1427    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1428 }
1429
1430
1431 GLhandleARB GLAPIENTRY
1432 _mesa_GetHandleARB(GLenum pname)
1433 {
1434    GET_CURRENT_CONTEXT(ctx);
1435    return get_handle(ctx, pname);
1436 }
1437
1438
1439 GLboolean GLAPIENTRY
1440 _mesa_IsProgram(GLuint name)
1441 {
1442    GET_CURRENT_CONTEXT(ctx);
1443    return is_program(ctx, name);
1444 }
1445
1446
1447 GLboolean GLAPIENTRY
1448 _mesa_IsShader(GLuint name)
1449 {
1450    GET_CURRENT_CONTEXT(ctx);
1451    return is_shader(ctx, name);
1452 }
1453
1454
1455 void GLAPIENTRY
1456 _mesa_LinkProgramARB(GLhandleARB programObj)
1457 {
1458    GET_CURRENT_CONTEXT(ctx);
1459    link_program(ctx, programObj);
1460 }
1461
1462
1463
1464 /**
1465  * Read shader source code from a file.
1466  * Useful for debugging to override an app's shader.
1467  */
1468 static GLcharARB *
1469 read_shader(const char *fname)
1470 {
1471    const int max = 50*1000;
1472    FILE *f = fopen(fname, "r");
1473    GLcharARB *buffer, *shader;
1474    int len;
1475
1476    if (!f) {
1477       return NULL;
1478    }
1479
1480    buffer = (char *) malloc(max);
1481    len = fread(buffer, 1, max, f);
1482    buffer[len] = 0;
1483
1484    fclose(f);
1485
1486    shader = _mesa_strdup(buffer);
1487    free(buffer);
1488
1489    return shader;
1490 }
1491
1492
1493 /**
1494  * Called via glShaderSource() and glShaderSourceARB() API functions.
1495  * Basically, concatenate the source code strings into one long string
1496  * and pass it to _mesa_shader_source().
1497  */
1498 void GLAPIENTRY
1499 _mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
1500                       const GLcharARB ** string, const GLint * length)
1501 {
1502    GET_CURRENT_CONTEXT(ctx);
1503    GLint *offsets;
1504    GLsizei i, totalLength;
1505    GLcharARB *source;
1506    GLuint checksum;
1507
1508    if (!shaderObj || string == NULL) {
1509       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1510       return;
1511    }
1512
1513    /*
1514     * This array holds offsets of where the appropriate string ends, thus the
1515     * last element will be set to the total length of the source code.
1516     */
1517    offsets = (GLint *) malloc(count * sizeof(GLint));
1518    if (offsets == NULL) {
1519       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1520       return;
1521    }
1522
1523    for (i = 0; i < count; i++) {
1524       if (string[i] == NULL) {
1525          free((GLvoid *) offsets);
1526          _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderSourceARB(null string)");
1527          return;
1528       }
1529       if (length == NULL || length[i] < 0)
1530          offsets[i] = strlen(string[i]);
1531       else
1532          offsets[i] = length[i];
1533       /* accumulate string lengths */
1534       if (i > 0)
1535          offsets[i] += offsets[i - 1];
1536    }
1537
1538    /* Total length of source string is sum off all strings plus two.
1539     * One extra byte for terminating zero, another extra byte to silence
1540     * valgrind warnings in the parser/grammer code.
1541     */
1542    totalLength = offsets[count - 1] + 2;
1543    source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB));
1544    if (source == NULL) {
1545       free((GLvoid *) offsets);
1546       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1547       return;
1548    }
1549
1550    for (i = 0; i < count; i++) {
1551       GLint start = (i > 0) ? offsets[i - 1] : 0;
1552       memcpy(source + start, string[i],
1553              (offsets[i] - start) * sizeof(GLcharARB));
1554    }
1555    source[totalLength - 1] = '\0';
1556    source[totalLength - 2] = '\0';
1557
1558    if (SHADER_SUBST) {
1559       /* Compute the shader's source code checksum then try to open a file
1560        * named newshader_<CHECKSUM>.  If it exists, use it in place of the
1561        * original shader source code.  For debugging.
1562        */
1563       char filename[100];
1564       GLcharARB *newSource;
1565
1566       checksum = _mesa_str_checksum(source);
1567
1568       _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
1569
1570       newSource = read_shader(filename);
1571       if (newSource) {
1572          fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
1573                        shaderObj, checksum, filename);
1574          free(source);
1575          source = newSource;
1576       }
1577    }
1578
1579    shader_source(ctx, shaderObj, source);
1580
1581    if (SHADER_SUBST) {
1582       struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
1583       if (sh)
1584          sh->SourceChecksum = checksum; /* save original checksum */
1585    }
1586
1587    free(offsets);
1588 }
1589
1590
1591 void GLAPIENTRY
1592 _mesa_UseProgramObjectARB(GLhandleARB program)
1593 {
1594    GET_CURRENT_CONTEXT(ctx);
1595    struct gl_shader_program *shProg;
1596    struct gl_transform_feedback_object *obj =
1597       ctx->TransformFeedback.CurrentObject;
1598
1599    if (obj->Active) {
1600       _mesa_error(ctx, GL_INVALID_OPERATION,
1601                   "glUseProgram(transform feedback active)");
1602       return;
1603    }
1604
1605    if (program) {
1606       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1607       if (!shProg) {
1608          return;
1609       }
1610       if (!shProg->LinkStatus) {
1611          _mesa_error(ctx, GL_INVALID_OPERATION,
1612                      "glUseProgram(program %u not linked)", program);
1613          return;
1614       }
1615
1616       /* debug code */
1617       if (ctx->Shader.Flags & GLSL_USE_PROG) {
1618          print_shader_info(shProg);
1619       }
1620    }
1621    else {
1622       shProg = NULL;
1623    }
1624
1625    _mesa_use_program(ctx, shProg);
1626 }
1627
1628
1629 void GLAPIENTRY
1630 _mesa_ValidateProgramARB(GLhandleARB program)
1631 {
1632    GET_CURRENT_CONTEXT(ctx);
1633    validate_program(ctx, program);
1634 }
1635
1636 #ifdef FEATURE_ES2
1637
1638 void GLAPIENTRY
1639 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1640                                GLint* range, GLint* precision)
1641 {
1642    const struct gl_program_constants *limits;
1643    const struct gl_precision *p;
1644    GET_CURRENT_CONTEXT(ctx);
1645
1646    switch (shadertype) {
1647    case GL_VERTEX_SHADER:
1648       limits = &ctx->Const.VertexProgram;
1649       break;
1650    case GL_FRAGMENT_SHADER:
1651       limits = &ctx->Const.FragmentProgram;
1652       break;
1653    default:
1654       _mesa_error(ctx, GL_INVALID_ENUM,
1655                   "glGetShaderPrecisionFormat(shadertype)");
1656       return;
1657    }
1658
1659    switch (precisiontype) {
1660    case GL_LOW_FLOAT:
1661       p = &limits->LowFloat;
1662       break;
1663    case GL_MEDIUM_FLOAT:
1664       p = &limits->MediumFloat;
1665       break;
1666    case GL_HIGH_FLOAT:
1667       p = &limits->HighFloat;
1668       break;
1669    case GL_LOW_INT:
1670       p = &limits->LowInt;
1671       break;
1672    case GL_MEDIUM_INT:
1673       p = &limits->MediumInt;
1674       break;
1675    case GL_HIGH_INT:
1676       p = &limits->HighInt;
1677       break;
1678    default:
1679       _mesa_error(ctx, GL_INVALID_ENUM,
1680                   "glGetShaderPrecisionFormat(precisiontype)");
1681       return;
1682    }
1683
1684    range[0] = p->RangeMin;
1685    range[1] = p->RangeMax;
1686    precision[0] = p->Precision;
1687 }
1688
1689
1690 void GLAPIENTRY
1691 _mesa_ReleaseShaderCompiler(void)
1692 {
1693    _mesa_destroy_shader_compiler_caches();
1694 }
1695
1696
1697 void GLAPIENTRY
1698 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1699                    const void* binary, GLint length)
1700 {
1701    GET_CURRENT_CONTEXT(ctx);
1702    (void) n;
1703    (void) shaders;
1704    (void) binaryformat;
1705    (void) binary;
1706    (void) length;
1707    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1708 }
1709
1710 #endif /* FEATURE_ES2 */
1711
1712
1713 #if FEATURE_ARB_geometry_shader4
1714
1715 void GLAPIENTRY
1716 _mesa_ProgramParameteriARB(GLuint program, GLenum pname,
1717                            GLint value)
1718 {
1719    struct gl_shader_program *shProg;
1720    GET_CURRENT_CONTEXT(ctx);
1721
1722    ASSERT_OUTSIDE_BEGIN_END(ctx);
1723
1724    shProg = _mesa_lookup_shader_program_err(ctx, program,
1725                                             "glProgramParameteri");
1726    if (!shProg)
1727       return;
1728
1729    switch (pname) {
1730    case GL_GEOMETRY_VERTICES_OUT_ARB:
1731       if (value < 1 ||
1732           (unsigned) value > ctx->Const.GeometryProgram.MaxGeometryOutputVertices) {
1733          _mesa_error(ctx, GL_INVALID_VALUE,
1734                      "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1735                      value);
1736          return;
1737       }
1738       shProg->Geom.VerticesOut = value;
1739       break;
1740    case GL_GEOMETRY_INPUT_TYPE_ARB:
1741       switch (value) {
1742       case GL_POINTS:
1743       case GL_LINES:
1744       case GL_LINES_ADJACENCY_ARB:
1745       case GL_TRIANGLES:
1746       case GL_TRIANGLES_ADJACENCY_ARB:
1747          shProg->Geom.InputType = value;
1748          break;
1749       default:
1750          _mesa_error(ctx, GL_INVALID_VALUE,
1751                      "glProgramParameteri(geometry input type = %s",
1752                      _mesa_lookup_enum_by_nr(value));
1753          return;
1754       }
1755       break;
1756    case GL_GEOMETRY_OUTPUT_TYPE_ARB:
1757       switch (value) {
1758       case GL_POINTS:
1759       case GL_LINE_STRIP:
1760       case GL_TRIANGLE_STRIP:
1761          shProg->Geom.OutputType = value;
1762          break;
1763       default:
1764          _mesa_error(ctx, GL_INVALID_VALUE,
1765                      "glProgramParameteri(geometry output type = %s",
1766                      _mesa_lookup_enum_by_nr(value));
1767          return;
1768       }
1769       break;
1770    default:
1771       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteriARB(pname=%s)",
1772                   _mesa_lookup_enum_by_nr(pname));
1773       break;
1774    }
1775 }
1776
1777 #endif
1778
1779 void
1780 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
1781                          struct gl_shader_program *shProg)
1782 {
1783    use_shader_program(ctx, type, shProg);
1784
1785    if (ctx->Driver.UseProgram)
1786       ctx->Driver.UseProgram(ctx, shProg);
1787 }
1788
1789 void GLAPIENTRY
1790 _mesa_UseShaderProgramEXT(GLenum type, GLuint program)
1791 {
1792    GET_CURRENT_CONTEXT(ctx);
1793    struct gl_shader_program *shProg = NULL;
1794
1795    if (!validate_shader_target(ctx, type)) {
1796       _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");
1797       return;
1798    }
1799
1800    if (ctx->TransformFeedback.CurrentObject->Active) {
1801       _mesa_error(ctx, GL_INVALID_OPERATION,
1802                   "glUseShaderProgramEXT(transform feedback is active)");
1803       return;
1804    }
1805
1806    if (program) {
1807       shProg = _mesa_lookup_shader_program_err(ctx, program,
1808                                                "glUseShaderProgramEXT");
1809       if (shProg == NULL)
1810          return;
1811
1812       if (!shProg->LinkStatus) {
1813          _mesa_error(ctx, GL_INVALID_OPERATION,
1814                      "glUseShaderProgramEXT(program not linked)");
1815          return;
1816       }
1817    }
1818
1819    _mesa_use_shader_program(ctx, type, shProg);
1820 }
1821
1822 void GLAPIENTRY
1823 _mesa_ActiveProgramEXT(GLuint program)
1824 {
1825    GET_CURRENT_CONTEXT(ctx);
1826    struct gl_shader_program *shProg = (program != 0)
1827       ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
1828       : NULL;
1829
1830    _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
1831    return;
1832 }
1833
1834 GLuint GLAPIENTRY
1835 _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
1836 {
1837    GET_CURRENT_CONTEXT(ctx);
1838    const GLuint shader = create_shader(ctx, type);
1839    GLuint program = 0;
1840
1841    if (shader) {
1842       shader_source(ctx, shader, _mesa_strdup(string));
1843       compile_shader(ctx, shader);
1844
1845       program = create_shader_program(ctx);
1846       if (program) {
1847          struct gl_shader_program *shProg;
1848          struct gl_shader *sh;
1849          GLint compiled = GL_FALSE;
1850
1851          shProg = _mesa_lookup_shader_program(ctx, program);
1852          sh = _mesa_lookup_shader(ctx, shader);
1853
1854          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
1855          if (compiled) {
1856             attach_shader(ctx, program, shader);
1857             link_program(ctx, program);
1858             detach_shader(ctx, program, shader);
1859
1860 #if 0
1861             /* Possibly... */
1862             if (active-user-defined-varyings-in-linked-program) {
1863                append-error-to-info-log;
1864                shProg->LinkStatus = GL_FALSE;
1865             }
1866 #endif
1867          }
1868
1869          ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
1870       }
1871
1872       delete_shader(ctx, shader);
1873    }
1874
1875    return program;
1876 }
1877
1878 /**
1879  * Plug in shader-related functions into API dispatch table.
1880  */
1881 void
1882 _mesa_init_shader_dispatch(struct _glapi_table *exec)
1883 {
1884 #if FEATURE_GL
1885    /* GL_ARB_vertex/fragment_shader */
1886    SET_DeleteObjectARB(exec, _mesa_DeleteObjectARB);
1887    SET_GetHandleARB(exec, _mesa_GetHandleARB);
1888    SET_DetachObjectARB(exec, _mesa_DetachObjectARB);
1889    SET_CreateShaderObjectARB(exec, _mesa_CreateShaderObjectARB);
1890    SET_ShaderSourceARB(exec, _mesa_ShaderSourceARB);
1891    SET_CompileShaderARB(exec, _mesa_CompileShaderARB);
1892    SET_CreateProgramObjectARB(exec, _mesa_CreateProgramObjectARB);
1893    SET_AttachObjectARB(exec, _mesa_AttachObjectARB);
1894    SET_LinkProgramARB(exec, _mesa_LinkProgramARB);
1895    SET_UseProgramObjectARB(exec, _mesa_UseProgramObjectARB);
1896    SET_ValidateProgramARB(exec, _mesa_ValidateProgramARB);
1897    SET_GetObjectParameterfvARB(exec, _mesa_GetObjectParameterfvARB);
1898    SET_GetObjectParameterivARB(exec, _mesa_GetObjectParameterivARB);
1899    SET_GetInfoLogARB(exec, _mesa_GetInfoLogARB);
1900    SET_GetAttachedObjectsARB(exec, _mesa_GetAttachedObjectsARB);
1901    SET_GetShaderSourceARB(exec, _mesa_GetShaderSourceARB);
1902
1903    /* OpenGL 2.0 */
1904    SET_AttachShader(exec, _mesa_AttachShader);
1905    SET_CreateProgram(exec, _mesa_CreateProgram);
1906    SET_CreateShader(exec, _mesa_CreateShader);
1907    SET_DeleteProgram(exec, _mesa_DeleteProgram);
1908    SET_DeleteShader(exec, _mesa_DeleteShader);
1909    SET_DetachShader(exec, _mesa_DetachShader);
1910    SET_GetAttachedShaders(exec, _mesa_GetAttachedShaders);
1911    SET_GetProgramiv(exec, _mesa_GetProgramiv);
1912    SET_GetProgramInfoLog(exec, _mesa_GetProgramInfoLog);
1913    SET_GetShaderiv(exec, _mesa_GetShaderiv);
1914    SET_GetShaderInfoLog(exec, _mesa_GetShaderInfoLog);
1915    SET_IsProgram(exec, _mesa_IsProgram);
1916    SET_IsShader(exec, _mesa_IsShader);
1917
1918 #if FEATURE_ARB_vertex_shader
1919    SET_BindAttribLocationARB(exec, _mesa_BindAttribLocationARB);
1920    SET_GetActiveAttribARB(exec, _mesa_GetActiveAttribARB);
1921    SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB);
1922 #endif
1923
1924 #if FEATURE_ARB_geometry_shader4
1925    SET_ProgramParameteriARB(exec, _mesa_ProgramParameteriARB);
1926 #endif
1927
1928    SET_UseShaderProgramEXT(exec, _mesa_UseShaderProgramEXT);
1929    SET_ActiveProgramEXT(exec, _mesa_ActiveProgramEXT);
1930    SET_CreateShaderProgramEXT(exec, _mesa_CreateShaderProgramEXT);
1931
1932    /* GL_EXT_gpu_shader4 / GL 3.0 */
1933    SET_BindFragDataLocationEXT(exec, _mesa_BindFragDataLocation);
1934    SET_GetFragDataLocationEXT(exec, _mesa_GetFragDataLocation);
1935
1936    /* GL_ARB_ES2_compatibility */
1937    SET_ReleaseShaderCompiler(exec, _mesa_ReleaseShaderCompiler);
1938    SET_GetShaderPrecisionFormat(exec, _mesa_GetShaderPrecisionFormat);
1939
1940 #endif /* FEATURE_GL */
1941 }
1942