Subversion Repositories Kolibri OS

/*

 * Mesa 3-D graphics library

 *

 * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.

 * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR

 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 */

/**

 * \file shaderapi.c

 * \author Brian Paul

 *

 * Implementation of GLSL-related API functions.

 * The glUniform* functions are in uniforms.c

 *

 *

 * XXX things to do:

 * 1. Check that the right error code is generated for all _mesa_error() calls.

 * 2. Insert FLUSH_VERTICES calls in various places

 */

#include "main/glheader.h"

#include "main/context.h"

#include "main/dispatch.h"

#include "main/enums.h"

#include "main/hash.h"

#include "main/mtypes.h"

#include "main/shaderapi.h"

#include "main/shaderobj.h"

#include "main/transformfeedback.h"

#include "main/uniforms.h"

#include "program/program.h"

#include "program/prog_print.h"

#include "program/prog_parameter.h"

#include "ralloc.h"

#include 

#include "../glsl/glsl_parser_extras.h"

#include "../glsl/ir.h"

#include "../glsl/ir_uniform.h"

#include "../glsl/program.h"

/** Define this to enable shader substitution (see below) */

#define SHADER_SUBST 0

/**

 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.

 */

static GLbitfield

get_shader_flags(void)

{

   GLbitfield flags = 0x0;

   const char *env = _mesa_getenv("MESA_GLSL");

   if (env) {

      if (strstr(env, "dump"))

         flags |= GLSL_DUMP;

      if (strstr(env, "log"))

         flags |= GLSL_LOG;

      if (strstr(env, "nopvert"))

         flags |= GLSL_NOP_VERT;

      if (strstr(env, "nopfrag"))

         flags |= GLSL_NOP_FRAG;

      if (strstr(env, "nopt"))

         flags |= GLSL_NO_OPT;

      else if (strstr(env, "opt"))

         flags |= GLSL_OPT;

      if (strstr(env, "uniform"))

         flags |= GLSL_UNIFORMS;

      if (strstr(env, "useprog"))

         flags |= GLSL_USE_PROG;

      if (strstr(env, "errors"))

         flags |= GLSL_REPORT_ERRORS;

   }

   return flags;

}

/**

 * Initialize context's shader state.

 */

void

_mesa_init_shader_state(struct gl_context *ctx)

{

   /* Device drivers may override these to control what kind of instructions

    * are generated by the GLSL compiler.

    */

   struct gl_shader_compiler_options options;

   gl_shader_type sh;

   memset(&options, 0, sizeof(options));

   options.MaxUnrollIterations = 32;

   options.MaxIfDepth = UINT_MAX;

   /* Default pragma settings */

   options.DefaultPragmas.Optimize = GL_TRUE;

   for (sh = 0; sh < MESA_SHADER_TYPES; ++sh)

      memcpy(&ctx->ShaderCompilerOptions[sh], &options, sizeof(options));

   ctx->Shader.Flags = get_shader_flags();

}

/**

 * Free the per-context shader-related state.

 */

void

_mesa_free_shader_state(struct gl_context *ctx)

{

   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentVertexProgram, NULL);

   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentGeometryProgram,

				  NULL);

   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentFragmentProgram,

				  NULL);

   _mesa_reference_shader_program(ctx, &ctx->Shader._CurrentFragmentProgram,

				  NULL);

   _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);

}

/**

 * Copy string from  to , up to maxLength characters, returning

 * length of  in .

 * \param src  the strings source

 * \param maxLength  max chars to copy

 * \param length  returns number of chars copied

 * \param dst  the string destination

 */

void

_mesa_copy_string(GLchar *dst, GLsizei maxLength,

                  GLsizei *length, const GLchar *src)

{

   GLsizei len;

   for (len = 0; len < maxLength - 1 && src && src[len]; len++)

      dst[len] = src[len];

   if (maxLength > 0)

      dst[len] = 0;

   if (length)

      *length = len;

}

