src/mesa/shader/shader_api.c

/*
 * Mesa 3-D graphics library
 * Version:  6.5.3
 *
 * Copyright (C) 2004-2007  Brian Paul   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
 * BRIAN PAUL 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 shader_api.c
 * Implementation of GLSL-related API functions
 * \author Brian Paul
 */

/**
 * 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 "glheader.h"
#include "context.h"
#include "hash.h"
#include "program.h"
#include "prog_parameter.h"
#include "shader_api.h"

#include "slang_compile.h"
#include "slang_link.h"





/**
 * Copy string from <src> to <dst>, up to maxLength characters, returning
 * length of <dst> in <length>.
 * \param src  the strings source
 * \param maxLength  max chars to copy
 * \param length  returns number of chars copied
 * \param dst  the string destination
 */
static void
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;
}




/**
 * Called via ctx->Driver.AttachShader()
 */
void
_mesa_attach_shader(GLcontext *ctx, GLuint program, GLuint shader)
{
   struct gl_linked_program *linked
      = _mesa_lookup_linked_program(ctx, program);
   struct gl_program *prog = _mesa_lookup_shader(ctx, shader);
   const GLuint n = linked->NumShaders;
   GLuint i;

   if (!linked || !prog) {
      _mesa_error(ctx, GL_INVALID_OPERATION,
                  "glAttachShader(bad program or shader name)");
      return;
   }

   for (i = 0; i < n; i++) {
      if (linked->Shaders[i] == prog) {
         /* already attached */
         return;
      }
   }

   /* grow list */
   linked->Shaders = (struct gl_program **)
      _mesa_realloc(linked->Shaders,
                    n * sizeof(struct gl_program *),
                    (n + 1) * sizeof(struct gl_program *));
   if (!linked->Shaders) {
      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
      return;
   }

   /* append */
   linked->Shaders[n] = prog;
   prog->RefCount++;
   linked->NumShaders++;
}


void
_mesa_bind_attrib_location(GLcontext *ctx, GLuint program, GLuint index,
                           const GLchar *name)
{
   struct gl_linked_program *linked
      = _mesa_lookup_linked_program(ctx, program);

   if (!linked) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glBindAttribLocation(program)");
      return;
   }

#if 0 /* XXXX */
   if (name == NULL || index >= MAX_VERTEX_ATTRIBS)
      _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocationARB");
   else if (IS_NAME_WITH_GL_PREFIX(name))
      _mesa_error(ctx, GL_INVALID_OPERATION, "glBindAttribLocationARB");
   else
      (**pro).OverrideAttribBinding(pro, index, name);
   RELEASE_PROGRAM(pro);
#endif
}


GLuint
_mesa_create_shader(GLcontext *ctx, GLenum type)
{
   struct gl_program *newProg;
   GLuint name;

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

   switch (type) {
   case GL_FRAGMENT_SHADER_ARB:
      /* alloc new gl_fragment_program */
      newProg = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, name);
      break;
   case GL_VERTEX_SHADER_ARB:
      /* alloc new gl_vertex_program */
      newProg = ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, name);
      break;
   default:
      _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
      return 0;
   }

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

   return name;
}


GLuint 
_mesa_create_program(GLcontext *ctx)
{
   GLuint name;
   struct gl_linked_program *linked;

   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ProgramObjects, 1);
   linked = _mesa_new_linked_program(ctx, name);

   _mesa_HashInsert(ctx->Shared->ProgramObjects, name, linked);

   return name;
}


void
_mesa_delete_program2(GLcontext *ctx, GLuint name)
{
   struct gl_linked_program *linked;

   linked = _mesa_lookup_linked_program(ctx, name);
   if (!linked) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteProgram(name)");
      return;
   }

   /* XXX refcounting! */
   _mesa_HashRemove(ctx->Shared->ProgramObjects, name);
   _mesa_delete_linked_program(ctx, linked);
}


void
_mesa_delete_shader(GLcontext *ctx, GLuint shader)
{
   /* XXX refcounting! */

   /*
   _mesa_DeleteObjectARB(shader);
   */
}


