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