/**

 * Confirm that the a shader type is valid and supported by the implementation

 *

 * \param ctx   Current GL context

 * \param type  Shader target

 *

 */

static bool

validate_shader_target(const struct gl_context *ctx, GLenum type)

{

   switch (type) {

   case GL_FRAGMENT_SHADER:

      return ctx->Extensions.ARB_fragment_shader;

   case GL_VERTEX_SHADER:

      return ctx->Extensions.ARB_vertex_shader;

   case GL_GEOMETRY_SHADER_ARB:

      return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_geometry_shader4;

   default:

      return false;

   }

}

static GLboolean

is_program(struct gl_context *ctx, GLuint name)

{

   struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);

   return shProg ? GL_TRUE : GL_FALSE;

}

static GLboolean

is_shader(struct gl_context *ctx, GLuint name)

{

   struct gl_shader *shader = _mesa_lookup_shader(ctx, name);

   return shader ? GL_TRUE : GL_FALSE;

}

/**

 * Attach shader to a shader program.

 */

static void

attach_shader(struct gl_context *ctx, GLuint program, GLuint shader)

{

   struct gl_shader_program *shProg;

   struct gl_shader *sh;

   GLuint i, n;

   const bool same_type_disallowed = _mesa_is_gles(ctx);

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");

   if (!shProg)

      return;

   sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");

   if (!sh) {

      return;

   }

   n = shProg->NumShaders;

   for (i = 0; i < n; i++) {

      if (shProg->Shaders[i] == sh) {

         /* The shader is already attched to this program.  The

          * GL_ARB_shader_objects spec says:

          *

          *     "The error INVALID_OPERATION is generated by AttachObjectARB

          *     if  is already attached to ."

          */

         _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");

         return;

      } else if (same_type_disallowed &&

                 shProg->Shaders[i]->Type == sh->Type) {

        /* Shader with the same type is already attached to this program,

         * OpenGL ES 2.0 and 3.0 specs say:

         *

         *      "Multiple shader objects of the same type may not be attached

         *      to a single program object. [...] The error INVALID_OPERATION

         *      is generated if [...] another shader object of the same type

         *      as shader is already attached to program."

         */

         _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");

         return;

      }

   }

   /* grow list */

   shProg->Shaders = (struct gl_shader **)

      _mesa_realloc(shProg->Shaders,

                    n * sizeof(struct gl_shader *),

                    (n + 1) * sizeof(struct gl_shader *));

   if (!shProg->Shaders) {

      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");

      return;

   }

   /* append */

   shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */

   _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);

   shProg->NumShaders++;

}

static GLuint

create_shader(struct gl_context *ctx, GLenum type)

{

   struct gl_shader *sh;

   GLuint name;

   if (!validate_shader_target(ctx, type)) {

      _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");

      return 0;

   }

   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);

   sh = ctx->Driver.NewShader(ctx, name, type);

   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);

   return name;

}

static GLuint

create_shader_program(struct gl_context *ctx)

{

   GLuint name;

   struct gl_shader_program *shProg;

   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);

   shProg = ctx->Driver.NewShaderProgram(ctx, name);

   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);

   assert(shProg->RefCount == 1);

   return name;

}

/**

 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's

 * DeleteProgramARB.

 */

static void

delete_shader_program(struct gl_context *ctx, GLuint name)

{

   /*

    * NOTE: deleting shaders/programs works a bit differently than

    * texture objects (and buffer objects, etc).  Shader/program

    * handles/IDs exist in the hash table until the object is really

    * deleted (refcount==0).  With texture objects, the handle/ID is

    * removed from the hash table in glDeleteTextures() while the tex

    * object itself might linger until its refcount goes to zero.

    */

   struct gl_shader_program *shProg;

   shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");

   if (!shProg)

      return;

   if (!shProg->DeletePending) {

      shProg->DeletePending = GL_TRUE;

      /* effectively, decr shProg's refcount */

      _mesa_reference_shader_program(ctx, &shProg, NULL);

   }

}

static void