void
_mesa_detach_shader(GLcontext *ctx, GLuint program, GLuint shader)
{
   struct gl_linked_program *linked
      = _mesa_lookup_linked_program(ctx, program);
   const GLuint n = linked->NumShaders;
   GLuint i, j;

   if (!linked) {
      _mesa_error(ctx, GL_INVALID_OPERATION,
                  "glDetachShader(bad program or shader name)");
      return;
   }

   for (i = 0; i < n; i++) {
      if (linked->Shaders[i]->Id == shader) {
         struct gl_program **newList;
         /* found it */
         /* alloc new, smaller array */
         newList = (struct gl_program **)
            _mesa_malloc((n - 1) * sizeof(struct gl_program *));
         if (!newList) {
            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
            return;
         }
         for (j = 0; j < i; j++) {
            newList[j] = linked->Shaders[j];
         }
         while (++i < n)
            newList[j++] = linked->Shaders[i];
         _mesa_free(linked->Shaders);

         /* XXX refcounting! */

         linked->Shaders = newList;
         return;
      }
   }

   /* not found */
   _mesa_error(ctx, GL_INVALID_OPERATION,
               "glDetachShader(shader not found)");
}


void
_mesa_get_active_attrib(GLcontext *ctx, GLuint program, GLuint index,
                        GLsizei maxLength, GLsizei *length, GLint *size,
                        GLenum *type, GLchar *nameOut)
{
   static const GLenum vec_types[] = {
      GL_FLOAT, GL_FLOAT_VEC2, GL_FLOAT_VEC3, GL_FLOAT_VEC4
   };
   struct gl_linked_program *linked
      = _mesa_lookup_linked_program(ctx, program);
   GLint sz;

   if (!linked) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniform");
      return;
   }

   if (!linked->Attributes || index >= linked->Attributes->NumParameters) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
      return;
   }

   copy_string(nameOut, maxLength, length,
               linked->Attributes->Parameters[index].Name);
   sz = linked->Attributes->Parameters[index].Size;
   if (size)
      *size = sz;
   if (type)
      *type = vec_types[sz]; /* XXX this is a temporary hack */
}


/**
 * Called via ctx->Driver.GetActiveUniform().
 */
void
_mesa_get_active_uniform(GLcontext *ctx, GLuint program, GLuint index,
                         GLsizei maxLength, GLsizei *length, GLint *size,
                         GLenum *type, GLchar *nameOut)
{
   static const GLenum vec_types[] = {
      GL_FLOAT, GL_FLOAT_VEC2, GL_FLOAT_VEC3, GL_FLOAT_VEC4
   };
   struct gl_linked_program *linked
      = _mesa_lookup_linked_program(ctx, program);
   GLint sz;

   if (!linked) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniform");
      return;
   }

   if (!linked->Uniforms || index >= linked->Uniforms->NumParameters) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
      return;
   }

   copy_string(nameOut, maxLength, length,
               linked->Uniforms->Parameters[index].Name);
   sz = linked->Uniforms->Parameters[index].Size;
   if (size)
      *size = sz;
   if (type)
      *type = vec_types[sz]; /* XXX this is a temporary hack */
}


/**
 * Called via ctx->Driver.GetAttachedShaders().
 */
void
_mesa_get_attached_shaders(GLcontext *ctx, GLuint program, GLsizei maxCount,
                           GLsizei *count, GLuint *obj)
{
   struct gl_linked_program *linked
      = _mesa_lookup_linked_program(ctx, program);
   if (linked) {
      GLuint i;
      for (i = 0; i < maxCount && i < linked->NumShaders; i++) {
         obj[i] = linked->Shaders[i]->Id;
      }
      if (count)
         *count = i;
   }
   else {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetAttachedShaders");
   }
}


GLint
_mesa_get_attrib_location(GLcontext *ctx, GLuint program,
                          const GLchar *name)
{
   struct gl_linked_program *linked
      = _mesa_lookup_linked_program(ctx, program);

   if (!linked) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetAttribLocation");
      return -1;
   }

   if (!linked->LinkStatus) {
      _mesa_error(ctx, GL_INVALID_OPERATION,
                  "glGetAttribLocation(program not linked)");
      return -1;
   }

   if (!name)
      return -1;

   if (linked->Attributes) {
      GLuint i;
      for (i = 0; i < linked->Attributes->NumParameters; i++) {
         if (!strcmp(linked->Attributes->Parameters[i].Name, name)) {
            return i;
         }
      }
   }
   return -1;
}


GLuint
_mesa_get_handle(GLcontext *ctx, GLenum pname)
{
#if 0
   GET_CURRENT_CONTEXT(ctx);

   switch (pname) {
   case GL_PROGRAM_OBJECT_ARB:
      {
         struct gl2_program_intf **pro = ctx->Shader.CurrentProgram;

         if (pro != NULL)
            return (**pro)._container._generic.
               GetName((struct gl2_generic_intf **) (pro));
      }
      break;
   default:
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
   }
#endif
   return 0;
}


