src/mesa/main/shaderapi.c

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