delete_shader(struct gl_context *ctx, GLuint shader)

{

   struct gl_shader *sh;

   sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");

   if (!sh)

      return;

   if (!sh->DeletePending) {

      sh->DeletePending = GL_TRUE;

      /* effectively, decr sh's refcount */

      _mesa_reference_shader(ctx, &sh, NULL);

   }

}

static void

detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)

{

   struct gl_shader_program *shProg;

   GLuint n;

   GLuint i, j;

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");

   if (!shProg)

      return;

   n = shProg->NumShaders;

   for (i = 0; i < n; i++) {

      if (shProg->Shaders[i]->Name == shader) {

         /* found it */

         struct gl_shader **newList;

         /* release */

         _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);

         /* alloc new, smaller array */

         newList =

            malloc((n - 1) * sizeof(struct gl_shader *));

         if (!newList) {

            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");

            return;

         }

         for (j = 0; j < i; j++) {

            newList[j] = shProg->Shaders[j];

         }

         while (++i < n)

            newList[j++] = shProg->Shaders[i];

         free(shProg->Shaders);

         shProg->Shaders = newList;

         shProg->NumShaders = n - 1;

#ifdef DEBUG

         /* sanity check */

         {

            for (j = 0; j < shProg->NumShaders; j++) {

               assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||

                      shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);

               assert(shProg->Shaders[j]->RefCount > 0);

            }

         }

#endif

         return;

      }

   }

   /* not found */

   {

      GLenum err;

      if (is_shader(ctx, shader))

         err = GL_INVALID_OPERATION;

      else if (is_program(ctx, shader))

         err = GL_INVALID_OPERATION;

      else

         err = GL_INVALID_VALUE;

      _mesa_error(ctx, err, "glDetachProgram(shader)");

      return;

   }

}

/**

 * Return list of shaders attached to shader program.

 */

static void

get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,

                     GLsizei *count, GLuint *obj)

{

   struct gl_shader_program *shProg =

      _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");

   if (shProg) {

      GLuint i;

      for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {

         obj[i] = shProg->Shaders[i]->Name;

      }

      if (count)

         *count = i;

   }

}

/**

 * glGetHandleARB() - return ID/name of currently bound shader program.

 */

static GLuint

get_handle(struct gl_context *ctx, GLenum pname)

{

   if (pname == GL_PROGRAM_OBJECT_ARB) {

      if (ctx->Shader.ActiveProgram)

         return ctx->Shader.ActiveProgram->Name;

      else

         return 0;

   }

   else {

      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");

      return 0;

   }

}

/**

 * glGetProgramiv() - get shader program state.

 * Note that this is for GLSL shader programs, not ARB vertex/fragment

 * programs (see glGetProgramivARB).

 */

static void

get_programiv(struct gl_context *ctx, GLuint program, GLenum pname, GLint *params)

