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