void
_mesa_get_programiv(GLcontext *ctx, GLuint program,
                    GLenum pname, GLint *params)
{
   struct gl_linked_program *linked
      = _mesa_lookup_linked_program(ctx, program);

   if (!linked) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
      return;
   }

   switch (pname) {
   case GL_DELETE_STATUS:
      *params = linked->DeletePending;
      break; 
   case GL_LINK_STATUS:
      *params = linked->LinkStatus;
      break;
   case GL_VALIDATE_STATUS:
      *params = linked->Validated;
      break;
   case GL_INFO_LOG_LENGTH:
      *params = linked->InfoLog ? strlen(linked->InfoLog) : 0;
      break;
   case GL_ATTACHED_SHADERS:
      *params = linked->NumShaders;
      break;
   case GL_ACTIVE_ATTRIBUTES:
      *params = linked->Uniforms ? linked->Uniforms->NumParameters : 0;
      break;
   case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
      *params = _mesa_parameter_longest_name(linked->Attributes);
      break;
   case GL_ACTIVE_UNIFORMS:
      *params = linked->Uniforms ? linked->Uniforms->NumParameters : 0;
      break;
   case GL_ACTIVE_UNIFORM_MAX_LENGTH:
      *params = _mesa_parameter_longest_name(linked->Uniforms);
      break;
   default:
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");
      return;
   }
}


void
_mesa_get_shaderiv(GLcontext *ctx, GLuint name, GLenum pname, GLint *params)
{
#if 0
   struct gl_program *shader = _mesa_lookup_shader(ctx, name);

   if (!shader) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderiv(shader)");
      return;
   }
#else
   struct gl_shader *shader;
#endif
   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) : 0;
      break;
   case GL_SHADER_SOURCE_LENGTH:
      *params = shader->Source ? strlen((char *) shader->Source) : 0;
      break;
   default:
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
      return;
   }
}


void
_mesa_get_program_info_log(GLcontext *ctx, GLuint program, GLsizei bufSize,
                           GLsizei *length, GLchar *infoLog)
{
   struct gl_linked_program *linked
      = _mesa_lookup_linked_program(ctx, program);
   if (!linked) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
      return;
   }
   /* XXX also test length, infoLog params for NULL? */
   copy_string(linked->InfoLog, bufSize, length, infoLog);
}


void
_mesa_get_shader_info_log(GLcontext *ctx, GLuint shader, GLsizei bufSize,
                          GLsizei *length, GLchar *infoLog)
{
   struct gl_program *shProg = _mesa_lookup_shader(ctx, shader);
   if (!shProg) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
      return;
   }
   /*
   copy_string(shProg->InfoLog, bufSize, length, infoLog);
   */
}


/**
 * Called via ctx->Driver.GetShaderSource().
 */
void
_mesa_get_shader_source(GLcontext *ctx, GLuint shader, GLsizei maxLength,
                        GLsizei *length, GLchar *sourceOut)
{
   struct gl_program *shProg = _mesa_lookup_shader(ctx, shader);
   if (!shProg) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderSource(shader)");
      return;
   }
   copy_string((GLchar *) shProg->String, maxLength, length, sourceOut);
}


/**
 * Called via ctx->Driver.GetUniformfv().
 */
void
_mesa_get_uniformfv(GLcontext *ctx, GLuint program, GLint location,
                    GLfloat *params)
{
   struct gl_linked_program *linked
      = _mesa_lookup_linked_program(ctx, program);
   if (linked) {
      GLuint i;
      if (location >= 0 && location < linked->Uniforms->NumParameters) {
         for (i = 0; i < linked->Uniforms->Parameters[location].Size; i++) {
            params[i] = linked->Uniforms->ParameterValues[location][i];
         }
      }
      else {
         _mesa_error(ctx, GL_INVALID_VALUE, "glGetUniformfv(location)");
      }
   }
   else {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(program)");
   }
}


/**
 * Called via ctx->Driver.GetUniformLocation().
 */
GLint
_mesa_get_uniform_location(GLcontext *ctx, GLuint program, const GLchar *name)
{
   if (ctx->Shader.CurrentProgram) {
      const struct gl_linked_program *linked = ctx->Shader.CurrentProgram;
      GLuint loc;
      for (loc = 0; loc < linked->Uniforms->NumParameters; loc++) {
         const struct gl_program_parameter *u
            = linked->Uniforms->Parameters + loc;
         if (u->Type == PROGRAM_UNIFORM && !strcmp(u->Name, name)) {
            return loc;
         }
      }
   }
   return -1;

}