{

   struct gl_shader_program *shProg

      = _mesa_lookup_shader_program(ctx, program);

   /* Is transform feedback available in this context?

    */

   const bool has_xfb =

      (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.EXT_transform_feedback)

      || ctx->API == API_OPENGL_CORE

      || _mesa_is_gles3(ctx);

   /* Are geometry shaders available in this context?

    */

   const bool has_gs =

      _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_geometry_shader4;

   /* Are uniform buffer objects available in this context?

    */

   const bool has_ubo =

      (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.ARB_uniform_buffer_object)

      || ctx->API == API_OPENGL_CORE

      || _mesa_is_gles3(ctx);

   if (!shProg) {

      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");

      return;

   }

   switch (pname) {

   case GL_DELETE_STATUS:

      *params = shProg->DeletePending;

      return;

   case GL_LINK_STATUS:

      *params = shProg->LinkStatus;

      return;

   case GL_VALIDATE_STATUS:

      *params = shProg->Validated;

      return;

   case GL_INFO_LOG_LENGTH:

      *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;

      return;

   case GL_ATTACHED_SHADERS:

      *params = shProg->NumShaders;

      return;

   case GL_ACTIVE_ATTRIBUTES:

      *params = _mesa_count_active_attribs(shProg);

      return;

   case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:

      *params = _mesa_longest_attribute_name_length(shProg);

      return;

   case GL_ACTIVE_UNIFORMS:

      *params = shProg->NumUserUniformStorage;

      return;

   case GL_ACTIVE_UNIFORM_MAX_LENGTH: {

      unsigned i;

      GLint max_len = 0;

      for (i = 0; i < shProg->NumUserUniformStorage; i++) {

	 /* Add one for the terminating NUL character for a non-array, and

	  * 4 for the "[0]" and the NUL for an array.

	  */

	 const GLint len = strlen(shProg->UniformStorage[i].name) + 1 +

	     ((shProg->UniformStorage[i].array_elements != 0) ? 3 : 0);

	 if (len > max_len)

	    max_len = len;

      }

      *params = max_len;

      return;

   }

   case GL_TRANSFORM_FEEDBACK_VARYINGS:

      if (!has_xfb)

         break;

      *params = shProg->TransformFeedback.NumVarying;

      return;

   case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: {

      unsigned i;

      GLint max_len = 0;

      if (!has_xfb)

         break;

      for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {

         /* Add one for the terminating NUL character.

          */

         const GLint len = strlen(shProg->TransformFeedback.VaryingNames[i]) + 1;

         if (len > max_len)

            max_len = len;

      }

      *params = max_len;

      return;

   }

   case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:

      if (!has_xfb)

         break;

      *params = shProg->TransformFeedback.BufferMode;

      return;

   case GL_GEOMETRY_VERTICES_OUT_ARB:

      if (!has_gs)

         break;

      *params = shProg->Geom.VerticesOut;

      return;

   case GL_GEOMETRY_INPUT_TYPE_ARB:

      if (!has_gs)

         break;

      *params = shProg->Geom.InputType;

      return;

   case GL_GEOMETRY_OUTPUT_TYPE_ARB:

      if (!has_gs)

         break;

      *params = shProg->Geom.OutputType;

      return;

   case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: {

      unsigned i;

      GLint max_len = 0;

      if (!has_ubo)

         break;

      for (i = 0; i < shProg->NumUniformBlocks; i++) {

	 /* Add one for the terminating NUL character.

	  */

	 const GLint len = strlen(shProg->UniformBlocks[i].Name) + 1;

	 if (len > max_len)

	    max_len = len;

      }

      *params = max_len;

      return;

   }

   case GL_ACTIVE_UNIFORM_BLOCKS:

      if (!has_ubo)

         break;

      *params = shProg->NumUniformBlocks;

      return;

   case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:

      /* This enum isn't part of the OES extension for OpenGL ES 2.0.  It is

       * only available with desktop OpenGL 3.0+ with the

       * GL_ARB_get_program_binary extension or OpenGL ES 3.0.

       *

       * On desktop, we ignore the 3.0+ requirement because it is silly.

       */

      if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx))

         break;

      *params = shProg->BinaryRetreivableHint;

      return;

   case GL_PROGRAM_BINARY_LENGTH:

      *params = 0;

      return;

   default:

      break;

   }

   _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname=%s)",

               _mesa_lookup_enum_by_nr(pname));

}

/**

 * glGetShaderiv() - get GLSL shader state

 */

static void

get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)

{

   struct gl_shader *shader =

      _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");

   if (!shader) {

      return;

   }

   switch (pname) {

   case GL_SHADER_TYPE:

      *params = shader->Type;

      break;

   case GL_DELETE_STATUS:

      *params = shader->DeletePending;

      break;

   case GL_COMPILE_STATUS:

      *params = shader->CompileStatus;

      break;

   case GL_INFO_LOG_LENGTH:

      *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;

      break;

   case GL_SHADER_SOURCE_LENGTH:

      *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;

      break;

   default:

      _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");

      return;

   }

}

static void

get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,

                     GLsizei *length, GLchar *infoLog)

