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