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