{

   struct gl_shader_program *shProg

      = _mesa_lookup_shader_program(ctx, program);

   if (!shProg) {

      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");

      return;

   }

   _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);

}

static void

get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,

                    GLsizei *length, GLchar *infoLog)

{

   struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);

   if (!sh) {

      _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");

      return;

   }

   _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);

}

/**

 * Return shader source code.

 */

static void

get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,

                  GLsizei *length, GLchar *sourceOut)

{

   struct gl_shader *sh;

   sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");

   if (!sh) {

      return;

   }

   _mesa_copy_string(sourceOut, maxLength, length, sh->Source);

}

/**

 * Set/replace shader source code.  A helper function used by

 * glShaderSource[ARB] and glCreateShaderProgramEXT.

 */

static void

shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)

{

   struct gl_shader *sh;

   sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");

   if (!sh)

      return;

   /* free old shader source string and install new one */

   free((void *)sh->Source);

   sh->Source = source;

   sh->CompileStatus = GL_FALSE;

#ifdef DEBUG

   sh->SourceChecksum = _mesa_str_checksum(sh->Source);

#endif

}

/**

 * Compile a shader.

 */

static void

compile_shader(struct gl_context *ctx, GLuint shaderObj)

{

   struct gl_shader *sh;

   struct gl_shader_compiler_options *options;

   sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");

   if (!sh)

      return;

   options = &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(sh->Type)];

   /* set default pragma state for shader */

   sh->Pragmas = options->DefaultPragmas;

   if (!sh->Source) {

      /* If the user called glCompileShader without first calling

       * glShaderSource, we should fail to compile, but not raise a GL_ERROR.

       */

      sh->CompileStatus = GL_FALSE;

   } else {

      if (ctx->Shader.Flags & GLSL_DUMP) {

         printf("GLSL source for %s shader %d:\n",

                _mesa_glsl_shader_target_name(sh->Type), sh->Name);

         printf("%s\n", sh->Source);

      }

      /* this call will set the shader->CompileStatus field to indicate if

       * compilation was successful.

       */

      _mesa_glsl_compile_shader(ctx, sh, false, false);

      if (ctx->Shader.Flags & GLSL_LOG) {

         _mesa_write_shader_to_file(sh);

      }

      if (ctx->Shader.Flags & GLSL_DUMP) {

         if (sh->CompileStatus) {

            printf("GLSL IR for shader %d:\n", sh->Name);

            _mesa_print_ir(sh->ir, NULL);

            printf("\n\n");

         } else {

            printf("GLSL shader %d failed to compile.\n", sh->Name);

         }

         if (sh->InfoLog && sh->InfoLog[0] != 0) {

            printf("GLSL shader %d info log:\n", sh->Name);

            printf("%s\n", sh->InfoLog);

         }

      }

   }

   if (sh->CompileStatus == GL_FALSE &&

       (ctx->Shader.Flags & GLSL_REPORT_ERRORS)) {

      _mesa_debug(ctx, "Error compiling shader %u:\n%s\n",

                  sh->Name, sh->InfoLog);

   }

}

/**

 * Link a program's shaders.

 */

static void

link_program(struct gl_context *ctx, GLuint program)

{

   struct gl_shader_program *shProg;

   struct gl_transform_feedback_object *obj =

      ctx->TransformFeedback.CurrentObject;

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");

   if (!shProg)

      return;

   if (obj->Active

       && (shProg == ctx->Shader.CurrentVertexProgram

	   || shProg == ctx->Shader.CurrentGeometryProgram

	   || shProg == ctx->Shader.CurrentFragmentProgram)) {

      _mesa_error(ctx, GL_INVALID_OPERATION,

                  "glLinkProgram(transform feedback active)");

      return;

   }

   FLUSH_VERTICES(ctx, _NEW_PROGRAM);

   _mesa_glsl_link_shader(ctx, shProg);

   if (shProg->LinkStatus == GL_FALSE &&

       (ctx->Shader.Flags & GLSL_REPORT_ERRORS)) {

      _mesa_debug(ctx, "Error linking program %u:\n%s\n",

                  shProg->Name, shProg->InfoLog);

   }

   /* debug code */

   if (0) {

      GLuint i;

      printf("Link %u shaders in program %u: %s\n",

                   shProg->NumShaders, shProg->Name,

                   shProg->LinkStatus ? "Success" : "Failed");

      for (i = 0; i < shProg->NumShaders; i++) {

         printf(" shader %u, type 0x%x\n",

                      shProg->Shaders[i]->Name,

                      shProg->Shaders[i]->Type);

      }

   }

}

