util/gl: Kill shader wrapper functions

This patch kills the wrapper functions defined in piglit-shader.h for GL.
They are rendered obsolete by piglit-dispatch.

A subset of the wrappers are kept for GLES1 and GLES2.

    - All GLES1 wrappers are kept and are renamed to match the core GL
      names.  That is, piglit_$func is renamed to gl$func. As before, the
      wrappers simply raise an assertion failure because GLES1 does not
      suppport shaders.

    - The subset of GLES2 wrappers that raise an assertion, because the
      function is not supported on GLES2,  are also kept and likewise
      renamed.

Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
Reviewed-by: Anuj Phogat <anuj.phogat@gmail.com>

10 files changed, 100 insertions, 100 deletions

diff --git a/tests/shaders/attribute0.c b/tests/shaders/attribute0.c
index e77fabc0..0d50d17b 100644
--- a/tests/shaders/attribute0.c
+++ b/tests/shaders/attribute0.c
@@ -85,11 +85,11 @@ piglit_init(int argc, char **argv)
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_text);
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_BindAttribLocation(prog, 0, "vertex");
-	piglit_LinkProgram(prog);
+	glBindAttribLocation(prog, 0, "vertex");
+	glLinkProgram(prog);
 	piglit_link_check_status(prog);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
 	glClearColor(blue[0], blue[1], blue[2], blue[3]);
 }