GLboolean
_mesa_is_program(GLcontext *ctx, GLuint name)
{
   struct gl_linked_program *linked = _mesa_lookup_linked_program(ctx, name);
   return linked ? GL_TRUE : GL_FALSE;
}


GLboolean
_mesa_is_shader(GLcontext *ctx, GLuint name)
{
   struct gl_program *shader = _mesa_lookup_shader(ctx, name);
   return shader ? GL_TRUE : GL_FALSE;
}



/**
 * Called via ctx->Driver.ShaderSource()
 */
void
_mesa_shader_source(GLcontext *ctx, GLuint shader, const GLchar *source)
{
   struct gl_program *shProg = _mesa_lookup_shader(ctx, shader);
   if (!shProg) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSource(shaderObj)");
      return;
   }

   /* free old shader source string and install new one */
   if (shProg->String) {
      _mesa_free(shProg->String);
   }
   shProg->String = (GLubyte *) source;
}


/**
 * Called via ctx->Driver.CompileShader()
 */
void
_mesa_compile_shader(GLcontext *ctx, GLuint shaderObj)
{
   struct gl_program *prog = _mesa_lookup_shader(ctx, shaderObj);
   slang_info_log info_log;
   slang_code_object obj;
   slang_unit_type type;

   if (!prog) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glCompileShader(shaderObj)");
      return;
   }

   slang_info_log_construct(&info_log);
   _slang_code_object_ctr(&obj);

   if (prog->Target == GL_VERTEX_PROGRAM_ARB) {
      type = slang_unit_vertex_shader;
   }
   else {
      assert(prog->Target == GL_FRAGMENT_PROGRAM_ARB);
      type = slang_unit_fragment_shader;
   }

   if (_slang_compile((const char*) prog->String, &obj,
                      type, &info_log, prog)) {
      /*
      prog->CompileStatus = GL_TRUE;
      */
   }
   else {
      /*
        prog->CompileStatus = GL_FALSE;
      */
      _mesa_problem(ctx, "Program did not compile!");
   }
}


/**
 * Called via ctx->Driver.LinkProgram()
 */
void
_mesa_link_program(GLcontext *ctx, GLuint program)
{
   struct gl_linked_program *linked;

   linked = _mesa_lookup_linked_program(ctx, program);
   if (!linked) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glLinkProgram(program)");
      return;
   }

   _slang_link2(ctx, program, linked);
}


/**
 * Called via ctx->Driver.UseProgram()
 */
void
_mesa_use_program(GLcontext *ctx, GLuint program)
{
   /* XXXX need to handle reference counting here! */
   if (program) {
      struct gl_linked_program *linked;
      linked = _mesa_lookup_linked_program(ctx, program);
      if (!linked) {
         _mesa_error(ctx, GL_INVALID_OPERATION,
                     "glUseProgramObjectARB(programObj)");
         return;
      }
      ctx->Shader.CurrentProgram = linked;
   }
   else {
      /* don't use a shader program */
      ctx->Shader.CurrentProgram = NULL;
   }      
}


/**
 * Called via ctx->Driver.Uniform().
 */
void
_mesa_uniform(GLcontext *ctx, GLint location, GLsizei count,
              const GLvoid *values, GLenum type)
{
   if (ctx->Shader.CurrentProgram) {
      struct gl_linked_program *linked = ctx->Shader.CurrentProgram;
      if (location >= 0 && location < linked->Uniforms->NumParameters) {
         GLfloat *v = linked->Uniforms->ParameterValues[location];
         const GLfloat *fValues = (const GLfloat *) values; /* XXX */
         GLint i;
         if (type == GL_FLOAT_VEC4)
            count *= 4;
         else if (type == GL_FLOAT_VEC3)
            count *= 3;
         else
            abort();
         
         for (i = 0; i < count; i++)
            v[i] = fValues[i];
         return;
      }
   }
   else {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");
   }
}


/**
 * Called by ctx->Driver.UniformMatrix().
 */