/**

 * Print basic shader info (for debug).

 */

static void

print_shader_info(const struct gl_shader_program *shProg)

{

   GLuint i;

   printf("Mesa: glUseProgram(%u)\n", shProg->Name);

   for (i = 0; i < shProg->NumShaders; i++) {

      printf("  %s shader %u, checksum %u\n",

             _mesa_glsl_shader_target_name(shProg->Shaders[i]->Type),

	     shProg->Shaders[i]->Name,

	     shProg->Shaders[i]->SourceChecksum);

   }

   if (shProg->_LinkedShaders[MESA_SHADER_VERTEX])

      printf("  vert prog %u\n",

	     shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program->Id);

   if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT])

      printf("  frag prog %u\n",

	     shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program->Id);

   if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY])

      printf("  geom prog %u\n",

	     shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program->Id);

}

/**

 * Use the named shader program for subsequent glUniform calls

 */

void

_mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,

		     const char *caller)

{

   if ((shProg != NULL) && !shProg->LinkStatus) {

      _mesa_error(ctx, GL_INVALID_OPERATION,

		  "%s(program %u not linked)", caller, shProg->Name);

      return;

   }

   if (ctx->Shader.ActiveProgram != shProg) {

      _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);

   }

}

/**

 */

static bool

use_shader_program(struct gl_context *ctx, GLenum type,

		   struct gl_shader_program *shProg)

{

   struct gl_shader_program **target;

   switch (type) {

   case GL_VERTEX_SHADER:

      target = &ctx->Shader.CurrentVertexProgram;

      if ((shProg == NULL)

	  || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) {

	 shProg = NULL;

      }

      break;

   case GL_GEOMETRY_SHADER_ARB:

      target = &ctx->Shader.CurrentGeometryProgram;

      if ((shProg == NULL)

	  || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) {

	 shProg = NULL;

      }

      break;

   case GL_FRAGMENT_SHADER:

      target = &ctx->Shader.CurrentFragmentProgram;

      if ((shProg == NULL)

	  || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) {

	 shProg = NULL;

      }

      break;

   default:

      return false;

   }

   if (*target != shProg) {

      FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);

      /* If the shader is also bound as the current rendering shader, unbind

       * it from that binding point as well.  This ensures that the correct

       * semantics of glDeleteProgram are maintained.

       */

      switch (type) {

      case GL_VERTEX_SHADER:

	 /* Empty for now. */

	 break;

      case GL_GEOMETRY_SHADER_ARB:

	 /* Empty for now. */

	 break;

      case GL_FRAGMENT_SHADER:

	 if (*target == ctx->Shader._CurrentFragmentProgram) {

	    _mesa_reference_shader_program(ctx,

					   &ctx->Shader._CurrentFragmentProgram,

					   NULL);

	 }

	 break;

      }

      _mesa_reference_shader_program(ctx, target, shProg);

      return true;

   }

   return false;

}

/**

 * Use the named shader program for subsequent rendering.

 */

void

_mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)

{

   use_shader_program(ctx, GL_VERTEX_SHADER, shProg);

   use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);

   use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);

   _mesa_active_program(ctx, shProg, "glUseProgram");

   if (ctx->Driver.UseProgram)

      ctx->Driver.UseProgram(ctx, shProg);

}