diff --git a/tests/shaders/getuniform-01.c b/tests/shaders/getuniform-01.c
index b32a829a..016a6d07 100644
--- a/tests/shaders/getuniform-01.c
+++ b/tests/shaders/getuniform-01.c
@@ -115,9 +115,9 @@ piglit_init(int argc, char **argv)
 
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
-	base_location = piglit_GetUniformLocation(prog, "c");
+	base_location = glGetUniformLocation(prog, "c");
 	if (base_location < 0) {
 		printf("Could not get location of `c'.\n");
 		piglit_report_result(PIGLIT_FAIL);
@@ -131,7 +131,7 @@ piglit_init(int argc, char **argv)
 		name[2] = '0' + i;
 		name[3] = ']';
 		name[4] = '\0';
-		array_location[i] = piglit_GetUniformLocation(prog, name);
+		array_location[i] = glGetUniformLocation(prog, name);
 		if (array_location[i] < 0) {
 			printf("Could not get location of `%s'.\n", name);
 			piglit_report_result(PIGLIT_FAIL);
@@ -154,7 +154,7 @@ piglit_init(int argc, char **argv)
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
-	piglit_Uniform1fv(base_location, 4, uniform_data);
+	glUniform1fv(base_location, 4, uniform_data);
 
 	/* From page 264 of the OpenGL 2.1 spec:
 	 *
@@ -169,7 +169,7 @@ piglit_init(int argc, char **argv)
 		buffer[i].u = 0xdeadbeef;
 	}
 
-	piglit_GetUniformfv(prog, base_location, (GLfloat *) buffer);
+	glGetUniformfv(prog, base_location, (GLfloat *) buffer);
 	validate_buffer(buffer, ARRAY_SIZE(buffer), uniform_data[0]);
 
 	printf("Getting one array element at a time...\n");
@@ -179,7 +179,7 @@ piglit_init(int argc, char **argv)
 			buffer[j].u = 0xdeadbeef;
 		}
 
-		piglit_GetUniformfv(prog, array_location[i],
+		glGetUniformfv(prog, array_location[i],
 				    (GLfloat *) buffer);
 		validate_buffer(buffer, ARRAY_SIZE(buffer), uniform_data[i]);
 	}
diff --git a/tests/shaders/getuniform-02.c b/tests/shaders/getuniform-02.c
index c744f1d0..5d774038 100644
--- a/tests/shaders/getuniform-02.c
+++ b/tests/shaders/getuniform-02.c
@@ -79,9 +79,9 @@ piglit_init(int argc, char **argv)
    vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text);
    prog = piglit_link_simple_program(vs, 0);
 
-   piglit_UseProgram(prog);
+   glUseProgram(prog);
 
-   piglit_GetProgramiv(prog, GL_ACTIVE_UNIFORMS, &numUniforms);
+   glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, &numUniforms);
    if (numUniforms != expectedNum) {
       printf("%s: incorrect number of uniforms (found %d, expected %d)\n",
              TestName, numUniforms, expectedNum);
@@ -96,9 +96,9 @@ piglit_init(int argc, char **argv)
       GLenum type, expectedType;
       GLint loc;
 
-      piglit_GetActiveUniform(prog,
+      glGetActiveUniform(prog,
 				 i, sizeof(name), &len, &size, &type, name);
-      loc = piglit_GetUniformLocation(prog, name);
+      loc = glGetUniformLocation(prog, name);
 
       if (loc < 0) {
          printf("%s: bad uniform location for %s: %d\n", TestName, name, loc);
@@ -133,47 +133,47 @@ piglit_init(int argc, char **argv)
 
    /* Check setting/getting values */
 
-   loc_f1 = piglit_GetUniformLocation(prog, "f1");
-   loc_f2 = piglit_GetUniformLocation(prog, "f2");
-   loc_sa = piglit_GetUniformLocation(prog, "s.a");
-   loc_sd = piglit_GetUniformLocation(prog, "s.d");
-   loc_v1 = piglit_GetUniformLocation(prog, "v[1]");
+   loc_f1 = glGetUniformLocation(prog, "f1");
+   loc_f2 = glGetUniformLocation(prog, "f2");
+   loc_sa = glGetUniformLocation(prog, "s.a");
+   loc_sd = glGetUniformLocation(prog, "s.d");
+   loc_v1 = glGetUniformLocation(prog, "v[1]");
 
-   piglit_Uniform1f(loc_f1, 5.0);
-   piglit_Uniform1f(loc_f2, 10.0);
-   piglit_Uniform1f(loc_sa, 15.0);
-   piglit_Uniform1f(loc_sd, 20.0);
-   piglit_Uniform4fv(loc_v1, 1, vVals);
+   glUniform1f(loc_f1, 5.0);
+   glUniform1f(loc_f2, 10.0);
+   glUniform1f(loc_sa, 15.0);
+   glUniform1f(loc_sd, 20.0);
+   glUniform4fv(loc_v1, 1, vVals);
 
-   piglit_GetUniformfv(prog, loc_f1, v);
+   glGetUniformfv(prog, loc_f1, v);
    if (v[0] != 5.0) {
       printf("%s: wrong value for f1 (found %f, expected %f)\n",
              TestName, v[0], 5.0);
       piglit_report_result(PIGLIT_FAIL);
    }
 
-   piglit_GetUniformfv(prog, loc_f2, v);
+   glGetUniformfv(prog, loc_f2, v);
    if (v[0] != 10.0) {
       printf("%s: wrong value for f2 (found %f, expected %f)\n",
              TestName, v[0], 10.0);
       piglit_report_result(PIGLIT_FAIL);
    }
 
-   piglit_GetUniformfv(prog, loc_sa, v);
+   glGetUniformfv(prog, loc_sa, v);
    if (v[0] != 15.0) {
       printf("%s: wrong value for s.a (found %f, expected %f)\n",
              TestName, v[0], 15.0);
       piglit_report_result(PIGLIT_FAIL);
    }
 
-   piglit_GetUniformfv(prog, loc_sd, v);
+   glGetUniformfv(prog, loc_sd, v);
    if (v[0] != 20.0) {
       printf("%s: wrong value for s.d (found %f, expected %f)\n",
              TestName, v[0], 20.0);
       piglit_report_result(PIGLIT_FAIL);
    }
 
-   piglit_GetUniformfv(prog, loc_v1, v);
+   glGetUniformfv(prog, loc_v1, v);
    if (v[0] != 30.0 ||
        v[1] != 31.0 ||
        v[2] != 32.0 ||
diff --git a/tests/shaders/glsl-bindattriblocation.c b/tests/shaders/glsl-bindattriblocation.c
index fd02e8db..c2101302 100644
--- a/tests/shaders/glsl-bindattriblocation.c
+++ b/tests/shaders/glsl-bindattriblocation.c
@@ -86,7 +86,7 @@ piglit_display(void)
 
 	/* Bind "attrib" to location 3 and re-link */
 	glBindAttribLocation(prog, 3, "attrib");
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 
 	/* check that the bind worked */
 	attrib_loc = glGetAttribLocation(prog, "attrib");
@@ -100,7 +100,7 @@ piglit_display(void)
 	}
 
 	/* now draw something and check that it works */
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
diff --git a/tests/shaders/glsl-bug-22603.c b/tests/shaders/glsl-bug-22603.c
index b36f4483..9a686100 100644
--- a/tests/shaders/glsl-bug-22603.c
+++ b/tests/shaders/glsl-bug-22603.c
@@ -98,10 +98,10 @@ piglit_display(void)
 
 	glViewport(0, 0, 512, 512);
 	glClear(GL_DEPTH_BUFFER_BIT);
-	piglit_UseProgram(shadow_prog);
-	piglit_Uniform1i(shadowMap_location, 0);
+	glUseProgram(shadow_prog);
+	glUniform1i(shadowMap_location, 0);
 	/* ogl reads in col-vectors, so transform=true */
-	piglit_UniformMatrix4fv(light_projection_location,
+	glUniformMatrix4fv(light_projection_location,
 			      1, GL_TRUE, matrix);
 	glBegin(GL_QUADS);
 		/* rect1 */
@@ -131,8 +131,8 @@ piglit_display(void)
 	glActiveTextureARB(GL_TEXTURE0_ARB);
 	glBindTexture(GL_TEXTURE_2D, shadow_texture);
 
-	piglit_UseProgram(prog);
-	piglit_UniformMatrix4fv(eye_projection_location, 1, 1, matrix);
+	glUseProgram(prog);
+	glUniformMatrix4fv(eye_projection_location, 1, 1, matrix);
 	/* this is the quad that is texturized with what we want to see */
 	glBegin(GL_QUADS);
 
@@ -210,9 +210,9 @@ piglit_init(int argc, char **argv)
 	shadow_fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_shadow_source);
 	shadow_prog = piglit_link_simple_program(shadow_vs, shadow_fs);
 
-	eye_projection_location = piglit_GetUniformLocation(prog,
+	eye_projection_location = glGetUniformLocation(prog,
 							  "eye_projection");
-	light_projection_location = piglit_GetUniformLocation(shadow_prog,
+	light_projection_location = glGetUniformLocation(shadow_prog,
 							    "light_projection");
-	shadowMap_location = piglit_GetUniformLocation(shadow_prog, "shadowMap");
+	shadowMap_location = glGetUniformLocation(shadow_prog, "shadowMap");
 }
diff --git a/tests/shaders/glsl-fs-color-matrix.c b/tests/shaders/glsl-fs-color-matrix.c
index 312409eb..53f32c0b 100644
--- a/tests/shaders/glsl-fs-color-matrix.c
+++ b/tests/shaders/glsl-fs-color-matrix.c
@@ -137,27 +137,27 @@ piglit_init(int argc, char **argv)
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_text);
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_BindAttribLocation(prog, 0, "vertex");
-	piglit_BindAttribLocation(prog, 1, "textureCoord");
+	glBindAttribLocation(prog, 0, "vertex");
+	glBindAttribLocation(prog, 1, "textureCoord");
 
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	piglit_link_check_status(prog);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
-	loc = piglit_GetUniformLocation(prog, "colorMatrix");
-	piglit_UniformMatrix4fv(loc, 1, GL_FALSE, identity_matrix);
+	loc = glGetUniformLocation(prog, "colorMatrix");
+	glUniformMatrix4fv(loc, 1, GL_FALSE, identity_matrix);
 
-	loc = piglit_GetUniformLocation(prog, "texture");
-	piglit_Uniform1i(loc, 0);
+	loc = glGetUniformLocation(prog, "texture");
+	glUniform1i(loc, 0);
 
 	glClearColor(0.2, 0.2, 0.2, 1.0);
 
-	piglit_VertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE,
+	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE,
 				   2 * sizeof(GLfloat), vertex);
-	piglit_VertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
+	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
 				   2 * sizeof(GLfloat), tex_coord);
 