void
_mesa_uniform_matrix(GLcontext *ctx, GLint cols, GLint rows,
                     GLenum matrixType, GLint location, GLsizei count,
                     GLboolean transpose, const GLfloat *values)
{
   const char *caller = "glUniformMatrix";
   const GLint matElements = rows * cols;

   if (values == NULL) {
      _mesa_error(ctx, GL_INVALID_VALUE, caller);
      return;
   }

   FLUSH_VERTICES(ctx, _NEW_PROGRAM);

   if (transpose) {
      GLfloat *trans, *pt;
      const GLfloat *pv;
      GLint i, j, k;

      trans = (GLfloat *) _mesa_malloc(count * matElements * sizeof(GLfloat));
      if (!trans) {
         _mesa_error(ctx, GL_OUT_OF_MEMORY, caller);
         return;
      }

      pt = trans;
      pv = values;
      for (i = 0; i < count; i++) {
         /* transpose from pv matrix into pt matrix */
         for (j = 0; j < cols; j++) {
            for (k = 0; k < rows; k++) {
               /* XXX verify this */
               pt[j * rows + k] = pv[k * cols + j];
            }
         }
         pt += matElements;
         pv += matElements;
      }

#ifdef OLD
      if (!(**pro).WriteUniform(pro, location, count, trans, matrixType))
         _mesa_error(ctx, GL_INVALID_OPERATION, caller);
#endif
      _mesa_free(trans);
   }
   else {
#ifdef OLD
      if (!(**pro).WriteUniform(pro, location, count, values, matrixType))
         _mesa_error(ctx, GL_INVALID_OPERATION, caller);
#endif
   }
}


void
_mesa_validate_program(GLcontext *ctx, GLuint program)
{
   struct gl_linked_program *linked;
   linked = _mesa_lookup_linked_program(ctx, program);
   if (!linked) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glValidateProgram(program)");
      return;
   }
   /* XXX temporary */
   linked->Validated = GL_TRUE;

   /* From the GL spec:
     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.
   */
}



/**********************************************************************/


/**
 * Create a new GLSL program object.
 */
struct gl_linked_program *
_mesa_new_linked_program(GLcontext *ctx, GLuint name)
{
   struct gl_linked_program *linked;
   linked = CALLOC_STRUCT(gl_linked_program);
   if (linked) {
      linked->Name = name;
   }
   return linked;
}


void
_mesa_free_linked_program_data(GLcontext *ctx,
                               struct gl_linked_program *linked)
{
   if (linked->VertexProgram) {
      if (linked->VertexProgram->Base.Parameters == linked->Uniforms) {
         /* to prevent a double-free in the next call */
         linked->VertexProgram->Base.Parameters = NULL;
      }
      _mesa_delete_program(ctx, &linked->VertexProgram->Base);
      linked->VertexProgram = NULL;
   }

   if (linked->FragmentProgram) {
      if (linked->FragmentProgram->Base.Parameters == linked->Uniforms) {
         /* to prevent a double-free in the next call */
         linked->FragmentProgram->Base.Parameters = NULL;
      }
      _mesa_delete_program(ctx, &linked->FragmentProgram->Base);
      linked->FragmentProgram = NULL;
   }


   if (linked->Uniforms) {
      _mesa_free_parameter_list(linked->Uniforms);
      linked->Uniforms = NULL;
   }

   if (linked->Varying) {
      _mesa_free_parameter_list(linked->Varying);
      linked->Varying = NULL;
   }
}



void
_mesa_delete_linked_program(GLcontext *ctx, struct gl_linked_program *linked)
{
   _mesa_free_linked_program_data(ctx, linked);
   _mesa_free(linked);
}


/**
 * Lookup a GLSL program object.
 */
struct gl_linked_program *
_mesa_lookup_linked_program(GLcontext *ctx, GLuint name)
{
   if (name)
      return (struct gl_linked_program *)
         _mesa_HashLookup(ctx->Shared->ProgramObjects, name);
   else
      return NULL;
}


struct gl_shader *
_mesa_new_shader(GLcontext *ctx, GLuint name, GLenum type)
{
   struct gl_shader *shader;
   assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER);
   shader = CALLOC_STRUCT(gl_shader);
   if (shader) {
      shader->Name = name;
      shader->Type = type;
   }
   return shader;
}


/**
 * Lookup a GLSL shader object.
 */
struct gl_program *
_mesa_lookup_shader(GLcontext *ctx, GLuint name)
{
   if (name)
      return (struct gl_program *)
         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
   else
      return NULL;
}


void
_mesa_init_shader_state(GLcontext * ctx)
{
   ctx->Shader._FragmentShaderPresent = GL_FALSE;
   ctx->Shader._VertexShaderPresent = GL_FALSE;
}