/**

 * Do validation of the given shader program.

 * \param errMsg  returns error message if validation fails.

 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)

 */

static GLboolean

validate_shader_program(const struct gl_shader_program *shProg,

                        char *errMsg)

{

   if (!shProg->LinkStatus) {

      return GL_FALSE;

   }

   /* From the GL spec, a program is invalid if any of these are true:

     any two active samplers in the current program object are of

     different types, but refer to the same texture image unit,

     any active sampler in the current program object refers to a texture

     image unit where fixed-function fragment processing accesses a

     texture target that does not match the sampler type, or

     the sum of the number of active samplers in the program and the

     number of texture image units enabled for fixed-function fragment

     processing exceeds the combined limit on the total number of texture

     image units allowed.

   */

   /*

    * Check: any two active samplers in the current program object are of

    * different types, but refer to the same texture image unit,

    */

   if (!_mesa_sampler_uniforms_are_valid(shProg, errMsg, 100))

      return GL_FALSE;

   return GL_TRUE;

}

/**

 * Called via glValidateProgram()

 */

static void

validate_program(struct gl_context *ctx, GLuint program)

{

   struct gl_shader_program *shProg;

   char errMsg[100] = "";

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");

   if (!shProg) {

      return;

   }

   shProg->Validated = validate_shader_program(shProg, errMsg);

   if (!shProg->Validated) {

      /* update info log */

      if (shProg->InfoLog) {

         ralloc_free(shProg->InfoLog);

      }

      shProg->InfoLog = ralloc_strdup(shProg, errMsg);

   }

}

void GLAPIENTRY

_mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)

{

   GET_CURRENT_CONTEXT(ctx);

   attach_shader(ctx, program, shader);

}

void GLAPIENTRY

_mesa_AttachShader(GLuint program, GLuint shader)

{

   GET_CURRENT_CONTEXT(ctx);

   attach_shader(ctx, program, shader);

}

void GLAPIENTRY

_mesa_CompileShader(GLhandleARB shaderObj)

{

   GET_CURRENT_CONTEXT(ctx);

   if (MESA_VERBOSE & VERBOSE_API)

      _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);

   compile_shader(ctx, shaderObj);

}

GLuint GLAPIENTRY

_mesa_CreateShader(GLenum type)

{

   GET_CURRENT_CONTEXT(ctx);

   if (MESA_VERBOSE & VERBOSE_API)

      _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));

   return create_shader(ctx, type);

}

GLhandleARB GLAPIENTRY

_mesa_CreateShaderObjectARB(GLenum type)

{

   GET_CURRENT_CONTEXT(ctx);

   return create_shader(ctx, type);

}

GLuint GLAPIENTRY

_mesa_CreateProgram(void)

{

   GET_CURRENT_CONTEXT(ctx);

   if (MESA_VERBOSE & VERBOSE_API)

      _mesa_debug(ctx, "glCreateProgram\n");

   return create_shader_program(ctx);

}

GLhandleARB GLAPIENTRY

_mesa_CreateProgramObjectARB(void)

{

   GET_CURRENT_CONTEXT(ctx);

   return create_shader_program(ctx);

}

void GLAPIENTRY

_mesa_DeleteObjectARB(GLhandleARB obj)

{

   if (MESA_VERBOSE & VERBOSE_API) {

      GET_CURRENT_CONTEXT(ctx);

      _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);

   }

   if (obj) {

      GET_CURRENT_CONTEXT(ctx);

      FLUSH_VERTICES(ctx, 0);

      if (is_program(ctx, obj)) {

         delete_shader_program(ctx, obj);

      }

      else if (is_shader(ctx, obj)) {

         delete_shader(ctx, obj);

      }

      else {

         /* error? */

      }

   }

}

void GLAPIENTRY

_mesa_DeleteProgram(GLuint name)

{

   if (name) {

      GET_CURRENT_CONTEXT(ctx);

      FLUSH_VERTICES(ctx, 0);

      delete_shader_program(ctx, name);

   }