-	piglit_EnableVertexAttribArray(0);
-	piglit_EnableVertexAttribArray(1);
+	glEnableVertexAttribArray(0);
+	glEnableVertexAttribArray(1);
 }
diff --git a/tests/shaders/glsl-fs-discard-02.c b/tests/shaders/glsl-fs-discard-02.c
index 166285f4..b4afbbac 100644
--- a/tests/shaders/glsl-fs-discard-02.c
+++ b/tests/shaders/glsl-fs-discard-02.c
@@ -74,7 +74,7 @@ static GLuint setup_shaders()
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_code);
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	return prog;
 }
 
@@ -99,7 +99,7 @@ static GLboolean test()
 
 	pass = pass && piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, green);
 
-	piglit_DeleteProgram(prog);
+	glDeleteProgram(prog);
 
 	return pass;
 }
diff --git a/tests/shaders/glsl-getactiveuniform-count.c b/tests/shaders/glsl-getactiveuniform-count.c
index 1ea1646e..6e888e1b 100644
--- a/tests/shaders/glsl-getactiveuniform-count.c
+++ b/tests/shaders/glsl-getactiveuniform-count.c
@@ -72,7 +72,7 @@ piglit_init(int argc, char **argv)
 
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_GetProgramiv(prog, GL_ACTIVE_UNIFORMS, &num);
+	glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, &num);
 	if (num != expect) {
 		printf("Unexpected active uniform count "
 		       "(saw %d, expected %d)\n", num, expect);
diff --git a/tests/shaders/glsl-link-test.c b/tests/shaders/glsl-link-test.c
index dd33391f..6b5c2f9a 100644
--- a/tests/shaders/glsl-link-test.c
+++ b/tests/shaders/glsl-link-test.c
@@ -55,7 +55,7 @@ void piglit_init(int argc, char **argv)
 	piglit_require_gl_version(20);
 
 	piglit_require_GLSL();
-	program = piglit_CreateProgram();
+	program = glCreateProgram();
 
 	for (i = 1; i < argc; i++) {
 		size_t len;
@@ -117,7 +117,7 @@ void piglit_init(int argc, char **argv)
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
-	piglit_LinkProgram(program);
+	glLinkProgram(program);
 
 	result = piglit_link_check_status_quiet(program);
 	if (result != expect)
diff --git a/tests/shaders/shader_runner.c b/tests/shaders/shader_runner.c
index d07ba165..e4752cee 100644
--- a/tests/shaders/shader_runner.c
+++ b/tests/shaders/shader_runner.c
@@ -118,7 +118,7 @@ string_match(const char *string, const char *line)
 void
 compile_glsl(GLenum target, bool release_text)
 {
-	GLuint shader = piglit_CreateShader(target);
+	GLuint shader = glCreateShader(target);
 	GLint ok;
 
 	switch (target) {
@@ -147,28 +147,28 @@ compile_glsl(GLenum target, bool release_text)
 		shader_strings[1] = shader_string;
 		shader_string_sizes[1] = shader_string_size;
 		
-		piglit_ShaderSource(shader, 2,
+		glShaderSource(shader, 2,
 				    (const GLchar **) shader_strings,
 				    shader_string_sizes);
 
 	} else {
-		piglit_ShaderSource(shader, 1,
+		glShaderSource(shader, 1,
 				    (const GLchar **) &shader_string,
 				    &shader_string_size);
 	}
 
-	piglit_CompileShader(shader);
+	glCompileShader(shader);
 
-	piglit_GetShaderiv(shader, GL_COMPILE_STATUS, &ok);
+	glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
 
 	if (!ok) {
 		GLchar *info;
 		GLint size;
 
-		piglit_GetShaderiv(shader, GL_INFO_LOG_LENGTH, &size);
+		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &size);
 		info = malloc(size);
 
-		piglit_GetShaderInfoLog(shader, size, NULL, info);
+		glGetShaderInfoLog(shader, size, NULL, info);
 
 		fprintf(stderr, "Failed to compile %s: %s\n",
 			target == GL_FRAGMENT_SHADER ? "FS" : "VS",
@@ -592,43 +592,43 @@ link_and_use_shaders(void)
 	    && (num_geometry_shaders == 0))
 		return;
 
-	prog = piglit_CreateProgram();
+	prog = glCreateProgram();
 
 	for (i = 0; i < num_vertex_shaders; i++) {
-		piglit_AttachShader(prog, vertex_shaders[i]);
+		glAttachShader(prog, vertex_shaders[i]);
 	}
 
 	for (i = 0; i < num_geometry_shaders; i++) {
-		piglit_AttachShader(prog, geometry_shaders[i]);
+		glAttachShader(prog, geometry_shaders[i]);
 	}
 
 	for (i = 0; i < num_fragment_shaders; i++) {
-		piglit_AttachShader(prog, fragment_shaders[i]);
+		glAttachShader(prog, fragment_shaders[i]);
 	}
 
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 
 	for (i = 0; i < num_vertex_shaders; i++) {
-		piglit_DeleteShader(vertex_shaders[i]);
+		glDeleteShader(vertex_shaders[i]);
 	}
 
 	for (i = 0; i < num_geometry_shaders; i++) {
-		piglit_DeleteShader(geometry_shaders[i]);
+		glDeleteShader(geometry_shaders[i]);
 	}
 
 	for (i = 0; i < num_fragment_shaders; i++) {
-		piglit_DeleteShader(fragment_shaders[i]);
+		glDeleteShader(fragment_shaders[i]);
 	}
 
-	piglit_GetProgramiv(prog, GL_LINK_STATUS, &ok);
+	glGetProgramiv(prog, GL_LINK_STATUS, &ok);
 	if (!ok) {
 		GLchar *info;
 		GLint size;
 
-		piglit_GetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
+		glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
 		info = malloc(size);
 
-		piglit_GetProgramInfoLog(prog, size, NULL, info);
+		glGetProgramInfoLog(prog, size, NULL, info);
 
 		fprintf(stderr, "Failed to link:\n%s\n",
 			info);
@@ -637,7 +637,7 @@ link_and_use_shaders(void)
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
 	err = glGetError();
 	if (err) {
@@ -646,10 +646,10 @@ link_and_use_shaders(void)
 
 		printf("GL error after linking program: 0x%04x\n", err);
 
-		piglit_GetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
+		glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
 		info = malloc(size);
 
-		piglit_GetProgramInfoLog(prog, size, NULL, info);
+		glGetProgramInfoLog(prog, size, NULL, info);
 		fprintf(stderr, "Info log: %s\n", info);
 
 		piglit_report_result(PIGLIT_FAIL);
@@ -1017,7 +1017,7 @@ set_uniform(const char *line)
 	if (set_ubo_uniform(name, type, line))
 		return;
 
-	loc = piglit_GetUniformLocation(prog, name);
+	loc = glGetUniformLocation(prog, name);
 	if (loc < 0) {
 		printf("cannot get location of uniform \"%s\"\n",
 		       name);
@@ -1026,46 +1026,46 @@ set_uniform(const char *line)
 
 	if (string_match("float", type)) {
 		get_floats(line, f, 1);
-		piglit_Uniform1fv(loc, 1, f);
+		glUniform1fv(loc, 1, f);
 		return;
 	} else if (string_match("int", type)) {
 		int val = atoi(line);
-		piglit_Uniform1i(loc, val);
+		glUniform1i(loc, val);
 		return;
 	} else if (string_match("uint", type)) {
 		unsigned val;
 		check_unsigned_support();
 		val = strtoul(line, NULL, 0);
-		piglit_Uniform1ui(loc, val);
+		glUniform1ui(loc, val);
 		return;
 	} else if (string_match("vec", type)) {
 		switch (type[3]) {
 		case '2':
 			get_floats(line, f, 2);
-			piglit_Uniform2fv(loc, 1, f);
+			glUniform2fv(loc, 1, f);
 			return;
 		case '3':
 			get_floats(line, f, 3);
-			piglit_Uniform3fv(loc, 1, f);
+			glUniform3fv(loc, 1, f);
 			return;
 		case '4':
 			get_floats(line, f, 4);
-			piglit_Uniform4fv(loc, 1, f);
+			glUniform4fv(loc, 1, f);
 			return;
 		}
 	} else if (string_match("ivec", type)) {
 		switch (type[4]) {
 		case '2':
 			get_ints(line, ints, 2);
-			piglit_Uniform2iv(loc, 1, ints);
+			glUniform2iv(loc, 1, ints);
 			return;
 		case '3':
 			get_ints(line, ints, 3);
-			piglit_Uniform3iv(loc, 1, ints);
+			glUniform3iv(loc, 1, ints);
 			return;
 		case '4':
 			get_ints(line, ints, 4);
-			piglit_Uniform4iv(loc, 1, ints);
+			glUniform4iv(loc, 1, ints);
 			return;
 		}
 	} else if (string_match("uvec", type)) {
@@ -1073,15 +1073,15 @@ set_uniform(const char *line)
 		switch (type[4]) {
 		case '2':
 			get_uints(line, uints, 2);
-			piglit_Uniform2uiv(loc, 1, uints);
+			glUniform2uiv(loc, 1, uints);
 			return;
 		case '3':
 			get_uints(line, uints, 3);
-			piglit_Uniform3uiv(loc, 1, uints);
+			glUniform3uiv(loc, 1, uints);
 			return;
 		case '4':
 			get_uints(line, uints, 4);
-			piglit_Uniform4uiv(loc, 1, uints);
+			glUniform4uiv(loc, 1, uints);
 			return;
 		}
 	} else if (string_match("mat", type) && type[3] != '\0') {
@@ -1092,45 +1092,45 @@ set_uniform(const char *line)
 			switch (rows) {
 			case '2':
 				get_floats(line, f, 4);
-				piglit_UniformMatrix2fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix2fv(loc, 1, GL_FALSE, f);
 				return;
 			case '3':
 				get_floats(line, f, 6);
-				piglit_UniformMatrix2x3fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix2x3fv(loc, 1, GL_FALSE, f);
 				return;
 			case '4':
 				get_floats(line, f, 8);
-				piglit_UniformMatrix2x4fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix2x4fv(loc, 1, GL_FALSE, f);
 				return;
 			}
 		case '3':
 			switch (rows) {
 			case '2':
 				get_floats(line, f, 6);
-				piglit_UniformMatrix3x2fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix3x2fv(loc, 1, GL_FALSE, f);
 				return;
 			case '3':
 				get_floats(line, f, 9);
-				piglit_UniformMatrix3fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix3fv(loc, 1, GL_FALSE, f);
 				return;
 			case '4':
 				get_floats(line, f, 12);
-				piglit_UniformMatrix3x4fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix3x4fv(loc, 1, GL_FALSE, f);
 				return;
 			}
 		case '4':
 			switch (rows) {
 			case '2':
 				get_floats(line, f, 8);
-				piglit_UniformMatrix4x2fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix4x2fv(loc, 1, GL_FALSE, f);
 				return;
 			case '3':
 				get_floats(line, f, 12);
-				piglit_UniformMatrix4x3fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix4x3fv(loc, 1, GL_FALSE, f);
 				return;
 			case '4':
 				get_floats(line, f, 16);
-				piglit_UniformMatrix4fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix4fv(loc, 1, GL_FALSE, f);
 				return;
 			}
 		}
@@ -1671,8 +1671,8 @@ piglit_display(void)
 
 	if (piglit_automatic) {
 		/* Free our resources, useful for valgrinding. */
-		piglit_DeleteProgram(prog);
-		piglit_UseProgram(0);
+		glDeleteProgram(prog);
+		glUseProgram(0);
 	}
 
 	return pass ? PIGLIT_PASS : PIGLIT_FAIL;