fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-02-21 10:00:36 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Replace the _mesa_*printf() wrappers with the plain libc versions

Browse source
This commit is contained in:
Kristian Høgsberg 2010-02-19 12:32:24 -05:00
parent 32f2fd1c5d
commit 298be2b028
99 changed files with 951 additions and 1032 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/gallium/auxiliary/util/u_gen_mipmap.c
View file

@ -1069,7 +1069,7 @@ reduce_3d(enum pipe_format pformat,
*/
/*
_mesa_printf("mip3d %d x %d x %d -> %d x %d x %d\n",
printf("mip3d %d x %d x %d -> %d x %d x %d\n",
srcWidth, srcHeight, srcDepth, dstWidth, dstHeight, dstDepth);
*/

2
src/gallium/drivers/cell/spu/spu_tri.c
View file

@ -752,7 +752,7 @@ subtriangle(struct edge *eleft, struct edge *eright, unsigned lines)
finish_y -= sy;
/*
_mesa_printf("%s %d %d\n", __FUNCTION__, start_y, finish_y);
printf("%s %d %d\n", __FUNCTION__, start_y, finish_y);
*/
for (y = start_y; y < finish_y; y++) {

8
src/gallium/state_trackers/glx/xlib/glx_api.c
View file

@ -1679,8 +1679,8 @@ PUBLIC const char *
glXQueryServerString( Display *dpy, int screen, int name )
{
static char version[1000];
_mesa_sprintf(version, "%d.%d %s",
SERVER_MAJOR_VERSION, SERVER_MINOR_VERSION, MESA_GLX_VERSION);
sprintf(version, "%d.%d %s",
SERVER_MAJOR_VERSION, SERVER_MINOR_VERSION, MESA_GLX_VERSION);
(void) dpy;
(void) screen;
@ -1704,8 +1704,8 @@ PUBLIC const char *
glXGetClientString( Display *dpy, int name )
{
static char version[1000];
_mesa_sprintf(version, "%d.%d %s", CLIENT_MAJOR_VERSION,
CLIENT_MINOR_VERSION, MESA_GLX_VERSION);
sprintf(version, "%d.%d %s", CLIENT_MAJOR_VERSION,
CLIENT_MINOR_VERSION, MESA_GLX_VERSION);
(void) dpy;

8
src/gallium/state_trackers/glx/xlib/xm_api.c
View file

@ -550,10 +550,10 @@ initialize_visual_and_buffer(XMesaVisual v, XMesaBuffer b,
* reports bugs.
*/
if (_mesa_getenv("MESA_INFO")) {
_mesa_printf("X/Mesa visual = %p\n", (void *) v);
_mesa_printf("X/Mesa level = %d\n", v->mesa_visual.level);
_mesa_printf("X/Mesa depth = %d\n", v->visinfo->depth);
_mesa_printf("X/Mesa bits per pixel = %d\n", v->BitsPerPixel);
printf("X/Mesa visual = %p\n", (void *) v);
printf("X/Mesa level = %d\n", v->mesa_visual.level);
printf("X/Mesa depth = %d\n", v->visinfo->depth);
printf("X/Mesa bits per pixel = %d\n", v->BitsPerPixel);
}
if (b && window) {

6
src/mesa/drivers/common/meta.c
View file

@ -1047,7 +1047,7 @@ init_blit_depth_pixels(GLcontext *ctx)
texTarget = "RECT";
else
texTarget = "2D";
_mesa_snprintf(program2, sizeof(program2), program, texTarget);
snprintf(program2, sizeof(program2), program, texTarget);
_mesa_GenPrograms(1, &blit->DepthFP);
_mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, blit->DepthFP);
@ -1670,7 +1670,7 @@ init_draw_stencil_pixels(GLcontext *ctx)
texTarget = "RECT";
else
texTarget = "2D";
_mesa_snprintf(program2, sizeof(program2), program, texTarget);
snprintf(program2, sizeof(program2), program, texTarget);
_mesa_GenPrograms(1, &drawpix->StencilFP);
_mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
@ -1704,7 +1704,7 @@ init_draw_depth_pixels(GLcontext *ctx)
texTarget = "RECT";
else
texTarget = "2D";
_mesa_snprintf(program2, sizeof(program2), program, texTarget);
snprintf(program2, sizeof(program2), program, texTarget);
_mesa_GenPrograms(1, &drawpix->DepthFP);
_mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);

2
src/mesa/drivers/dri/i915/i915_context.c
View file

@ -108,7 +108,7 @@ i915CreateContext(const __GLcontextModes * mesaVis,
return GL_FALSE;
if (0)
_mesa_printf("\ntexmem-0-3 branch\n\n");
printf("\ntexmem-0-3 branch\n\n");
i915InitVtbl(i915);

178
src/mesa/drivers/dri/i915/i915_debug.c
View file

@ -31,27 +31,25 @@
#include "i915_context.h"
#include "i915_debug.h"
#define PRINTF( ... ) _mesa_printf( __VA_ARGS__ )
static GLboolean debug( struct debug_stream *stream, const char *name, GLuint len )
{
GLuint i;
GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
if (len == 0) {
PRINTF("Error - zero length packet (0x%08x)\n", stream->ptr[0]);
printf("Error - zero length packet (0x%08x)\n", stream->ptr[0]);
assert(0);
return GL_FALSE;
}
if (stream->print_addresses)
PRINTF("%08x: ", stream->offset);
printf("%08x: ", stream->offset);
PRINTF("%s (%d dwords):\n", name, len);
printf("%s (%d dwords):\n", name, len);
for (i = 0; i < len; i++)
PRINTF("\t0x%08x\n", ptr[i]);
PRINTF("\n");
printf("\t0x%08x\n", ptr[i]);
printf("\n");
stream->offset += len * sizeof(GLuint);
@ -88,17 +86,17 @@ static GLboolean debug_prim( struct debug_stream *stream, const char *name,
PRINTF("%s %s (%d dwords):\n", name, prim, len);
PRINTF("\t0x%08x\n", ptr[0]);
printf("%s %s (%d dwords):\n", name, prim, len);
printf("\t0x%08x\n", ptr[0]);
for (i = 1; i < len; i++) {
if (dump_floats)
PRINTF("\t0x%08x // %f\n", ptr[i], *(GLfloat *)&ptr[i]);
printf("\t0x%08x // %f\n", ptr[i], *(GLfloat *)&ptr[i]);
else
PRINTF("\t0x%08x\n", ptr[i]);
printf("\t0x%08x\n", ptr[i]);
}
PRINTF("\n");
printf("\n");
stream->offset += len * sizeof(GLuint);
@ -113,15 +111,15 @@ static GLboolean debug_program( struct debug_stream *stream, const char *name, G
GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
if (len == 0) {
PRINTF("Error - zero length packet (0x%08x)\n", stream->ptr[0]);
printf("Error - zero length packet (0x%08x)\n", stream->ptr[0]);
assert(0);
return GL_FALSE;
}
if (stream->print_addresses)
PRINTF("%08x: ", stream->offset);
printf("%08x: ", stream->offset);
PRINTF("%s (%d dwords):\n", name, len);
printf("%s (%d dwords):\n", name, len);
i915_disassemble_program( ptr, len );
stream->offset += len * sizeof(GLuint);
@ -135,17 +133,17 @@ static GLboolean debug_chain( struct debug_stream *stream, const char *name, GLu
GLuint old_offset = stream->offset + len * sizeof(GLuint);
GLuint i;
PRINTF("%s (%d dwords):\n", name, len);
printf("%s (%d dwords):\n", name, len);
for (i = 0; i < len; i++)
PRINTF("\t0x%08x\n", ptr[i]);
printf("\t0x%08x\n", ptr[i]);
stream->offset = ptr[1] & ~0x3;
if (stream->offset < old_offset)
PRINTF("\n... skipping backwards from 0x%x --> 0x%x ...\n\n",
printf("\n... skipping backwards from 0x%x --> 0x%x ...\n\n",
old_offset, stream->offset );
else
PRINTF("\n... skipping from 0x%x --> 0x%x ...\n\n",
printf("\n... skipping from 0x%x --> 0x%x ...\n\n",
old_offset, stream->offset );
@ -165,10 +163,10 @@ static GLboolean debug_variable_length_prim( struct debug_stream *stream )
len = 1+(i+2)/2;
PRINTF("3DPRIM, %s variable length %d indicies (%d dwords):\n", prim, i, len);
printf("3DPRIM, %s variable length %d indicies (%d dwords):\n", prim, i, len);
for (i = 0; i < len; i++)
PRINTF("\t0x%08x\n", ptr[i]);
PRINTF("\n");
printf("\t0x%08x\n", ptr[i]);
printf("\n");
stream->offset += len * sizeof(GLuint);
return GL_TRUE;
@ -178,9 +176,9 @@ static GLboolean debug_variable_length_prim( struct debug_stream *stream )
#define BITS( dw, hi, lo, ... ) \
do { \
unsigned himask = 0xffffffffU >> (31 - (hi)); \
PRINTF("\t\t "); \
PRINTF(__VA_ARGS__); \
PRINTF(": 0x%x\n", ((dw) & himask) >> (lo)); \
printf("\t\t "); \
printf(__VA_ARGS__); \
printf(": 0x%x\n", ((dw) & himask) >> (lo)); \
} while (0)
#define MBZ( dw, hi, lo) do { \
@ -194,9 +192,9 @@ do { \
#define FLAG( dw, bit, ... ) \
do { \
if (((dw) >> (bit)) & 1) { \
PRINTF("\t\t "); \
PRINTF(__VA_ARGS__); \
PRINTF("\n"); \
printf("\t\t "); \
printf(__VA_ARGS__); \
printf("\n"); \
} \
} while (0)
@ -208,17 +206,17 @@ static GLboolean debug_load_immediate( struct debug_stream *stream,
GLuint bits = (ptr[0] >> 4) & 0xff;
GLuint j = 0;
PRINTF("%s (%d dwords, flags: %x):\n", name, len, bits);
PRINTF("\t0x%08x\n", ptr[j++]);
printf("%s (%d dwords, flags: %x):\n", name, len, bits);
printf("\t0x%08x\n", ptr[j++]);
if (bits & (1<<0)) {
PRINTF("\t LIS0: 0x%08x\n", ptr[j]);
PRINTF("\t vb address: 0x%08x\n", (ptr[j] & ~0x3));
printf("\t LIS0: 0x%08x\n", ptr[j]);
printf("\t vb address: 0x%08x\n", (ptr[j] & ~0x3));
BITS(ptr[j], 0, 0, "vb invalidate disable");
j++;
}
if (bits & (1<<1)) {
PRINTF("\t LIS1: 0x%08x\n", ptr[j]);
printf("\t LIS1: 0x%08x\n", ptr[j]);
BITS(ptr[j], 29, 24, "vb dword width");
BITS(ptr[j], 21, 16, "vb dword pitch");
BITS(ptr[j], 15, 0, "vb max index");
@ -226,7 +224,7 @@ static GLboolean debug_load_immediate( struct debug_stream *stream,
}
if (bits & (1<<2)) {
int i;
PRINTF("\t LIS2: 0x%08x\n", ptr[j]);
printf("\t LIS2: 0x%08x\n", ptr[j]);
for (i = 0; i < 8; i++) {
unsigned tc = (ptr[j] >> (i * 4)) & 0xf;
if (tc != 0xf)
@ -235,11 +233,11 @@ static GLboolean debug_load_immediate( struct debug_stream *stream,
j++;
}
if (bits & (1<<3)) {
PRINTF("\t LIS3: 0x%08x\n", ptr[j]);
printf("\t LIS3: 0x%08x\n", ptr[j]);
j++;
}
if (bits & (1<<4)) {
PRINTF("\t LIS4: 0x%08x\n", ptr[j]);
printf("\t LIS4: 0x%08x\n", ptr[j]);
BITS(ptr[j], 31, 23, "point width");
BITS(ptr[j], 22, 19, "line width");
FLAG(ptr[j], 18, "alpha flatshade");
@ -261,7 +259,7 @@ static GLboolean debug_load_immediate( struct debug_stream *stream,
j++;
}
if (bits & (1<<5)) {
PRINTF("\t LIS5: 0x%08x\n", ptr[j]);
printf("\t LIS5: 0x%08x\n", ptr[j]);
BITS(ptr[j], 31, 28, "rgba write disables");
FLAG(ptr[j], 27, "force dflt point width");
FLAG(ptr[j], 26, "last pixel enable");
@ -279,7 +277,7 @@ static GLboolean debug_load_immediate( struct debug_stream *stream,
j++;
}
if (bits & (1<<6)) {
PRINTF("\t LIS6: 0x%08x\n", ptr[j]);
printf("\t LIS6: 0x%08x\n", ptr[j]);
FLAG(ptr[j], 31, "alpha test enable");
BITS(ptr[j], 30, 28, "alpha func");
BITS(ptr[j], 27, 20, "alpha ref");
@ -296,7 +294,7 @@ static GLboolean debug_load_immediate( struct debug_stream *stream,
}
PRINTF("\n");
printf("\n");
assert(j == len);
@ -315,34 +313,34 @@ static GLboolean debug_load_indirect( struct debug_stream *stream,
GLuint bits = (ptr[0] >> 8) & 0x3f;
GLuint i, j = 0;
PRINTF("%s (%d dwords):\n", name, len);
PRINTF("\t0x%08x\n", ptr[j++]);
printf("%s (%d dwords):\n", name, len);
printf("\t0x%08x\n", ptr[j++]);
for (i = 0; i < 6; i++) {
if (bits & (1<<i)) {
switch (1<<(8+i)) {
case LI0_STATE_STATIC_INDIRECT:
PRINTF(" STATIC: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
PRINTF(" 0x%08x\n", ptr[j++]);
printf(" STATIC: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
printf(" 0x%08x\n", ptr[j++]);
break;
case LI0_STATE_DYNAMIC_INDIRECT:
PRINTF(" DYNAMIC: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
printf(" DYNAMIC: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
break;
case LI0_STATE_SAMPLER:
PRINTF(" SAMPLER: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
PRINTF(" 0x%08x\n", ptr[j++]);
printf(" SAMPLER: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
printf(" 0x%08x\n", ptr[j++]);
break;
case LI0_STATE_MAP:
PRINTF(" MAP: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
PRINTF(" 0x%08x\n", ptr[j++]);
printf(" MAP: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
printf(" 0x%08x\n", ptr[j++]);
break;
case LI0_STATE_PROGRAM:
PRINTF(" PROGRAM: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
PRINTF(" 0x%08x\n", ptr[j++]);
printf(" PROGRAM: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
printf(" 0x%08x\n", ptr[j++]);
break;
case LI0_STATE_CONSTANTS:
PRINTF(" CONSTANTS: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
PRINTF(" 0x%08x\n", ptr[j++]);
printf(" CONSTANTS: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
printf(" 0x%08x\n", ptr[j++]);
break;
default:
assert(0);
@ -352,10 +350,10 @@ static GLboolean debug_load_indirect( struct debug_stream *stream,
}
if (bits == 0) {
PRINTF("\t DUMMY: 0x%08x\n", ptr[j++]);
printf("\t DUMMY: 0x%08x\n", ptr[j++]);
}
PRINTF("\n");
printf("\n");
assert(j == len);
@ -368,7 +366,7 @@ static GLboolean debug_load_indirect( struct debug_stream *stream,
static void BR13( struct debug_stream *stream,
GLuint val )
{
PRINTF("\t0x%08x\n", val);
printf("\t0x%08x\n", val);
FLAG(val, 30, "clipping enable");
BITS(val, 25, 24, "color depth (3==32bpp)");
BITS(val, 23, 16, "raster op");
@ -384,11 +382,11 @@ static void BR2223( struct debug_stream *stream,
BR22.val = val22;
BR23.val = val23;
PRINTF("\t0x%08x\n", val22);
printf("\t0x%08x\n", val22);
BITS(val22, 31, 16, "dest y1");
BITS(val22, 15, 0, "dest x1");
PRINTF("\t0x%08x\n", val23);
printf("\t0x%08x\n", val23);
BITS(val23, 31, 16, "dest y2");
BITS(val23, 15, 0, "dest x2");
@ -400,13 +398,13 @@ static void BR2223( struct debug_stream *stream,
static void BR09( struct debug_stream *stream,
GLuint val )
{
PRINTF("\t0x%08x -- dest address\n", val);
printf("\t0x%08x -- dest address\n", val);
}
static void BR26( struct debug_stream *stream,
GLuint val )
{
PRINTF("\t0x%08x\n", val);
printf("\t0x%08x\n", val);
BITS(val, 31, 16, "src y1");
BITS(val, 15, 0, "src x1");
}
@ -414,20 +412,20 @@ static void BR26( struct debug_stream *stream,
static void BR11( struct debug_stream *stream,
GLuint val )
{
PRINTF("\t0x%08x\n", val);
printf("\t0x%08x\n", val);
BITS(val, 15, 0, "src pitch");
}
static void BR12( struct debug_stream *stream,
GLuint val )
{
PRINTF("\t0x%08x -- src address\n", val);
printf("\t0x%08x -- src address\n", val);
}
static void BR16( struct debug_stream *stream,
GLuint val )
{
PRINTF("\t0x%08x -- color\n", val);
printf("\t0x%08x -- color\n", val);
}
static GLboolean debug_copy_blit( struct debug_stream *stream,
@ -437,8 +435,8 @@ static GLboolean debug_copy_blit( struct debug_stream *stream,
GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
PRINTF("\t0x%08x\n", ptr[j++]);
printf("%s (%d dwords):\n", name, len);
printf("\t0x%08x\n", ptr[j++]);
BR13(stream, ptr[j++]);
BR2223(stream, ptr[j], ptr[j+1]);
@ -460,8 +458,8 @@ static GLboolean debug_color_blit( struct debug_stream *stream,
GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
PRINTF("\t0x%08x\n", ptr[j++]);
printf("%s (%d dwords):\n", name, len);
printf("\t0x%08x\n", ptr[j++]);
BR13(stream, ptr[j++]);
BR2223(stream, ptr[j], ptr[j+1]);
@ -481,8 +479,8 @@ static GLboolean debug_modes4( struct debug_stream *stream,
GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
PRINTF("\t0x%08x\n", ptr[j]);
printf("%s (%d dwords):\n", name, len);
printf("\t0x%08x\n", ptr[j]);
BITS(ptr[j], 21, 18, "logicop func");
FLAG(ptr[j], 17, "stencil test mask modify-enable");
FLAG(ptr[j], 16, "stencil write mask modify-enable");
@ -502,26 +500,26 @@ static GLboolean debug_map_state( struct debug_stream *stream,
GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
PRINTF("\t0x%08x\n", ptr[j++]);
printf("%s (%d dwords):\n", name, len);
printf("\t0x%08x\n", ptr[j++]);
{
PRINTF("\t0x%08x\n", ptr[j]);
printf("\t0x%08x\n", ptr[j]);
BITS(ptr[j], 15, 0, "map mask");
j++;
}
while (j < len) {
{
PRINTF("\t TMn.0: 0x%08x\n", ptr[j]);
PRINTF("\t map address: 0x%08x\n", (ptr[j] & ~0x3));
printf("\t TMn.0: 0x%08x\n", ptr[j]);
printf("\t map address: 0x%08x\n", (ptr[j] & ~0x3));
FLAG(ptr[j], 1, "vertical line stride");
FLAG(ptr[j], 0, "vertical line stride offset");
j++;
}
{
PRINTF("\t TMn.1: 0x%08x\n", ptr[j]);
printf("\t TMn.1: 0x%08x\n", ptr[j]);
BITS(ptr[j], 31, 21, "height");
BITS(ptr[j], 20, 10, "width");
BITS(ptr[j], 9, 7, "surface format");
@ -532,7 +530,7 @@ static GLboolean debug_map_state( struct debug_stream *stream,
j++;
}
{
PRINTF("\t TMn.2: 0x%08x\n", ptr[j]);
printf("\t TMn.2: 0x%08x\n", ptr[j]);
BITS(ptr[j], 31, 21, "dword pitch");
BITS(ptr[j], 20, 15, "cube face enables");
BITS(ptr[j], 14, 9, "max lod");
@ -554,18 +552,18 @@ static GLboolean debug_sampler_state( struct debug_stream *stream,
GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
PRINTF("\t0x%08x\n", ptr[j++]);
printf("%s (%d dwords):\n", name, len);
printf("\t0x%08x\n", ptr[j++]);
{
PRINTF("\t0x%08x\n", ptr[j]);
printf("\t0x%08x\n", ptr[j]);
BITS(ptr[j], 15, 0, "sampler mask");
j++;
}
while (j < len) {
{
PRINTF("\t TSn.0: 0x%08x\n", ptr[j]);
printf("\t TSn.0: 0x%08x\n", ptr[j]);
FLAG(ptr[j], 31, "reverse gamma");
FLAG(ptr[j], 30, "planar to packed");
FLAG(ptr[j], 29, "yuv->rgb");
@ -582,7 +580,7 @@ static GLboolean debug_sampler_state( struct debug_stream *stream,
}
{
PRINTF("\t TSn.1: 0x%08x\n", ptr[j]);
printf("\t TSn.1: 0x%08x\n", ptr[j]);
BITS(ptr[j], 31, 24, "min lod");
MBZ( ptr[j], 23, 18 );
FLAG(ptr[j], 17, "kill pixel enable");
@ -597,7 +595,7 @@ static GLboolean debug_sampler_state( struct debug_stream *stream,
j++;
}
{
PRINTF("\t TSn.2: 0x%08x (default color)\n", ptr[j]);
printf("\t TSn.2: 0x%08x (default color)\n", ptr[j]);
j++;
}
}
@ -614,11 +612,11 @@ static GLboolean debug_dest_vars( struct debug_stream *stream,
GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
PRINTF("\t0x%08x\n", ptr[j++]);
printf("%s (%d dwords):\n", name, len);
printf("\t0x%08x\n", ptr[j++]);
{
PRINTF("\t0x%08x\n", ptr[j]);
printf("\t0x%08x\n", ptr[j]);
FLAG(ptr[j], 31, "early classic ztest");
FLAG(ptr[j], 30, "opengl tex default color");
FLAG(ptr[j], 29, "bypass iz");
@ -649,11 +647,11 @@ static GLboolean debug_buf_info( struct debug_stream *stream,
GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
PRINTF("\t0x%08x\n", ptr[j++]);
printf("%s (%d dwords):\n", name, len);
printf("\t0x%08x\n", ptr[j++]);
{
PRINTF("\t0x%08x\n", ptr[j]);
printf("\t0x%08x\n", ptr[j]);
BITS(ptr[j], 28, 28, "aux buffer id");
BITS(ptr[j], 27, 24, "buffer id (7=depth, 3=back)");
FLAG(ptr[j], 23, "use fence regs");
@ -665,7 +663,7 @@ static GLboolean debug_buf_info( struct debug_stream *stream,
j++;
}
PRINTF("\t0x%08x -- buffer base address\n", ptr[j++]);
printf("\t0x%08x -- buffer base address\n", ptr[j++]);
stream->offset += len * sizeof(GLuint);
assert(j == len);
@ -826,7 +824,7 @@ i915_dump_batchbuffer( GLuint *start,
GLuint bytes = (end - start) * 4;
GLboolean done = GL_FALSE;
PRINTF("\n\nBATCH: (%d)\n", bytes / 4);
printf("\n\nBATCH: (%d)\n", bytes / 4);
stream.offset = 0;
stream.ptr = (char *)start;
@ -843,7 +841,7 @@ i915_dump_batchbuffer( GLuint *start,
stream.offset >= 0);
}
PRINTF("END-BATCH\n\n\n");
printf("END-BATCH\n\n\n");
}

80
src/mesa/drivers/dri/i915/i915_debug_fp.c
View file

@ -31,8 +31,6 @@
#include "i915_debug.h"
#include "main/imports.h"
#define PRINTF( ... ) _mesa_printf( __VA_ARGS__ )
static const char *opcodes[0x20] = {
"NOP",
"ADD",
@ -123,27 +121,27 @@ print_reg_type_nr(GLuint type, GLuint nr)
case REG_TYPE_T:
switch (nr) {
case T_DIFFUSE:
PRINTF("T_DIFFUSE");
printf("T_DIFFUSE");
return;
case T_SPECULAR:
PRINTF("T_SPECULAR");
printf("T_SPECULAR");
return;
case T_FOG_W:
PRINTF("T_FOG_W");
printf("T_FOG_W");
return;
default:
PRINTF("T_TEX%d", nr);
printf("T_TEX%d", nr);
return;
}
case REG_TYPE_OC:
if (nr == 0) {
PRINTF("oC");
printf("oC");
return;
}
break;
case REG_TYPE_OD:
if (nr == 0) {
PRINTF("oD");
printf("oD");
return;
}
break;
@ -151,7 +149,7 @@ print_reg_type_nr(GLuint type, GLuint nr)
break;
}
PRINTF("%s[%d]", regname[type], nr);
printf("%s[%d]", regname[type], nr);
}
#define REG_SWIZZLE_MASK 0x7777
@ -172,33 +170,33 @@ print_reg_neg_swizzle(GLuint reg)
(reg & REG_NEGATE_MASK) == 0)
return;
PRINTF(".");
printf(".");
for (i = 3; i >= 0; i--) {
if (reg & (1 << ((i * 4) + 3)))
PRINTF("-");
printf("-");
switch ((reg >> (i * 4)) & 0x7) {
case 0:
PRINTF("x");
printf("x");
break;
case 1:
PRINTF("y");
printf("y");
break;
case 2:
PRINTF("z");
printf("z");
break;
case 3:
PRINTF("w");
printf("w");
break;
case 4:
PRINTF("0");
printf("0");
break;
case 5:
PRINTF("1");
printf("1");
break;
default:
PRINTF("?");
printf("?");
break;
}
}
@ -223,15 +221,15 @@ print_dest_reg(GLuint dword)
print_reg_type_nr(type, nr);
if ((dword & A0_DEST_CHANNEL_ALL) == A0_DEST_CHANNEL_ALL)
return;
PRINTF(".");
printf(".");
if (dword & A0_DEST_CHANNEL_X)
PRINTF("x");
printf("x");
if (dword & A0_DEST_CHANNEL_Y)
PRINTF("y");
printf("y");
if (dword & A0_DEST_CHANNEL_Z)
PRINTF("z");
printf("z");
if (dword & A0_DEST_CHANNEL_W)
PRINTF("w");
printf("w");
}
@ -246,29 +244,29 @@ print_arith_op(GLuint opcode, const GLuint * program)
if (opcode != A0_NOP) {
print_dest_reg(program[0]);
if (program[0] & A0_DEST_SATURATE)
PRINTF(" = SATURATE ");
printf(" = SATURATE ");
else
PRINTF(" = ");
printf(" = ");
}
PRINTF("%s ", opcodes[opcode]);
printf("%s ", opcodes[opcode]);
print_src_reg(GET_SRC0_REG(program[0], program[1]));
if (args[opcode] == 1) {
PRINTF("\n");
printf("\n");
return;
}
PRINTF(", ");
printf(", ");
print_src_reg(GET_SRC1_REG(program[1], program[2]));
if (args[opcode] == 2) {
PRINTF("\n");
printf("\n");
return;
}
PRINTF(", ");
printf(", ");
print_src_reg(GET_SRC2_REG(program[2]));
PRINTF("\n");
printf("\n");
return;
}
@ -277,24 +275,24 @@ static void
print_tex_op(GLuint opcode, const GLuint * program)
{
print_dest_reg(program[0] | A0_DEST_CHANNEL_ALL);
PRINTF(" = ");
printf(" = ");
PRINTF("%s ", opcodes[opcode]);
printf("%s ", opcodes[opcode]);
PRINTF("S[%d],", program[0] & T0_SAMPLER_NR_MASK);
printf("S[%d],", program[0] & T0_SAMPLER_NR_MASK);
print_reg_type_nr((program[1] >> T1_ADDRESS_REG_TYPE_SHIFT) &
REG_TYPE_MASK,
(program[1] >> T1_ADDRESS_REG_NR_SHIFT) & REG_NR_MASK);
PRINTF("\n");
printf("\n");
}
static void
print_dcl_op(GLuint opcode, const GLuint * program)
{
PRINTF("%s ", opcodes[opcode]);
printf("%s ", opcodes[opcode]);
print_dest_reg(program[0] | A0_DEST_CHANNEL_ALL);
PRINTF("\n");
printf("\n");
}
@ -304,7 +302,7 @@ i915_disassemble_program(const GLuint * program, GLuint sz)
GLuint size = program[0] & 0x1ff;
GLint i;
PRINTF("\t\tBEGIN\n");
printf("\t\tBEGIN\n");
assert(size + 2 == sz);
@ -312,7 +310,7 @@ i915_disassemble_program(const GLuint * program, GLuint sz)
for (i = 1; i < sz; i += 3, program += 3) {
GLuint opcode = program[0] & (0x1f << 24);
PRINTF("\t\t");
printf("\t\t");
if ((GLint) opcode >= A0_NOP && opcode <= A0_SLT)
print_arith_op(opcode >> 24, program);
@ -321,10 +319,10 @@ i915_disassemble_program(const GLuint * program, GLuint sz)
else if (opcode == D0_DCL)
print_dcl_op(opcode >> 24, program);
else
PRINTF("Unknown opcode 0x%x\n", opcode);
printf("Unknown opcode 0x%x\n", opcode);
}
PRINTF("\t\tEND\n\n");
printf("\t\tEND\n\n");
}

4
src/mesa/drivers/dri/i915/i915_tex_layout.c
View file

@ -145,8 +145,8 @@ i915_miptree_layout_cube(struct intel_context *intel,
intel_miptree_set_image_offset(mt, level, face, x, y);
if (d == 0)
_mesa_printf("cube mipmap %d/%d (%d..%d) is 0x0\n",
face, level, mt->first_level, mt->last_level);
printf("cube mipmap %d/%d (%d..%d) is 0x0\n",
face, level, mt->first_level, mt->last_level);
d >>= 1;
x += step_offsets[face][0] * d;

8
src/mesa/drivers/dri/i915/intel_tris.c
View file

@ -66,7 +66,7 @@ intel_flush_inline_primitive(struct intel_context *intel)
assert(intel->prim.primitive != ~0);
/* _mesa_printf("/\n"); */
/* printf("/\n"); */
if (used < 8)
goto do_discard;
@ -93,7 +93,7 @@ static void intel_start_inline(struct intel_context *intel, uint32_t prim)
intel->no_batch_wrap = GL_TRUE;
/*_mesa_printf("%s *", __progname);*/
/*printf("%s *", __progname);*/
/* Emit a slot which will be filled with the inline primitive
* command later.
@ -111,7 +111,7 @@ static void intel_start_inline(struct intel_context *intel, uint32_t prim)
ADVANCE_BATCH();
intel->no_batch_wrap = GL_FALSE;
/* _mesa_printf(">"); */
/* printf(">"); */
}
static void intel_wrap_inline(struct intel_context *intel)
@ -133,7 +133,7 @@ static GLuint *intel_extend_inline(struct intel_context *intel, GLuint dwords)
if (intel_batchbuffer_space(intel->batch) < sz)
intel_wrap_inline(intel);
/* _mesa_printf("."); */
/* printf("."); */
intel->vtbl.assert_not_dirty(intel);

4
src/mesa/drivers/dri/i965/brw_context.c
View file

@ -78,7 +78,7 @@ GLboolean brwCreateContext( const __GLcontextModes *mesaVis,
GLcontext *ctx = &intel->ctx;
if (!brw) {
_mesa_printf("%s: failed to alloc context\n", __FUNCTION__);
printf("%s: failed to alloc context\n", __FUNCTION__);
return GL_FALSE;
}
@ -87,7 +87,7 @@ GLboolean brwCreateContext( const __GLcontextModes *mesaVis,
if (!intelInitContext( intel, mesaVis, driContextPriv,
sharedContextPrivate, &functions )) {
_mesa_printf("%s: failed to init intel context\n", __FUNCTION__);
printf("%s: failed to init intel context\n", __FUNCTION__);
FREE(brw);
return GL_FALSE;
}

26
src/mesa/drivers/dri/i965/brw_curbe.c
View file

@ -114,13 +114,13 @@ static void calculate_curbe_offsets( struct brw_context *brw )
brw->curbe.total_size = reg;
if (0)
_mesa_printf("curbe wm %d+%d clip %d+%d vs %d+%d\n",
brw->curbe.wm_start,
brw->curbe.wm_size,
brw->curbe.clip_start,
brw->curbe.clip_size,
brw->curbe.vs_start,
brw->curbe.vs_size );
printf("curbe wm %d+%d clip %d+%d vs %d+%d\n",
brw->curbe.wm_start,
brw->curbe.wm_size,
brw->curbe.clip_start,
brw->curbe.clip_size,
brw->curbe.vs_start,
brw->curbe.vs_size );
brw->state.dirty.brw |= BRW_NEW_CURBE_OFFSETS;
}
@ -280,13 +280,13 @@ static void prepare_constant_buffer(struct brw_context *brw)
if (0) {
for (i = 0; i < sz*16; i+=4)
_mesa_printf("curbe %d.%d: %f %f %f %f\n", i/8, i&4,
buf[i+0], buf[i+1], buf[i+2], buf[i+3]);
printf("curbe %d.%d: %f %f %f %f\n", i/8, i&4,
buf[i+0], buf[i+1], buf[i+2], buf[i+3]);
_mesa_printf("last_buf %p buf %p sz %d/%d cmp %d\n",
brw->curbe.last_buf, buf,
bufsz, brw->curbe.last_bufsz,
brw->curbe.last_buf ? memcmp(buf, brw->curbe.last_buf, bufsz) : -1);
printf("last_buf %p buf %p sz %d/%d cmp %d\n",
brw->curbe.last_buf, buf,
bufsz, brw->curbe.last_bufsz,
brw->curbe.last_buf ? memcmp(buf, brw->curbe.last_buf, bufsz) : -1);
}
if (brw->curbe.curbe_bo != NULL &&

4
src/mesa/drivers/dri/i965/brw_draw.c
View file

@ -82,7 +82,7 @@ static GLuint brw_set_prim(struct brw_context *brw, GLenum prim)
GLcontext *ctx = &brw->intel.ctx;
if (INTEL_DEBUG & DEBUG_PRIMS)
_mesa_printf("PRIM: %s\n", _mesa_lookup_enum_by_nr(prim));
printf("PRIM: %s\n", _mesa_lookup_enum_by_nr(prim));
/* Slight optimization to avoid the GS program when not needed:
*/
@ -125,7 +125,7 @@ static void brw_emit_prim(struct brw_context *brw,
struct intel_context *intel = &brw->intel;
if (INTEL_DEBUG & DEBUG_PRIMS)
_mesa_printf("PRIM: %s %d %d\n", _mesa_lookup_enum_by_nr(prim->mode),
printf("PRIM: %s %d %d\n", _mesa_lookup_enum_by_nr(prim->mode),
prim->start, prim->count);
prim_packet.header.opcode = CMD_3D_PRIM;

4
src/mesa/drivers/dri/i965/brw_draw_upload.c
View file

@ -169,7 +169,7 @@ static GLuint get_surface_type( GLenum type, GLuint size,
GLenum format, GLboolean normalized )
{
if (INTEL_DEBUG & DEBUG_VERTS)
_mesa_printf("type %s size %d normalized %d\n",
printf("type %s size %d normalized %d\n",
_mesa_lookup_enum_by_nr(type), size, normalized);
if (normalized) {
@ -355,7 +355,7 @@ static void brw_prepare_vertices(struct brw_context *brw)
/* First build an array of pointers to ve's in vb.inputs_read
*/
if (0)
_mesa_printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
/* Accumulate the list of enabled arrays. */
brw->vb.nr_enabled = 0;

14
src/mesa/drivers/dri/i965/brw_eu_debug.c
View file

@ -54,9 +54,9 @@ void brw_print_reg( struct brw_reg hwreg )
"f"
};
_mesa_printf("%s%s",
hwreg.abs ? "abs/" : "",
hwreg.negate ? "-" : "");
printf("%s%s",
hwreg.abs ? "abs/" : "",
hwreg.negate ? "-" : "");
if (hwreg.file == BRW_GENERAL_REGISTER_FILE &&
hwreg.nr % 2 == 0 &&
@ -66,7 +66,7 @@ void brw_print_reg( struct brw_reg hwreg )
hwreg.hstride == BRW_HORIZONTAL_STRIDE_1 &&
hwreg.type == BRW_REGISTER_TYPE_F) {
/* vector register */
_mesa_printf("vec%d", hwreg.nr);
printf("vec%d", hwreg.nr);
}
else if (hwreg.file == BRW_GENERAL_REGISTER_FILE &&
hwreg.vstride == BRW_VERTICAL_STRIDE_0 &&
@ -74,13 +74,13 @@ void brw_print_reg( struct brw_reg hwreg )
hwreg.hstride == BRW_HORIZONTAL_STRIDE_0 &&
hwreg.type == BRW_REGISTER_TYPE_F) {
/* "scalar" register */
_mesa_printf("scl%d.%d", hwreg.nr, hwreg.subnr / 4);
printf("scl%d.%d", hwreg.nr, hwreg.subnr / 4);
}
else if (hwreg.file == BRW_IMMEDIATE_VALUE) {
_mesa_printf("imm %f", hwreg.dw1.f);
printf("imm %f", hwreg.dw1.f);
}
else {
_mesa_printf("%s%d.%d<%d;%d,%d>:%s",
printf("%s%d.%d<%d;%d,%d>:%s",
file[hwreg.file],
hwreg.nr,
hwreg.subnr / type_sz(hwreg.type),

4
src/mesa/drivers/dri/i965/brw_eu_emit.c
View file

@ -1272,7 +1272,7 @@ void brw_SAMPLE(struct brw_compile *p,
GLboolean need_stall = 0;
if (writemask == 0) {
/*_mesa_printf("%s: zero writemask??\n", __FUNCTION__); */
/*printf("%s: zero writemask??\n", __FUNCTION__); */
return;
}
@ -1304,7 +1304,7 @@ void brw_SAMPLE(struct brw_compile *p,
if (newmask != writemask) {
need_stall = 1;
/* _mesa_printf("need stall %x %x\n", newmask , writemask); */
/* printf("need stall %x %x\n", newmask , writemask); */
}
else {
struct brw_reg m1 = brw_message_reg(msg_reg_nr);

10
src/mesa/drivers/dri/i965/brw_state_cache.c
View file

@ -266,7 +266,7 @@ brw_upload_cache_with_auxdata(struct brw_cache *cache,
}
if (INTEL_DEBUG & DEBUG_STATE)
_mesa_printf("upload %s: %d bytes to cache id %d\n",
printf("upload %s: %d bytes to cache id %d\n",
cache->name[cache_id],
data_size, cache_id);
@ -425,7 +425,7 @@ brw_clear_cache(struct brw_context *brw, struct brw_cache *cache)
GLuint i;
if (INTEL_DEBUG & DEBUG_STATE)
_mesa_printf("%s\n", __FUNCTION__);
printf("%s\n", __FUNCTION__);
for (i = 0; i < cache->size; i++) {
for (c = cache->items[i]; c; c = next) {
@ -465,7 +465,7 @@ brw_state_cache_bo_delete(struct brw_cache *cache, dri_bo *bo)
GLuint i;
if (INTEL_DEBUG & DEBUG_STATE)
_mesa_printf("%s\n", __FUNCTION__);
printf("%s\n", __FUNCTION__);
for (i = 0; i < cache->size; i++) {
for (prev = &cache->items[i]; *prev;) {
@ -493,7 +493,7 @@ void
brw_state_cache_check_size(struct brw_context *brw)
{
if (INTEL_DEBUG & DEBUG_STATE)
_mesa_printf("%s (n_items=%d)\n", __FUNCTION__, brw->cache.n_items);
printf("%s (n_items=%d)\n", __FUNCTION__, brw->cache.n_items);
/* un-tuned guess. We've got around 20 state objects for a total of around
* 32k, so 1000 of them is around 1.5MB.
@ -512,7 +512,7 @@ brw_destroy_cache(struct brw_context *brw, struct brw_cache *cache)
GLuint i;
if (INTEL_DEBUG & DEBUG_STATE)
_mesa_printf("%s\n", __FUNCTION__);
printf("%s\n", __FUNCTION__);
brw_clear_cache(brw, cache);
for (i = 0; i < BRW_MAX_CACHE; i++) {

6
src/mesa/drivers/dri/i965/brw_urb.c
View file

@ -186,17 +186,17 @@ static void recalculate_urb_fence( struct brw_context *brw )
* entries and the values for minimum nr of entries
* provided above.
*/
_mesa_printf("couldn't calculate URB layout!\n");
printf("couldn't calculate URB layout!\n");
exit(1);
}
if (INTEL_DEBUG & (DEBUG_URB|DEBUG_FALLBACKS))
_mesa_printf("URB CONSTRAINED\n");
printf("URB CONSTRAINED\n");
}
done:
if (INTEL_DEBUG & DEBUG_URB)
_mesa_printf("URB fence: %d ..VS.. %d ..GS.. %d ..CLP.. %d ..SF.. %d ..CS.. %d\n",
printf("URB fence: %d ..VS.. %d ..GS.. %d ..CLP.. %d ..SF.. %d ..CS.. %d\n",
brw->urb.vs_start,
brw->urb.gs_start,
brw->urb.clip_start,

14
src/mesa/drivers/dri/i965/brw_vs_emit.c
View file

@ -287,9 +287,9 @@ static void brw_vs_alloc_regs( struct brw_vs_compile *c )
c->prog_data.total_grf = reg;
if (INTEL_DEBUG & DEBUG_VS) {
_mesa_printf("%s NumAddrRegs %d\n", __FUNCTION__, c->vp->program.Base.NumAddressRegs);
_mesa_printf("%s NumTemps %d\n", __FUNCTION__, c->vp->program.Base.NumTemporaries);
_mesa_printf("%s reg = %d\n", __FUNCTION__, reg);
printf("%s NumAddrRegs %d\n", __FUNCTION__, c->vp->program.Base.NumAddressRegs);
printf("%s NumTemps %d\n", __FUNCTION__, c->vp->program.Base.NumTemporaries);
printf("%s reg = %d\n", __FUNCTION__, reg);
}
}
@ -1444,9 +1444,9 @@ void brw_vs_emit(struct brw_vs_compile *c )
GLuint file;
if (INTEL_DEBUG & DEBUG_VS) {
_mesa_printf("vs-mesa:\n");
printf("vs-mesa:\n");
_mesa_print_program(&c->vp->program.Base);
_mesa_printf("\n");
printf("\n");
}
brw_set_compression_control(p, BRW_COMPRESSION_NONE);
@ -1796,9 +1796,9 @@ void brw_vs_emit(struct brw_vs_compile *c )
if (INTEL_DEBUG & DEBUG_VS) {
int i;
_mesa_printf("vs-native:\n");
printf("vs-native:\n");
for (i = 0; i < p->nr_insn; i++)
brw_disasm(stderr, &p->store[i]);
_mesa_printf("\n");
printf("\n");
}
}

68
src/mesa/drivers/dri/i965/brw_wm_debug.c
View file

@ -41,21 +41,21 @@ void brw_wm_print_value( struct brw_wm_compile *c,
if (c->state >= PASS2_DONE)
brw_print_reg(value->hw_reg);
else if( value == &c->undef_value )
_mesa_printf("undef");
printf("undef");
else if( value - c->vreg >= 0 &&
value - c->vreg < BRW_WM_MAX_VREG)
_mesa_printf("r%d", value - c->vreg);
printf("r%d", value - c->vreg);
else if (value - c->creg >= 0 &&
value - c->creg < BRW_WM_MAX_PARAM)
_mesa_printf("c%d", value - c->creg);
printf("c%d", value - c->creg);
else if (value - c->payload.input_interp >= 0 &&
value - c->payload.input_interp < FRAG_ATTRIB_MAX)
_mesa_printf("i%d", value - c->payload.input_interp);
printf("i%d", value - c->payload.input_interp);
else if (value - c->payload.depth >= 0 &&
value - c->payload.depth < FRAG_ATTRIB_MAX)
_mesa_printf("d%d", value - c->payload.depth);
printf("d%d", value - c->payload.depth);
else
_mesa_printf("?");
printf("?");
}
void brw_wm_print_ref( struct brw_wm_compile *c,
@ -64,16 +64,16 @@ void brw_wm_print_ref( struct brw_wm_compile *c,
struct brw_reg hw_reg = ref->hw_reg;
if (ref->unspill_reg)
_mesa_printf("UNSPILL(%x)/", ref->value->spill_slot);
printf("UNSPILL(%x)/", ref->value->spill_slot);
if (c->state >= PASS2_DONE)
brw_print_reg(ref->hw_reg);
else {
_mesa_printf("%s", hw_reg.negate ? "-" : "");
_mesa_printf("%s", hw_reg.abs ? "abs/" : "");
printf("%s", hw_reg.negate ? "-" : "");
printf("%s", hw_reg.abs ? "abs/" : "");
brw_wm_print_value(c, ref->value);
if ((hw_reg.nr&1) || hw_reg.subnr) {
_mesa_printf("->%d.%d", (hw_reg.nr&1), hw_reg.subnr);
printf("->%d.%d", (hw_reg.nr&1), hw_reg.subnr);
}
}
}
@ -84,22 +84,22 @@ void brw_wm_print_insn( struct brw_wm_compile *c,
GLuint i, arg;
GLuint nr_args = brw_wm_nr_args(inst->opcode);
_mesa_printf("[");
printf("[");
for (i = 0; i < 4; i++) {
if (inst->dst[i]) {
brw_wm_print_value(c, inst->dst[i]);
if (inst->dst[i]->spill_slot)
_mesa_printf("/SPILL(%x)",inst->dst[i]->spill_slot);
printf("/SPILL(%x)",inst->dst[i]->spill_slot);
}
else
_mesa_printf("#");
printf("#");
if (i < 3)
_mesa_printf(",");
printf(",");
}
_mesa_printf("]");
printf("]");
if (inst->writemask != WRITEMASK_XYZW)
_mesa_printf(".%s%s%s%s",
printf(".%s%s%s%s",
GET_BIT(inst->writemask, 0) ? "x" : "",
GET_BIT(inst->writemask, 1) ? "y" : "",
GET_BIT(inst->writemask, 2) ? "z" : "",
@ -107,58 +107,58 @@ void brw_wm_print_insn( struct brw_wm_compile *c,
switch (inst->opcode) {
case WM_PIXELXY:
_mesa_printf(" = PIXELXY");
printf(" = PIXELXY");
break;
case WM_DELTAXY:
_mesa_printf(" = DELTAXY");
printf(" = DELTAXY");
break;
case WM_PIXELW:
_mesa_printf(" = PIXELW");
printf(" = PIXELW");
break;
case WM_WPOSXY:
_mesa_printf(" = WPOSXY");
printf(" = WPOSXY");
break;
case WM_PINTERP:
_mesa_printf(" = PINTERP");
printf(" = PINTERP");
break;
case WM_LINTERP:
_mesa_printf(" = LINTERP");
printf(" = LINTERP");
break;
case WM_CINTERP:
_mesa_printf(" = CINTERP");
printf(" = CINTERP");
break;
case WM_FB_WRITE:
_mesa_printf(" = FB_WRITE");
printf(" = FB_WRITE");
break;
case WM_FRONTFACING:
_mesa_printf(" = FRONTFACING");
printf(" = FRONTFACING");
break;
default:
_mesa_printf(" = %s", _mesa_opcode_string(inst->opcode));
printf(" = %s", _mesa_opcode_string(inst->opcode));
break;
}
if (inst->saturate)
_mesa_printf("_SAT");
printf("_SAT");
for (arg = 0; arg < nr_args; arg++) {
_mesa_printf(" [");
printf(" [");
for (i = 0; i < 4; i++) {
if (inst->src[arg][i]) {
brw_wm_print_ref(c, inst->src[arg][i]);
}
else
_mesa_printf("%%");
printf("%%");
if (i < 3)
_mesa_printf(",");
printf(",");
else
_mesa_printf("]");
printf("]");
}
}
_mesa_printf("\n");
printf("\n");
}
void brw_wm_print_program( struct brw_wm_compile *c,
@ -166,9 +166,9 @@ void brw_wm_print_program( struct brw_wm_compile *c,
{
GLuint insn;
_mesa_printf("%s:\n", stage);
printf("%s:\n", stage);
for (insn = 0; insn < c->nr_insns; insn++)
brw_wm_print_insn(c, &c->instruction[insn]);
_mesa_printf("\n");
printf("\n");
}

12
src/mesa/drivers/dri/i965/brw_wm_emit.c
View file

@ -1622,10 +1622,10 @@ void brw_wm_emit( struct brw_wm_compile *c )
break;
default:
_mesa_printf("Unsupported opcode %i (%s) in fragment shader\n",
inst->opcode, inst->opcode < MAX_OPCODE ?
_mesa_opcode_string(inst->opcode) :
"unknown");
printf("Unsupported opcode %i (%s) in fragment shader\n",
inst->opcode, inst->opcode < MAX_OPCODE ?
_mesa_opcode_string(inst->opcode) :
"unknown");
}
for (i = 0; i < 4; i++)
@ -1638,9 +1638,9 @@ void brw_wm_emit( struct brw_wm_compile *c )
if (INTEL_DEBUG & DEBUG_WM) {
int i;
_mesa_printf("wm-native:\n");
printf("wm-native:\n");
for (i = 0; i < p->nr_insn; i++)
brw_disasm(stderr, &p->store[i]);
_mesa_printf("\n");
printf("\n");
}
}

14
src/mesa/drivers/dri/i965/brw_wm_fp.c
View file

@ -159,7 +159,7 @@ static struct prog_dst_register get_temp( struct brw_wm_compile *c )
int bit = _mesa_ffs( ~c->fp_temp );
if (!bit) {
_mesa_printf("%s: out of temporaries\n", __FILE__);
printf("%s: out of temporaries\n", __FILE__);
exit(1);
}
@ -1034,7 +1034,7 @@ static void print_insns( const struct prog_instruction *insn,
{
GLuint i;
for (i = 0; i < nr; i++, insn++) {
_mesa_printf("%3d: ", i);
printf("%3d: ", i);
if (insn->Opcode < MAX_OPCODE)
_mesa_print_instruction(insn);
else if (insn->Opcode < MAX_WM_OPCODE) {
@ -1045,7 +1045,7 @@ static void print_insns( const struct prog_instruction *insn,
3);
}
else
_mesa_printf("965 Opcode %d\n", insn->Opcode);
printf("965 Opcode %d\n", insn->Opcode);
}
}
@ -1060,9 +1060,9 @@ void brw_wm_pass_fp( struct brw_wm_compile *c )
GLuint insn;
if (INTEL_DEBUG & DEBUG_WM) {
_mesa_printf("pre-fp:\n");
printf("pre-fp:\n");
_mesa_print_program(&fp->program.Base);
_mesa_printf("\n");
printf("\n");
}
c->pixel_xy = src_undef();
@ -1168,9 +1168,9 @@ void brw_wm_pass_fp( struct brw_wm_compile *c )
}
if (INTEL_DEBUG & DEBUG_WM) {
_mesa_printf("pass_fp:\n");
printf("pass_fp:\n");
print_insns( c->prog_instructions, c->nr_fp_insns );
_mesa_printf("\n");
printf("\n");
}
}

10
src/mesa/drivers/dri/i965/brw_wm_glsl.c
View file

@ -1849,7 +1849,7 @@ static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c)
c->cur_inst = i;
#if 0
_mesa_printf("Inst %d: ", i);
printf("Inst %d: ", i);
_mesa_print_instruction(inst);
#endif
@ -2115,7 +2115,7 @@ static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c)
}
break;
default:
_mesa_printf("unsupported IR in fragment shader %d\n",
printf("unsupported IR in fragment shader %d\n",
inst->Opcode);
}
@ -2127,10 +2127,10 @@ static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c)
post_wm_emit(c);
if (INTEL_DEBUG & DEBUG_WM) {
_mesa_printf("wm-native:\n");
printf("wm-native:\n");
for (i = 0; i < p->nr_insn; i++)
brw_disasm(stderr, &p->store[i]);
_mesa_printf("\n");
printf("\n");
}
}
@ -2141,7 +2141,7 @@ static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c)
void brw_wm_glsl_emit(struct brw_context *brw, struct brw_wm_compile *c)
{
if (INTEL_DEBUG & DEBUG_WM) {
_mesa_printf("brw_wm_glsl_emit:\n");
printf("brw_wm_glsl_emit:\n");
}
/* initial instruction translation/simplification */

4
src/mesa/drivers/dri/i965/brw_wm_pass0.c
View file

@ -105,7 +105,7 @@ static const struct brw_wm_ref *get_param_ref( struct brw_wm_compile *c,
GLuint i = c->prog_data.nr_params++;
if (i >= BRW_WM_MAX_PARAM) {
_mesa_printf("%s: out of params\n", __FUNCTION__);
printf("%s: out of params\n", __FUNCTION__);
c->prog_data.error = 1;
return NULL;
}
@ -154,7 +154,7 @@ static const struct brw_wm_ref *get_const_ref( struct brw_wm_compile *c,
return c->constref[i].ref;
}
else {
_mesa_printf("%s: out of constrefs\n", __FUNCTION__);
printf("%s: out of constrefs\n", __FUNCTION__);
c->prog_data.error = 1;
return NULL;
}

4
src/mesa/drivers/dri/intel/intel_batchbuffer.c
View file

@ -209,8 +209,8 @@ intel_batchbuffer_emit_reloc(struct intel_batchbuffer *batch,
int ret;
if (batch->ptr - batch->map > batch->buf->size)
_mesa_printf ("bad relocation ptr %p map %p offset %d size %d\n",
batch->ptr, batch->map, batch->ptr - batch->map, batch->buf->size);
printf ("bad relocation ptr %p map %p offset %d size %d\n",
batch->ptr, batch->map, batch->ptr - batch->map, batch->buf->size);
ret = dri_bo_emit_reloc(batch->buf, read_domains, write_domain,
delta, batch->ptr - batch->map, buffer);

2
src/mesa/drivers/dri/intel/intel_context.c
View file

@ -592,7 +592,7 @@ intelInitContext(struct intel_context *intel,
if (!_mesa_initialize_context(&intel->ctx, mesaVis, shareCtx,
functions, (void *) intel)) {
_mesa_printf("%s: failed to init mesa context\n", __FUNCTION__);
printf("%s: failed to init mesa context\n", __FUNCTION__);
return GL_FALSE;
}

2
src/mesa/drivers/dri/intel/intel_context.h
View file

@ -345,7 +345,7 @@ extern int INTEL_DEBUG;
#define DBG(...) do { \
if (INTEL_DEBUG & FILE_DEBUG_FLAG) \
_mesa_printf(__VA_ARGS__); \
printf(__VA_ARGS__); \
} while(0)
#define PCI_CHIP_845_G 0x2562

4
src/mesa/drivers/dri/intel/intel_pixel_bitmap.c
View file

@ -123,7 +123,7 @@ static GLuint get_bitmap_rect(GLsizei width, GLsizei height,
GLuint count = 0;
if (INTEL_DEBUG & DEBUG_PIXEL)
_mesa_printf("%s %d,%d %dx%d bitmap %dx%d skip %d src_offset %d mask %d\n",
printf("%s %d,%d %dx%d bitmap %dx%d skip %d src_offset %d mask %d\n",
__FUNCTION__, x,y,w,h,width,height,unpack->SkipPixels, src_offset, mask);
if (invert) {
@ -516,7 +516,7 @@ intelBitmap(GLcontext * ctx,
return;
if (INTEL_DEBUG & DEBUG_PIXEL)
_mesa_printf("%s: fallback to swrast\n", __FUNCTION__);
printf("%s: fallback to swrast\n", __FUNCTION__);
_swrast_Bitmap(ctx, x, y, width, height, unpack, pixels);
}

14
src/mesa/drivers/dri/intel/intel_pixel_read.c
View file

@ -80,7 +80,7 @@ do_blit_readpixels(GLcontext * ctx,
GLint dst_x, dst_y;
if (INTEL_DEBUG & DEBUG_PIXEL)
_mesa_printf("%s\n", __FUNCTION__);
printf("%s\n", __FUNCTION__);
if (!src)
return GL_FALSE;
@ -89,7 +89,7 @@ do_blit_readpixels(GLcontext * ctx,
/* PBO only for now:
*/
if (INTEL_DEBUG & DEBUG_PIXEL)
_mesa_printf("%s - not PBO\n", __FUNCTION__);
printf("%s - not PBO\n", __FUNCTION__);
return GL_FALSE;
}
@ -97,13 +97,13 @@ do_blit_readpixels(GLcontext * ctx,
if (ctx->_ImageTransferState ||
!intel_check_blit_format(src, format, type)) {
if (INTEL_DEBUG & DEBUG_PIXEL)
_mesa_printf("%s - bad format for blit\n", __FUNCTION__);
printf("%s - bad format for blit\n", __FUNCTION__);
return GL_FALSE;
}
if (pack->Alignment != 1 || pack->SwapBytes || pack->LsbFirst) {
if (INTEL_DEBUG & DEBUG_PIXEL)
_mesa_printf("%s: bad packing params\n", __FUNCTION__);
printf("%s: bad packing params\n", __FUNCTION__);
return GL_FALSE;
}
@ -114,7 +114,7 @@ do_blit_readpixels(GLcontext * ctx,
if (pack->Invert) {
if (INTEL_DEBUG & DEBUG_PIXEL)
_mesa_printf("%s: MESA_PACK_INVERT not done yet\n", __FUNCTION__);
printf("%s: MESA_PACK_INVERT not done yet\n", __FUNCTION__);
return GL_FALSE;
}
else {
@ -159,7 +159,7 @@ do_blit_readpixels(GLcontext * ctx,
}
if (INTEL_DEBUG & DEBUG_PIXEL)
_mesa_printf("%s - DONE\n", __FUNCTION__);
printf("%s - DONE\n", __FUNCTION__);
return GL_TRUE;
}
@ -181,7 +181,7 @@ intelReadPixels(GLcontext * ctx,
return;
if (INTEL_DEBUG & DEBUG_PIXEL)
_mesa_printf("%s: fallback to swrast\n", __FUNCTION__);
printf("%s: fallback to swrast\n", __FUNCTION__);
/* Update Mesa state before calling down into _swrast_ReadPixels, as
* the spans code requires the computed buffer states to be up to date,

4
src/mesa/drivers/dri/intel/intel_tex.c
View file

@ -146,7 +146,7 @@ timed_memcpy(void *dest, const void *src, size_t n)
double rate;
if ((((unsigned) src) & 63) || (((unsigned) dest) & 63))
_mesa_printf("Warning - non-aligned texture copy!\n");
printf("Warning - non-aligned texture copy!\n");
t1 = fastrdtsc();
ret = do_memcpy(dest, src, n);
@ -154,7 +154,7 @@ timed_memcpy(void *dest, const void *src, size_t n)
rate = time_diff(t1, t2);
rate /= (double) n;
_mesa_printf("timed_memcpy: %u %u --> %f clocks/byte\n", t1, t2, rate);
printf("timed_memcpy: %u %u --> %f clocks/byte\n", t1, t2, rate);
return ret;
}
#endif /* DO_DEBUG */

2
src/mesa/drivers/dri/nouveau/nouveau_driver.h
View file

@ -70,7 +70,7 @@ struct nouveau_driver {
};
#define nouveau_error(format, ...) \
_mesa_fprintf(stderr, "%s: " format, __func__, ## __VA_ARGS__)
fprintf(stderr, "%s: " format, __func__, ## __VA_ARGS__)
void
nouveau_clear(GLcontext *ctx, GLbitfield buffers);

2
src/mesa/drivers/dri/r300/r300_fragprog_common.c
View file

@ -227,7 +227,7 @@ static void translate_fragment_program(GLcontext *ctx, struct r300_fragment_prog
if (compiler.Base.Debug) {
fflush(stderr);
_mesa_printf("Fragment Program: Initial program:\n");
printf("Fragment Program: Initial program:\n");
_mesa_print_program(&cont->Base.Base);
fflush(stderr);
}

2
src/mesa/drivers/dri/r300/r300_render.c
View file

@ -440,7 +440,7 @@ void r300SwitchFallback(GLcontext *ctx, uint32_t bit, GLboolean mode)
if (mode) {
if ((fallback_warn & bit) == 0) {
if (RADEON_DEBUG & RADEON_FALLBACKS)
_mesa_fprintf(stderr, "WARNING! Falling back to software for %s\n", getFallbackString(bit));
fprintf(stderr, "WARNING! Falling back to software for %s\n", getFallbackString(bit));
fallback_warn |= bit;
}
rmesa->fallback |= bit;

2
src/mesa/drivers/dri/r300/r300_state.c
View file

@ -1970,7 +1970,7 @@ void r300UpdateShaders(r300ContextPtr rmesa)
/* should only happenen once, just after context is created */
/* TODO: shouldn't we fallback to sw here? */
if (!ctx->FragmentProgram._Current) {
_mesa_fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
return;
}

2
src/mesa/drivers/dri/r600/r700_state.c
View file

@ -65,7 +65,7 @@ void r700UpdateShaders(GLcontext * ctx)
/* should only happenen once, just after context is created */
/* TODO: shouldn't we fallback to sw here? */
if (!ctx->FragmentProgram._Current) {
_mesa_fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
return;
}

2
src/mesa/drivers/dri/radeon/radeon_fbo.c
View file

@ -43,7 +43,7 @@
#define FILE_DEBUG_FLAG RADEON_TEXTURE
#define DBG(...) do { \
if (RADEON_DEBUG & FILE_DEBUG_FLAG) \
_mesa_printf(__VA_ARGS__); \
printf(__VA_ARGS__); \
} while(0)
static struct gl_framebuffer *

4
src/mesa/drivers/dri/swrast/swrast_priv.h
View file

@ -43,13 +43,13 @@
#define DEBUG_SPAN 0
#if DEBUG_CORE
#define TRACE _mesa_printf("--> %s\n", __FUNCTION__)
#define TRACE printf("--> %s\n", __FUNCTION__)
#else
#define TRACE
#endif
#if DEBUG_SPAN
#define TRACE_SPAN _mesa_printf("--> %s\n", __FUNCTION__)
#define TRACE_SPAN printf("--> %s\n", __FUNCTION__)
#else
#define TRACE_SPAN
#endif

10
src/mesa/drivers/x11/fakeglx.c
View file

@ -53,7 +53,7 @@
#include "xmesaP.h"
#ifdef __VMS
#define _mesa_sprintf sprintf
#define sprintf sprintf
#endif
/* This indicates the client-side GLX API and GLX encoder version. */
@ -2032,8 +2032,8 @@ static const char *
Fake_glXQueryServerString( Display *dpy, int screen, int name )
{
static char version[1000];
_mesa_sprintf(version, "%d.%d %s",
SERVER_MAJOR_VERSION, SERVER_MINOR_VERSION, MESA_GLX_VERSION);
sprintf(version, "%d.%d %s",
SERVER_MAJOR_VERSION, SERVER_MINOR_VERSION, MESA_GLX_VERSION);
(void) dpy;
(void) screen;
@ -2057,8 +2057,8 @@ static const char *
Fake_glXGetClientString( Display *dpy, int name )
{
static char version[1000];
_mesa_sprintf(version, "%d.%d %s", CLIENT_MAJOR_VERSION,
CLIENT_MINOR_VERSION, MESA_GLX_VERSION);
sprintf(version, "%d.%d %s", CLIENT_MAJOR_VERSION,
CLIENT_MINOR_VERSION, MESA_GLX_VERSION);
(void) dpy;

12
src/mesa/drivers/x11/xm_api.c
View file

@ -1110,12 +1110,12 @@ initialize_visual_and_buffer(XMesaVisual v, XMesaBuffer b,
* reports bugs.
*/
if (_mesa_getenv("MESA_INFO")) {
_mesa_printf("X/Mesa visual = %p\n", (void *) v);
_mesa_printf("X/Mesa dithered pf = %u\n", v->dithered_pf);
_mesa_printf("X/Mesa undithered pf = %u\n", v->undithered_pf);
_mesa_printf("X/Mesa level = %d\n", v->mesa_visual.level);
_mesa_printf("X/Mesa depth = %d\n", GET_VISUAL_DEPTH(v));
_mesa_printf("X/Mesa bits per pixel = %d\n", v->BitsPerPixel);
printf("X/Mesa visual = %p\n", (void *) v);
printf("X/Mesa dithered pf = %u\n", v->dithered_pf);
printf("X/Mesa undithered pf = %u\n", v->undithered_pf);
printf("X/Mesa level = %d\n", v->mesa_visual.level);
printf("X/Mesa depth = %d\n", GET_VISUAL_DEPTH(v));
printf("X/Mesa bits per pixel = %d\n", v->BitsPerPixel);
}
if (b && window) {

92
src/mesa/drivers/x11/xm_tri.c
View file

@ -1330,97 +1330,97 @@
extern void _xmesa_print_triangle_func( swrast_tri_func triFunc );
void _xmesa_print_triangle_func( swrast_tri_func triFunc )
{
_mesa_printf("XMesa tri func = ");
printf("XMesa tri func = ");
if (triFunc ==smooth_TRUECOLOR_z_triangle)
_mesa_printf("smooth_TRUECOLOR_z_triangle\n");
printf("smooth_TRUECOLOR_z_triangle\n");
else if (triFunc ==smooth_8A8B8G8R_z_triangle)
_mesa_printf("smooth_8A8B8G8R_z_triangle\n");
printf("smooth_8A8B8G8R_z_triangle\n");
else if (triFunc ==smooth_8A8R8G8B_z_triangle)
_mesa_printf("smooth_8A8R8G8B_z_triangle\n");
printf("smooth_8A8R8G8B_z_triangle\n");
else if (triFunc ==smooth_8R8G8B_z_triangle)
_mesa_printf("smooth_8R8G8B_z_triangle\n");
printf("smooth_8R8G8B_z_triangle\n");
else if (triFunc ==smooth_8R8G8B24_z_triangle)
_mesa_printf("smooth_8R8G8B24_z_triangle\n");
printf("smooth_8R8G8B24_z_triangle\n");
else if (triFunc ==smooth_TRUEDITHER_z_triangle)
_mesa_printf("smooth_TRUEDITHER_z_triangle\n");
printf("smooth_TRUEDITHER_z_triangle\n");
else if (triFunc ==smooth_5R6G5B_z_triangle)
_mesa_printf("smooth_5R6G5B_z_triangle\n");
printf("smooth_5R6G5B_z_triangle\n");
else if (triFunc ==smooth_DITHER_5R6G5B_z_triangle)
_mesa_printf("smooth_DITHER_5R6G5B_z_triangle\n");
printf("smooth_DITHER_5R6G5B_z_triangle\n");
else if (triFunc ==smooth_HPCR_z_triangle)
_mesa_printf("smooth_HPCR_z_triangle\n");
printf("smooth_HPCR_z_triangle\n");
else if (triFunc ==smooth_DITHER8_z_triangle)
_mesa_printf("smooth_DITHER8_z_triangle\n");
printf("smooth_DITHER8_z_triangle\n");
else if (triFunc ==smooth_LOOKUP8_z_triangle)
_mesa_printf("smooth_LOOKUP8_z_triangle\n");
printf("smooth_LOOKUP8_z_triangle\n");
else if (triFunc ==flat_TRUECOLOR_z_triangle)
_mesa_printf("flat_TRUECOLOR_z_triangle\n");
printf("flat_TRUECOLOR_z_triangle\n");
else if (triFunc ==flat_8A8B8G8R_z_triangle)
_mesa_printf("flat_8A8B8G8R_z_triangle\n");
printf("flat_8A8B8G8R_z_triangle\n");
else if (triFunc ==flat_8A8R8G8B_z_triangle)
_mesa_printf("flat_8A8R8G8B_z_triangle\n");
printf("flat_8A8R8G8B_z_triangle\n");
else if (triFunc ==flat_8R8G8B_z_triangle)
_mesa_printf("flat_8R8G8B_z_triangle\n");
printf("flat_8R8G8B_z_triangle\n");
else if (triFunc ==flat_8R8G8B24_z_triangle)
_mesa_printf("flat_8R8G8B24_z_triangle\n");
printf("flat_8R8G8B24_z_triangle\n");
else if (triFunc ==flat_TRUEDITHER_z_triangle)
_mesa_printf("flat_TRUEDITHER_z_triangle\n");
printf("flat_TRUEDITHER_z_triangle\n");
else if (triFunc ==flat_5R6G5B_z_triangle)
_mesa_printf("flat_5R6G5B_z_triangle\n");
printf("flat_5R6G5B_z_triangle\n");
else if (triFunc ==flat_DITHER_5R6G5B_z_triangle)
_mesa_printf("flat_DITHER_5R6G5B_z_triangle\n");
printf("flat_DITHER_5R6G5B_z_triangle\n");
else if (triFunc ==flat_HPCR_z_triangle)
_mesa_printf("flat_HPCR_z_triangle\n");
printf("flat_HPCR_z_triangle\n");
else if (triFunc ==flat_DITHER8_z_triangle)
_mesa_printf("flat_DITHER8_z_triangle\n");
printf("flat_DITHER8_z_triangle\n");
else if (triFunc ==flat_LOOKUP8_z_triangle)
_mesa_printf("flat_LOOKUP8_z_triangle\n");
printf("flat_LOOKUP8_z_triangle\n");
else if (triFunc ==smooth_TRUECOLOR_triangle)
_mesa_printf("smooth_TRUECOLOR_triangle\n");
printf("smooth_TRUECOLOR_triangle\n");
else if (triFunc ==smooth_8A8B8G8R_triangle)
_mesa_printf("smooth_8A8B8G8R_triangle\n");
printf("smooth_8A8B8G8R_triangle\n");
else if (triFunc ==smooth_8A8R8G8B_triangle)
_mesa_printf("smooth_8A8R8G8B_triangle\n");
printf("smooth_8A8R8G8B_triangle\n");
else if (triFunc ==smooth_8R8G8B_triangle)
_mesa_printf("smooth_8R8G8B_triangle\n");
printf("smooth_8R8G8B_triangle\n");
else if (triFunc ==smooth_8R8G8B24_triangle)
_mesa_printf("smooth_8R8G8B24_triangle\n");
printf("smooth_8R8G8B24_triangle\n");
else if (triFunc ==smooth_TRUEDITHER_triangle)
_mesa_printf("smooth_TRUEDITHER_triangle\n");
printf("smooth_TRUEDITHER_triangle\n");
else if (triFunc ==smooth_5R6G5B_triangle)
_mesa_printf("smooth_5R6G5B_triangle\n");
printf("smooth_5R6G5B_triangle\n");
else if (triFunc ==smooth_DITHER_5R6G5B_triangle)
_mesa_printf("smooth_DITHER_5R6G5B_triangle\n");
printf("smooth_DITHER_5R6G5B_triangle\n");
else if (triFunc ==smooth_HPCR_triangle)
_mesa_printf("smooth_HPCR_triangle\n");
printf("smooth_HPCR_triangle\n");
else if (triFunc ==smooth_DITHER8_triangle)
_mesa_printf("smooth_DITHER8_triangle\n");
printf("smooth_DITHER8_triangle\n");
else if (triFunc ==smooth_LOOKUP8_triangle)
_mesa_printf("smooth_LOOKUP8_triangle\n");
printf("smooth_LOOKUP8_triangle\n");
else if (triFunc ==flat_TRUECOLOR_triangle)
_mesa_printf("flat_TRUECOLOR_triangle\n");
printf("flat_TRUECOLOR_triangle\n");
else if (triFunc ==flat_TRUEDITHER_triangle)
_mesa_printf("flat_TRUEDITHER_triangle\n");
printf("flat_TRUEDITHER_triangle\n");
else if (triFunc ==flat_8A8B8G8R_triangle)
_mesa_printf("flat_8A8B8G8R_triangle\n");
printf("flat_8A8B8G8R_triangle\n");
else if (triFunc ==flat_8A8R8G8B_triangle)
_mesa_printf("flat_8A8R8G8B_triangle\n");
printf("flat_8A8R8G8B_triangle\n");
else if (triFunc ==flat_8R8G8B_triangle)
_mesa_printf("flat_8R8G8B_triangle\n");
printf("flat_8R8G8B_triangle\n");
else if (triFunc ==flat_8R8G8B24_triangle)
_mesa_printf("flat_8R8G8B24_triangle\n");
printf("flat_8R8G8B24_triangle\n");
else if (triFunc ==flat_5R6G5B_triangle)
_mesa_printf("flat_5R6G5B_triangle\n");
printf("flat_5R6G5B_triangle\n");
else if (triFunc ==flat_DITHER_5R6G5B_triangle)
_mesa_printf("flat_DITHER_5R6G5B_triangle\n");
printf("flat_DITHER_5R6G5B_triangle\n");
else if (triFunc ==flat_HPCR_triangle)
_mesa_printf("flat_HPCR_triangle\n");
printf("flat_HPCR_triangle\n");
else if (triFunc ==flat_DITHER8_triangle)
_mesa_printf("flat_DITHER8_triangle\n");
printf("flat_DITHER8_triangle\n");
else if (triFunc ==flat_LOOKUP8_triangle)
_mesa_printf("flat_LOOKUP8_triangle\n");
printf("flat_LOOKUP8_triangle\n");
else
_mesa_printf("???\n");
printf("???\n");
}
#endif

2
src/mesa/glapi/gl_enums.py
View file

@ -105,7 +105,7 @@ const char *_mesa_lookup_enum_by_nr( int nr )
}
else {
/* this is not re-entrant safe, no big deal here */
_mesa_sprintf(token_tmp, "0x%x", nr);
sprintf(token_tmp, "0x%x", nr);
return token_tmp;
}
}

10
src/mesa/main/arrayobj.c
View file

@ -295,11 +295,11 @@ compute_max_element(struct gl_client_array *array)
- (GLsizeiptrARB) array->Ptr + array->StrideB
- array->_ElementSize) / array->StrideB;
if (0)
_mesa_printf("%s Object %u Size %u MaxElement %u\n",
__FUNCTION__,
array->BufferObj->Name,
(GLuint) array->BufferObj->Size,
array->_MaxElement);
printf("%s Object %u Size %u MaxElement %u\n",
__FUNCTION__,
array->BufferObj->Name,
(GLuint) array->BufferObj->Size,
array->_MaxElement);
}
else {
/* user-space array, no idea how big it is */

8
src/mesa/main/bufferobj.c
View file

@ -1155,7 +1155,7 @@ _mesa_BufferDataARB(GLenum target, GLsizeiptrARB size,
bufObj->Written = GL_TRUE;
#ifdef VBO_DEBUG
_mesa_printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n",
printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n",
bufObj->Name, size, data, usage);
#endif
@ -1272,8 +1272,8 @@ _mesa_MapBufferARB(GLenum target, GLenum access)
bufObj->Written = GL_TRUE;
#ifdef VBO_DEBUG
_mesa_printf("glMapBufferARB(%u, sz %ld, access 0x%x)\n",
bufObj->Name, bufObj->Size, access);
printf("glMapBufferARB(%u, sz %ld, access 0x%x)\n",
bufObj->Name, bufObj->Size, access);
if (access == GL_WRITE_ONLY_ARB) {
GLuint i;
GLubyte *b = (GLubyte *) bufObj->Pointer;
@ -1349,7 +1349,7 @@ _mesa_UnmapBufferARB(GLenum target)
}
}
if (unchanged) {
_mesa_printf("glUnmapBufferARB(%u): %u of %ld unchanged, starting at %d\n",
printf("glUnmapBufferARB(%u): %u of %ld unchanged, starting at %d\n",
bufObj->Name, unchanged, bufObj->Size, pos);
}
}

56
src/mesa/main/debug.c
View file

@ -314,9 +314,9 @@ write_texture_image(struct gl_texture_object *texObj,
buffer, texObj, img);
/* make filename */
_mesa_sprintf(s, "/tmp/tex%u.l%u.f%u.ppm", texObj->Name, level, face);
sprintf(s, "/tmp/tex%u.l%u.f%u.ppm", texObj->Name, level, face);
_mesa_printf(" Writing image level %u to %s\n", level, s);
printf(" Writing image level %u to %s\n", level, s);
write_ppm(s, buffer, img->Width, img->Height, 4, 0, 1, 2, GL_FALSE);
ctx->Pack = store; /* restore */
@ -356,9 +356,9 @@ write_renderbuffer_image(const struct gl_renderbuffer *rb)
format, type, &ctx->DefaultPacking, buffer);
/* make filename */
_mesa_sprintf(s, "/tmp/renderbuffer%u.ppm", rb->Name);
sprintf(s, "/tmp/renderbuffer%u.ppm", rb->Name);
_mesa_printf(" Writing renderbuffer image to %s\n", s);
printf(" Writing renderbuffer image to %s\n", s);
write_ppm(s, buffer, rb->Width, rb->Height, 4, 0, 1, 2, GL_TRUE);
free(buffer);
@ -380,17 +380,17 @@ dump_texture(struct gl_texture_object *texObj, GLuint writeImages)
GLboolean written = GL_FALSE;
GLuint i, j;
_mesa_printf("Texture %u\n", texObj->Name);
_mesa_printf(" Target %s\n", tex_target_name(texObj->Target));
printf("Texture %u\n", texObj->Name);
printf(" Target %s\n", tex_target_name(texObj->Target));
for (i = 0; i < MAX_TEXTURE_LEVELS; i++) {
for (j = 0; j < numFaces; j++) {
struct gl_texture_image *texImg = texObj->Image[j][i];
if (texImg) {
_mesa_printf(" Face %u level %u: %d x %d x %d, format %s at %p\n",
j, i,
texImg->Width, texImg->Height, texImg->Depth,
_mesa_get_format_name(texImg->TexFormat),
texImg->Data);
printf(" Face %u level %u: %d x %d x %d, format %s at %p\n",
j, i,
texImg->Width, texImg->Height, texImg->Depth,
_mesa_get_format_name(texImg->TexFormat),
texImg->Data);
if (writeImages == WRITE_ALL ||
(writeImages == WRITE_ONE && !written)) {
write_texture_image(texObj, j, i);
@ -441,9 +441,9 @@ _mesa_dump_textures(GLuint writeImages)
static void
dump_renderbuffer(const struct gl_renderbuffer *rb, GLboolean writeImage)
{
_mesa_printf("Renderbuffer %u: %u x %u IntFormat = %s\n",
rb->Name, rb->Width, rb->Height,
_mesa_lookup_enum_by_nr(rb->InternalFormat));
printf("Renderbuffer %u: %u x %u IntFormat = %s\n",
rb->Name, rb->Width, rb->Height,
_mesa_lookup_enum_by_nr(rb->InternalFormat));
if (writeImage) {
write_renderbuffer_image(rb);
}
@ -489,12 +489,12 @@ _mesa_dump_color_buffer(const char *filename)
_mesa_ReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, buf);
_mesa_printf("ReadBuffer %p 0x%x DrawBuffer %p 0x%x\n",
ctx->ReadBuffer->_ColorReadBuffer,
ctx->ReadBuffer->ColorReadBuffer,
ctx->DrawBuffer->_ColorDrawBuffers[0],
ctx->DrawBuffer->ColorDrawBuffer[0]);
_mesa_printf("Writing %d x %d color buffer to %s\n", w, h, filename);
printf("ReadBuffer %p 0x%x DrawBuffer %p 0x%x\n",
ctx->ReadBuffer->_ColorReadBuffer,
ctx->ReadBuffer->ColorReadBuffer,
ctx->DrawBuffer->_ColorDrawBuffers[0],
ctx->DrawBuffer->ColorDrawBuffer[0]);
printf("Writing %d x %d color buffer to %s\n", w, h, filename);
write_ppm(filename, buf, w, h, 4, 0, 1, 2, GL_TRUE);
_mesa_PopClientAttrib();
@ -529,7 +529,7 @@ _mesa_dump_depth_buffer(const char *filename)
buf2[i*3+2] = (buf[i] >> 8) & 0xff;
}
_mesa_printf("Writing %d x %d depth buffer to %s\n", w, h, filename);
printf("Writing %d x %d depth buffer to %s\n", w, h, filename);
write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE);
_mesa_PopClientAttrib();
@ -564,7 +564,7 @@ _mesa_dump_stencil_buffer(const char *filename)
buf2[i*3+2] = (buf[i] - 128) * 2;
}
_mesa_printf("Writing %d x %d stencil buffer to %s\n", w, h, filename);
printf("Writing %d x %d stencil buffer to %s\n", w, h, filename);
write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE);
_mesa_PopClientAttrib();
@ -587,7 +587,7 @@ _mesa_print_texture(GLcontext *ctx, const struct gl_texture_image *img)
const GLubyte *data = (const GLubyte *) img->Data;
if (!data) {
_mesa_printf("No texture data\n");
printf("No texture data\n");
return;
}
@ -619,17 +619,17 @@ _mesa_print_texture(GLcontext *ctx, const struct gl_texture_image *img)
for (i = 0; i < img->Height; i++) {
for (j = 0; j < img->Width; j++) {
if (c==1)
_mesa_printf("%02x ", data[0]);
printf("%02x ", data[0]);
else if (c==2)
_mesa_printf("%02x%02x ", data[0], data[1]);
printf("%02x%02x ", data[0], data[1]);
else if (c==3)
_mesa_printf("%02x%02x%02x ", data[0], data[1], data[2]);
printf("%02x%02x%02x ", data[0], data[1], data[2]);
else if (c==4)
_mesa_printf("%02x%02x%02x%02x ", data[0], data[1], data[2], data[3]);
printf("%02x%02x%02x%02x ", data[0], data[1], data[2], data[3]);
data += (img->RowStride - img->Width) * c;
}
/* XXX use img->ImageStride here */
_mesa_printf("\n");
printf("\n");
}
#endif
}

130
src/mesa/main/dlist.c
View file

@ -7685,7 +7685,7 @@ execute_list(GLcontext *ctx, GLuint list)
default:
{
char msg[1000];
_mesa_sprintf(msg, "Error in execute_list: opcode=%d",
sprintf(msg, "Error in execute_list: opcode=%d",
(int) opcode);
_mesa_problem(ctx, msg);
}
@ -9320,7 +9320,7 @@ print_list(GLcontext *ctx, GLuint list)
GLboolean done;
if (!islist(ctx, list)) {
_mesa_printf("%u is not a display list ID\n", list);
printf("%u is not a display list ID\n", list);
return;
}
@ -9330,7 +9330,7 @@ print_list(GLcontext *ctx, GLuint list)
n = dlist->Head;
_mesa_printf("START-LIST %u, address %p\n", list, (void *) n);
printf("START-LIST %u, address %p\n", list, (void *) n);
done = n ? GL_FALSE : GL_TRUE;
while (!done) {
@ -9342,196 +9342,196 @@ print_list(GLcontext *ctx, GLuint list)
else {
switch (opcode) {
case OPCODE_ACCUM:
_mesa_printf("Accum %s %g\n", enum_string(n[1].e), n[2].f);
printf("Accum %s %g\n", enum_string(n[1].e), n[2].f);
break;
case OPCODE_BITMAP:
_mesa_printf("Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i,
printf("Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i,
n[3].f, n[4].f, n[5].f, n[6].f, (void *) n[7].data);
break;
case OPCODE_CALL_LIST:
_mesa_printf("CallList %d\n", (int) n[1].ui);
printf("CallList %d\n", (int) n[1].ui);
break;
case OPCODE_CALL_LIST_OFFSET:
_mesa_printf("CallList %d + offset %u = %u\n", (int) n[1].ui,
printf("CallList %d + offset %u = %u\n", (int) n[1].ui,
ctx->List.ListBase, ctx->List.ListBase + n[1].ui);
break;
case OPCODE_COLOR_TABLE_PARAMETER_FV:
_mesa_printf("ColorTableParameterfv %s %s %f %f %f %f\n",
printf("ColorTableParameterfv %s %s %f %f %f %f\n",
enum_string(n[1].e), enum_string(n[2].e),
n[3].f, n[4].f, n[5].f, n[6].f);
break;
case OPCODE_COLOR_TABLE_PARAMETER_IV:
_mesa_printf("ColorTableParameteriv %s %s %d %d %d %d\n",
printf("ColorTableParameteriv %s %s %d %d %d %d\n",
enum_string(n[1].e), enum_string(n[2].e),
n[3].i, n[4].i, n[5].i, n[6].i);
break;
case OPCODE_DISABLE:
_mesa_printf("Disable %s\n", enum_string(n[1].e));
printf("Disable %s\n", enum_string(n[1].e));
break;
case OPCODE_ENABLE:
_mesa_printf("Enable %s\n", enum_string(n[1].e));
printf("Enable %s\n", enum_string(n[1].e));
break;
case OPCODE_FRUSTUM:
_mesa_printf("Frustum %g %g %g %g %g %g\n",
printf("Frustum %g %g %g %g %g %g\n",
n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);
break;
case OPCODE_LINE_STIPPLE:
_mesa_printf("LineStipple %d %x\n", n[1].i, (int) n[2].us);
printf("LineStipple %d %x\n", n[1].i, (int) n[2].us);
break;
case OPCODE_LOAD_IDENTITY:
_mesa_printf("LoadIdentity\n");
printf("LoadIdentity\n");
break;
case OPCODE_LOAD_MATRIX:
_mesa_printf("LoadMatrix\n");
_mesa_printf(" %8f %8f %8f %8f\n",
printf("LoadMatrix\n");
printf(" %8f %8f %8f %8f\n",
n[1].f, n[5].f, n[9].f, n[13].f);
_mesa_printf(" %8f %8f %8f %8f\n",
printf(" %8f %8f %8f %8f\n",
n[2].f, n[6].f, n[10].f, n[14].f);
_mesa_printf(" %8f %8f %8f %8f\n",
printf(" %8f %8f %8f %8f\n",
n[3].f, n[7].f, n[11].f, n[15].f);
_mesa_printf(" %8f %8f %8f %8f\n",
printf(" %8f %8f %8f %8f\n",
n[4].f, n[8].f, n[12].f, n[16].f);
break;
case OPCODE_MULT_MATRIX:
_mesa_printf("MultMatrix (or Rotate)\n");
_mesa_printf(" %8f %8f %8f %8f\n",
printf("MultMatrix (or Rotate)\n");
printf(" %8f %8f %8f %8f\n",
n[1].f, n[5].f, n[9].f, n[13].f);
_mesa_printf(" %8f %8f %8f %8f\n",
printf(" %8f %8f %8f %8f\n",
n[2].f, n[6].f, n[10].f, n[14].f);
_mesa_printf(" %8f %8f %8f %8f\n",
printf(" %8f %8f %8f %8f\n",
n[3].f, n[7].f, n[11].f, n[15].f);
_mesa_printf(" %8f %8f %8f %8f\n",
printf(" %8f %8f %8f %8f\n",
n[4].f, n[8].f, n[12].f, n[16].f);
break;
case OPCODE_ORTHO:
_mesa_printf("Ortho %g %g %g %g %g %g\n",
printf("Ortho %g %g %g %g %g %g\n",
n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);
break;
case OPCODE_POP_ATTRIB:
_mesa_printf("PopAttrib\n");
printf("PopAttrib\n");
break;
case OPCODE_POP_MATRIX:
_mesa_printf("PopMatrix\n");
printf("PopMatrix\n");
break;
case OPCODE_POP_NAME:
_mesa_printf("PopName\n");
printf("PopName\n");
break;
case OPCODE_PUSH_ATTRIB:
_mesa_printf("PushAttrib %x\n", n[1].bf);
printf("PushAttrib %x\n", n[1].bf);
break;
case OPCODE_PUSH_MATRIX:
_mesa_printf("PushMatrix\n");
printf("PushMatrix\n");
break;
case OPCODE_PUSH_NAME:
_mesa_printf("PushName %d\n", (int) n[1].ui);
printf("PushName %d\n", (int) n[1].ui);
break;
case OPCODE_RASTER_POS:
_mesa_printf("RasterPos %g %g %g %g\n",
printf("RasterPos %g %g %g %g\n",
n[1].f, n[2].f, n[3].f, n[4].f);
break;
case OPCODE_ROTATE:
_mesa_printf("Rotate %g %g %g %g\n",
printf("Rotate %g %g %g %g\n",
n[1].f, n[2].f, n[3].f, n[4].f);
break;
case OPCODE_SCALE:
_mesa_printf("Scale %g %g %g\n", n[1].f, n[2].f, n[3].f);
printf("Scale %g %g %g\n", n[1].f, n[2].f, n[3].f);
break;
case OPCODE_TRANSLATE:
_mesa_printf("Translate %g %g %g\n", n[1].f, n[2].f, n[3].f);
printf("Translate %g %g %g\n", n[1].f, n[2].f, n[3].f);
break;
case OPCODE_BIND_TEXTURE:
_mesa_printf("BindTexture %s %d\n",
printf("BindTexture %s %d\n",
_mesa_lookup_enum_by_nr(n[1].ui), n[2].ui);
break;
case OPCODE_SHADE_MODEL:
_mesa_printf("ShadeModel %s\n", _mesa_lookup_enum_by_nr(n[1].ui));
printf("ShadeModel %s\n", _mesa_lookup_enum_by_nr(n[1].ui));
break;
case OPCODE_MAP1:
_mesa_printf("Map1 %s %.3f %.3f %d %d\n",
printf("Map1 %s %.3f %.3f %d %d\n",
_mesa_lookup_enum_by_nr(n[1].ui),
n[2].f, n[3].f, n[4].i, n[5].i);
break;
case OPCODE_MAP2:
_mesa_printf("Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n",
printf("Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n",
_mesa_lookup_enum_by_nr(n[1].ui),
n[2].f, n[3].f, n[4].f, n[5].f,
n[6].i, n[7].i, n[8].i, n[9].i);
break;
case OPCODE_MAPGRID1:
_mesa_printf("MapGrid1 %d %.3f %.3f\n", n[1].i, n[2].f, n[3].f);
printf("MapGrid1 %d %.3f %.3f\n", n[1].i, n[2].f, n[3].f);
break;
case OPCODE_MAPGRID2:
_mesa_printf("MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n",
printf("MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n",
n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
break;
case OPCODE_EVALMESH1:
_mesa_printf("EvalMesh1 %d %d\n", n[1].i, n[2].i);
printf("EvalMesh1 %d %d\n", n[1].i, n[2].i);
break;
case OPCODE_EVALMESH2:
_mesa_printf("EvalMesh2 %d %d %d %d\n",
printf("EvalMesh2 %d %d %d %d\n",
n[1].i, n[2].i, n[3].i, n[4].i);
break;
case OPCODE_ATTR_1F_NV:
_mesa_printf("ATTR_1F_NV attr %d: %f\n", n[1].i, n[2].f);
printf("ATTR_1F_NV attr %d: %f\n", n[1].i, n[2].f);
break;
case OPCODE_ATTR_2F_NV:
_mesa_printf("ATTR_2F_NV attr %d: %f %f\n",
printf("ATTR_2F_NV attr %d: %f %f\n",
n[1].i, n[2].f, n[3].f);
break;
case OPCODE_ATTR_3F_NV:
_mesa_printf("ATTR_3F_NV attr %d: %f %f %f\n",
printf("ATTR_3F_NV attr %d: %f %f %f\n",
n[1].i, n[2].f, n[3].f, n[4].f);
break;
case OPCODE_ATTR_4F_NV:
_mesa_printf("ATTR_4F_NV attr %d: %f %f %f %f\n",
printf("ATTR_4F_NV attr %d: %f %f %f %f\n",
n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);
break;
case OPCODE_ATTR_1F_ARB:
_mesa_printf("ATTR_1F_ARB attr %d: %f\n", n[1].i, n[2].f);
printf("ATTR_1F_ARB attr %d: %f\n", n[1].i, n[2].f);
break;
case OPCODE_ATTR_2F_ARB:
_mesa_printf("ATTR_2F_ARB attr %d: %f %f\n",
printf("ATTR_2F_ARB attr %d: %f %f\n",
n[1].i, n[2].f, n[3].f);
break;
case OPCODE_ATTR_3F_ARB:
_mesa_printf("ATTR_3F_ARB attr %d: %f %f %f\n",
printf("ATTR_3F_ARB attr %d: %f %f %f\n",
n[1].i, n[2].f, n[3].f, n[4].f);
break;
case OPCODE_ATTR_4F_ARB:
_mesa_printf("ATTR_4F_ARB attr %d: %f %f %f %f\n",
printf("ATTR_4F_ARB attr %d: %f %f %f %f\n",
n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);
break;
case OPCODE_MATERIAL:
_mesa_printf("MATERIAL %x %x: %f %f %f %f\n",
printf("MATERIAL %x %x: %f %f %f %f\n",
n[1].i, n[2].i, n[3].f, n[4].f, n[5].f, n[6].f);
break;
case OPCODE_BEGIN:
_mesa_printf("BEGIN %x\n", n[1].i);
printf("BEGIN %x\n", n[1].i);
break;
case OPCODE_END:
_mesa_printf("END\n");
printf("END\n");
break;
case OPCODE_RECTF:
_mesa_printf("RECTF %f %f %f %f\n", n[1].f, n[2].f, n[3].f,
printf("RECTF %f %f %f %f\n", n[1].f, n[2].f, n[3].f,
n[4].f);
break;
case OPCODE_EVAL_C1:
_mesa_printf("EVAL_C1 %f\n", n[1].f);
printf("EVAL_C1 %f\n", n[1].f);
break;
case OPCODE_EVAL_C2:
_mesa_printf("EVAL_C2 %f %f\n", n[1].f, n[2].f);
printf("EVAL_C2 %f %f\n", n[1].f, n[2].f);
break;
case OPCODE_EVAL_P1:
_mesa_printf("EVAL_P1 %d\n", n[1].i);
printf("EVAL_P1 %d\n", n[1].i);
break;
case OPCODE_EVAL_P2:
_mesa_printf("EVAL_P2 %d %d\n", n[1].i, n[2].i);
printf("EVAL_P2 %d %d\n", n[1].i, n[2].i);
break;
case OPCODE_PROVOKING_VERTEX:
_mesa_printf("ProvokingVertex %s\n",
printf("ProvokingVertex %s\n",
_mesa_lookup_enum_by_nr(n[1].ui));
break;
@ -9539,26 +9539,26 @@ print_list(GLcontext *ctx, GLuint list)
* meta opcodes/commands
*/
case OPCODE_ERROR:
_mesa_printf("Error: %s %s\n",
printf("Error: %s %s\n",
enum_string(n[1].e), (const char *) n[2].data);
break;
case OPCODE_CONTINUE:
_mesa_printf("DISPLAY-LIST-CONTINUE\n");
printf("DISPLAY-LIST-CONTINUE\n");
n = (Node *) n[1].next;
break;
case OPCODE_END_OF_LIST:
_mesa_printf("END-LIST %u\n", list);
printf("END-LIST %u\n", list);
done = GL_TRUE;
break;
default:
if (opcode < 0 || opcode > OPCODE_END_OF_LIST) {
_mesa_printf
printf
("ERROR IN DISPLAY LIST: opcode = %d, address = %p\n",
opcode, (void *) n);
return;
}
else {
_mesa_printf("command %d, %u operands\n", opcode,
printf("command %d, %u operands\n", opcode,
InstSize[opcode]);
}
}

2
src/mesa/main/enums.c
View file

@ -5216,7 +5216,7 @@ const char *_mesa_lookup_enum_by_nr( int nr )
}
else {
/* this is not re-entrant safe, no big deal here */
_mesa_sprintf(token_tmp, "0x%x", nr);
sprintf(token_tmp, "0x%x", nr);
return token_tmp;
}
}

2
src/mesa/main/execmem.c
View file

@ -106,7 +106,7 @@ _mesa_exec_malloc(GLuint size)
if (block)
addr = exec_mem + block->ofs;
else
_mesa_printf("_mesa_exec_malloc failed\n");
printf("_mesa_exec_malloc failed\n");
bail:
_glthread_UNLOCK_MUTEX(exec_mutex);

50
src/mesa/main/fbobject.c
View file

@ -374,8 +374,8 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format,
}
if (texImage->Width < 1 || texImage->Height < 1) {
att_incomplete("teximage width/height=0");
_mesa_printf("texobj = %u\n", texObj->Name);
_mesa_printf("level = %d\n", att->TextureLevel);
printf("texobj = %u\n", texObj->Name);
printf("level = %d\n", att->TextureLevel);
att->Complete = GL_FALSE;
return;
}
@ -2139,39 +2139,39 @@ _mesa_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
/* Debug code */
if (DEBUG_BLIT) {
_mesa_printf("glBlitFramebuffer(%d, %d, %d, %d, %d, %d, %d, %d,"
" 0x%x, 0x%x)\n",
srcX0, srcY0, srcX1, srcY1,
dstX0, dstY0, dstX1, dstY1,
mask, filter);
printf("glBlitFramebuffer(%d, %d, %d, %d, %d, %d, %d, %d,"
" 0x%x, 0x%x)\n",
srcX0, srcY0, srcX1, srcY1,
dstX0, dstY0, dstX1, dstY1,
mask, filter);
if (colorReadRb) {
const struct gl_renderbuffer_attachment *att;
att = find_attachment(readFb, colorReadRb);
_mesa_printf(" Src FBO %u RB %u (%dx%d) ",
readFb->Name, colorReadRb->Name,
colorReadRb->Width, colorReadRb->Height);
printf(" Src FBO %u RB %u (%dx%d) ",
readFb->Name, colorReadRb->Name,
colorReadRb->Width, colorReadRb->Height);
if (att && att->Texture) {
_mesa_printf("Tex %u tgt 0x%x level %u face %u",
att->Texture->Name,
att->Texture->Target,
att->TextureLevel,
att->CubeMapFace);
printf("Tex %u tgt 0x%x level %u face %u",
att->Texture->Name,
att->Texture->Target,
att->TextureLevel,
att->CubeMapFace);
}
_mesa_printf("\n");
printf("\n");
att = find_attachment(drawFb, colorDrawRb);
_mesa_printf(" Dst FBO %u RB %u (%dx%d) ",
drawFb->Name, colorDrawRb->Name,
colorDrawRb->Width, colorDrawRb->Height);
printf(" Dst FBO %u RB %u (%dx%d) ",
drawFb->Name, colorDrawRb->Name,
colorDrawRb->Width, colorDrawRb->Height);
if (att && att->Texture) {
_mesa_printf("Tex %u tgt 0x%x level %u face %u",
att->Texture->Name,
att->Texture->Target,
att->TextureLevel,
att->CubeMapFace);
printf("Tex %u tgt 0x%x level %u face %u",
att->Texture->Name,
att->Texture->Target,
att->TextureLevel,
att->CubeMapFace);
}
_mesa_printf("\n");
printf("\n");
}
}

8
src/mesa/main/ffvertex_prog.c
View file

@ -536,10 +536,10 @@ static void debug_insn( struct prog_instruction *inst, const char *fn,
if (fn != last_fn) {
last_fn = fn;
_mesa_printf("%s:\n", fn);
printf("%s:\n", fn);
}
_mesa_printf("%d:\t", line);
printf("%d:\t", line);
_mesa_print_instruction(inst);
}
}
@ -1577,7 +1577,7 @@ static void build_tnl_program( struct tnl_program *p )
/* Disassemble:
*/
if (DISASSEM) {
_mesa_printf ("\n");
printf ("\n");
}
}
@ -1647,7 +1647,7 @@ _mesa_get_fixed_func_vertex_program(GLcontext *ctx)
if (!prog) {
/* OK, we'll have to build a new one */
if (0)
_mesa_printf("Build new TNL program\n");
printf("Build new TNL program\n");
prog = (struct gl_vertex_program *)
ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);

67
src/mesa/main/imports.c
View file

@ -827,67 +827,6 @@ _mesa_str_checksum(const char *str)
/*@}*/
/**********************************************************************/
/** \name I/O */
/*@{*/
/** Wrapper around vsprintf() */
int
_mesa_sprintf( char *str, const char *fmt, ... )
{
int r;
va_list args;
va_start( args, fmt );
r = vsprintf( str, fmt, args );
va_end( args );
return r;
}
/** Wrapper around vsnprintf() */
int
_mesa_snprintf( char *str, size_t size, const char *fmt, ... )
{
int r;
va_list args;
va_start( args, fmt );
r = vsnprintf( str, size, fmt, args );
va_end( args );
return r;
}
/** Wrapper around printf(), using vsprintf() for the formatting. */
void
_mesa_printf( const char *fmtString, ... )
{
va_list args;
va_start( args, fmtString );
vfprintf(stderr, fmtString, args);
va_end( args );
}
/** Wrapper around fprintf(), using vsprintf() for the formatting. */
void
_mesa_fprintf( FILE *f, const char *fmtString, ... )
{
char s[MAXSTRING];
va_list args;
va_start( args, fmtString );
vsnprintf(s, MAXSTRING, fmtString, args);
va_end( args );
fprintf(f, "%s", s);
}
/** Wrapper around vsprintf() */
int
_mesa_vsprintf( char *str, const char *fmt, va_list args )
{
return vsprintf( str, fmt, args );
}
/*@}*/
/**********************************************************************/
/** \name Diagnostics */
/*@{*/
@ -927,7 +866,7 @@ output_if_debug(const char *prefixString, const char *outputString,
* visible, so communicate with the debugger instead */
{
char buf[4096];
_mesa_snprintf(buf, sizeof(buf), "%s: %s%s", prefixString, outputString, newline ? "\n" : "");
snprintf(buf, sizeof(buf), "%s: %s%s", prefixString, outputString, newline ? "\n" : "");
OutputDebugStringA(buf);
}
#endif
@ -976,7 +915,7 @@ flush_delayed_errors( GLcontext *ctx )
char s[MAXSTRING];
if (ctx->ErrorDebugCount) {
_mesa_snprintf(s, MAXSTRING, "%d similar %s errors",
snprintf(s, MAXSTRING, "%d similar %s errors",
ctx->ErrorDebugCount,
error_string(ctx->ErrorValue));
@ -1083,7 +1022,7 @@ _mesa_error( GLcontext *ctx, GLenum error, const char *fmtString, ... )
vsnprintf(s, MAXSTRING, fmtString, args);
va_end(args);
_mesa_snprintf(s2, MAXSTRING, "%s in %s", error_string(error), s);
snprintf(s2, MAXSTRING, "%s in %s", error_string(error), s);
output_if_debug("Mesa: User error", s2, GL_TRUE);
ctx->ErrorDebugFmtString = fmtString;

16
src/mesa/main/imports.h
View file

@ -594,22 +594,6 @@ _mesa_strtod( const char *s, char **end );
extern unsigned int
_mesa_str_checksum(const char *str);
extern int
_mesa_sprintf( char *str, const char *fmt, ... );
extern int
_mesa_snprintf( char *str, size_t size, const char *fmt, ... );
extern void
_mesa_printf( const char *fmtString, ... );
extern void
_mesa_fprintf( FILE *f, const char *fmtString, ... );
extern int
_mesa_vsprintf( char *str, const char *fmt, va_list args );
extern void
_mesa_warning( __GLcontext *gc, const char *fmtString, ... );

2
src/mesa/main/mipmap.c
View file

@ -1115,7 +1115,7 @@ make_3d_mipmap(GLenum datatype, GLuint comps, GLint border,
*/
/*
_mesa_printf("mip3d %d x %d x %d -> %d x %d x %d\n",
printf("mip3d %d x %d x %d -> %d x %d x %d\n",
srcWidth, srcHeight, srcDepth, dstWidth, dstHeight, dstDepth);
*/

2
src/mesa/main/shaders.c
View file

@ -489,7 +489,7 @@ _mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
newSource = _mesa_read_shader(filename);
if (newSource) {
_mesa_fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
shaderObj, checksum, filename);
free(source);
source = newSource;

2
src/mesa/main/state.c
View file

@ -682,7 +682,7 @@ _mesa_set_varying_vp_inputs( GLcontext *ctx,
if (ctx->varying_vp_inputs != varying_inputs) {
ctx->varying_vp_inputs = varying_inputs;
ctx->NewState |= _NEW_ARRAY;
/*_mesa_printf("%s %x\n", __FUNCTION__, varying_inputs);*/
/*printf("%s %x\n", __FUNCTION__, varying_inputs);*/
}
}

2
src/mesa/main/texenvprogram.c
View file

@ -1560,7 +1560,7 @@ create_new_program(GLcontext *ctx, struct state_key *key,
if (DISASSEM) {
_mesa_print_program(&p.program->Base);
_mesa_printf("\n");
printf("\n");
}
}

4
src/mesa/main/teximage.c
View file

@ -1307,7 +1307,7 @@ texture_error_check( GLcontext *ctx, GLenum target,
if (type != GL_UNSIGNED_SHORT_8_8_MESA &&
type != GL_UNSIGNED_SHORT_8_8_REV_MESA) {
char message[100];
_mesa_sprintf(message,
sprintf(message,
"glTexImage%d(format/type YCBCR mismatch", dimensions);
_mesa_error(ctx, GL_INVALID_ENUM, message);
return GL_TRUE; /* error */
@ -1323,7 +1323,7 @@ texture_error_check( GLcontext *ctx, GLenum target,
if (border != 0) {
if (!isProxy) {
char message[100];
_mesa_sprintf(message,
sprintf(message,
"glTexImage%d(format=GL_YCBCR_MESA and border=%d)",
dimensions, border);
_mesa_error(ctx, GL_INVALID_VALUE, message);

6
src/mesa/main/texobj.c
View file

@ -383,7 +383,7 @@ _mesa_reference_texobj(struct gl_texture_object **ptr,
static void
incomplete(const struct gl_texture_object *t, const char *why)
{
_mesa_printf("Texture Obj %d incomplete because: %s\n", t->Name, why);
printf("Texture Obj %d incomplete because: %s\n", t->Name, why);
}
#else
#define incomplete(t, why)
@ -416,7 +416,7 @@ _mesa_test_texobj_completeness( const GLcontext *ctx,
*/
if ((baseLevel < 0) || (baseLevel >= MAX_TEXTURE_LEVELS)) {
char s[100];
_mesa_sprintf(s, "base level = %d is invalid", baseLevel);
sprintf(s, "base level = %d is invalid", baseLevel);
incomplete(t, s);
t->_Complete = GL_FALSE;
return;
@ -425,7 +425,7 @@ _mesa_test_texobj_completeness( const GLcontext *ctx,
/* Always need the base level image */
if (!t->Image[0][baseLevel]) {
char s[100];
_mesa_sprintf(s, "Image[baseLevel=%d] == NULL", baseLevel);
sprintf(s, "Image[baseLevel=%d] == NULL", baseLevel);
incomplete(t, s);
t->_Complete = GL_FALSE;
return;

38
src/mesa/main/texstate.c
View file

@ -122,25 +122,25 @@ void
_mesa_print_texunit_state( GLcontext *ctx, GLuint unit )
{
const struct gl_texture_unit *texUnit = ctx->Texture.Unit + unit;
_mesa_printf("Texture Unit %d\n", unit);
_mesa_printf(" GL_TEXTURE_ENV_MODE = %s\n", _mesa_lookup_enum_by_nr(texUnit->EnvMode));
_mesa_printf(" GL_COMBINE_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeRGB));
_mesa_printf(" GL_COMBINE_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeA));
_mesa_printf(" GL_SOURCE0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[0]));
_mesa_printf(" GL_SOURCE1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[1]));
_mesa_printf(" GL_SOURCE2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[2]));
_mesa_printf(" GL_SOURCE0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[0]));
_mesa_printf(" GL_SOURCE1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[1]));
_mesa_printf(" GL_SOURCE2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[2]));
_mesa_printf(" GL_OPERAND0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[0]));
_mesa_printf(" GL_OPERAND1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[1]));
_mesa_printf(" GL_OPERAND2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[2]));
_mesa_printf(" GL_OPERAND0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[0]));
_mesa_printf(" GL_OPERAND1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[1]));
_mesa_printf(" GL_OPERAND2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[2]));
_mesa_printf(" GL_RGB_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftRGB);
_mesa_printf(" GL_ALPHA_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftA);
_mesa_printf(" GL_TEXTURE_ENV_COLOR = (%f, %f, %f, %f)\n", texUnit->EnvColor[0], texUnit->EnvColor[1], texUnit->EnvColor[2], texUnit->EnvColor[3]);
printf("Texture Unit %d\n", unit);
printf(" GL_TEXTURE_ENV_MODE = %s\n", _mesa_lookup_enum_by_nr(texUnit->EnvMode));
printf(" GL_COMBINE_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeRGB));
printf(" GL_COMBINE_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeA));
printf(" GL_SOURCE0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[0]));
printf(" GL_SOURCE1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[1]));
printf(" GL_SOURCE2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[2]));
printf(" GL_SOURCE0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[0]));
printf(" GL_SOURCE1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[1]));
printf(" GL_SOURCE2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[2]));
printf(" GL_OPERAND0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[0]));
printf(" GL_OPERAND1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[1]));
printf(" GL_OPERAND2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[2]));
printf(" GL_OPERAND0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[0]));
printf(" GL_OPERAND1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[1]));
printf(" GL_OPERAND2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[2]));
printf(" GL_RGB_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftRGB);
printf(" GL_ALPHA_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftA);
printf(" GL_TEXTURE_ENV_COLOR = (%f, %f, %f, %f)\n", texUnit->EnvColor[0], texUnit->EnvColor[1], texUnit->EnvColor[2], texUnit->EnvColor[3]);
}

20
src/mesa/main/texstore.c
View file

@ -264,15 +264,15 @@ compute_component_mapping(GLenum inFormat, GLenum outFormat,
map[ONE] = ONE;
#if 0
_mesa_printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
inFormat, _mesa_lookup_enum_by_nr(inFormat),
outFormat, _mesa_lookup_enum_by_nr(outFormat),
map[0],
map[1],
map[2],
map[3],
map[4],
map[5]);
printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
inFormat, _mesa_lookup_enum_by_nr(inFormat),
outFormat, _mesa_lookup_enum_by_nr(outFormat),
map[0],
map[1],
map[2],
map[3],
map[4],
map[5]);
#endif
}
@ -884,7 +884,7 @@ _mesa_swizzle_ubyte_image(GLcontext *ctx,
for (i = 0; i < 4; i++)
map[i] = srctype2ubyte[swap[src2base[base2rgba[rgba2dst[i]]]]];
/* _mesa_printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]); */
/* printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]); */
if (srcComponents == dstComponents &&
srcRowStride == dstRowStride &&

18
src/mesa/main/varray.c
View file

@ -1083,14 +1083,14 @@ static void
print_array(const char *name, GLint index, const struct gl_client_array *array)
{
if (index >= 0)
_mesa_printf(" %s[%d]: ", name, index);
printf(" %s[%d]: ", name, index);
else
_mesa_printf(" %s: ", name);
_mesa_printf("Ptr=%p, Type=0x%x, Size=%d, ElemSize=%u, Stride=%d, Buffer=%u(Size %u), MaxElem=%u\n",
array->Ptr, array->Type, array->Size,
array->_ElementSize, array->StrideB,
array->BufferObj->Name, array->BufferObj->Size,
array->_MaxElement);
printf(" %s: ", name);
printf("Ptr=%p, Type=0x%x, Size=%d, ElemSize=%u, Stride=%d, Buffer=%u(Size %u), MaxElem=%u\n",
array->Ptr, array->Type, array->Size,
array->_ElementSize, array->StrideB,
array->BufferObj->Name, array->BufferObj->Size,
array->_MaxElement);
}
@ -1105,7 +1105,7 @@ _mesa_print_arrays(GLcontext *ctx)
_mesa_update_array_object_max_element(ctx, arrayObj);
_mesa_printf("Array Object %u\n", arrayObj->Name);
printf("Array Object %u\n", arrayObj->Name);
if (arrayObj->Vertex.Enabled)
print_array("Vertex", -1, &arrayObj->Vertex);
if (arrayObj->Normal.Enabled)
@ -1118,7 +1118,7 @@ _mesa_print_arrays(GLcontext *ctx)
for (i = 0; i < Elements(arrayObj->VertexAttrib); i++)
if (arrayObj->VertexAttrib[i].Enabled)
print_array("Attrib", i, &arrayObj->VertexAttrib[i]);
_mesa_printf(" _MaxElement = %u\n", arrayObj->_MaxElement);
printf(" _MaxElement = %u\n", arrayObj->_MaxElement);
}

4
src/mesa/main/version.c
View file

@ -124,7 +124,7 @@ _mesa_compute_version(GLcontext *ctx)
ctx->VersionString = (char *) malloc(max);
if (ctx->VersionString) {
_mesa_snprintf(ctx->VersionString, max, "%u.%u Mesa " MESA_VERSION_STRING,
ctx->VersionMajor, ctx->VersionMinor);
snprintf(ctx->VersionString, max, "%u.%u Mesa " MESA_VERSION_STRING,
ctx->VersionMajor, ctx->VersionMinor);
}
}

44
src/mesa/math/m_debug_clip.c
View file

@ -270,20 +270,20 @@ static int test_cliptest_function( clip_func func, int np,
}
if ( dco != rco ) {
_mesa_printf( "\n-----------------------------\n" );
_mesa_printf( "dco = 0x%02x rco = 0x%02x\n", dco, rco );
printf( "\n-----------------------------\n" );
printf( "dco = 0x%02x rco = 0x%02x\n", dco, rco );
return 0;
}
if ( dca != rca ) {
_mesa_printf( "\n-----------------------------\n" );
_mesa_printf( "dca = 0x%02x rca = 0x%02x\n", dca, rca );
printf( "\n-----------------------------\n" );
printf( "dca = 0x%02x rca = 0x%02x\n", dca, rca );
return 0;
}
for ( i = 0 ; i < TEST_COUNT ; i++ ) {
if ( dm[i] != rm[i] ) {
_mesa_printf( "\n-----------------------------\n" );
_mesa_printf( "(i = %i)\n", i );
_mesa_printf( "dm = 0x%02x rm = 0x%02x\n", dm[i], rm[i] );
printf( "\n-----------------------------\n" );
printf( "(i = %i)\n", i );
printf( "dm = 0x%02x rm = 0x%02x\n", dm[i], rm[i] );
return 0;
}
}
@ -297,19 +297,19 @@ static int test_cliptest_function( clip_func func, int np,
for ( i = 0 ; i < TEST_COUNT ; i++ ) {
for ( j = 0 ; j < 4 ; j++ ) {
if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
_mesa_printf( "\n-----------------------------\n" );
_mesa_printf( "(i = %i, j = %i) dm = 0x%02x rm = 0x%02x\n",
printf( "\n-----------------------------\n" );
printf( "(i = %i, j = %i) dm = 0x%02x rm = 0x%02x\n",
i, j, dm[i], rm[i] );
_mesa_printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][0], r[i][0], r[i][0]-d[i][0],
MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
_mesa_printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][1], r[i][1], r[i][1]-d[i][1],
MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
_mesa_printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][2], r[i][2], r[i][2]-d[i][2],
MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
_mesa_printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][3], r[i][3], r[i][3]-d[i][3],
MAX_PRECISION - significand_match( d[i][3], r[i][3] ) );
return 0;
@ -335,19 +335,19 @@ void _math_test_all_cliptest_functions( char *description )
if ( mesa_profile ) {
if ( !counter_overhead ) {
INIT_COUNTER();
_mesa_printf( "counter overhead: %ld cycles\n\n", counter_overhead );
printf( "counter overhead: %ld cycles\n\n", counter_overhead );
}
_mesa_printf( "cliptest results after hooking in %s functions:\n", description );
printf( "cliptest results after hooking in %s functions:\n", description );
}
#endif
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
_mesa_printf( "\n\t" );
printf( "\n\t" );
for ( psize = 2 ; psize <= 4 ; psize++ ) {
_mesa_printf( " p%d\t", psize );
printf( " p%d\t", psize );
}
_mesa_printf( "\n--------------------------------------------------------\n\t" );
printf( "\n--------------------------------------------------------\n\t" );
}
#endif
@ -358,23 +358,23 @@ void _math_test_all_cliptest_functions( char *description )
if ( test_cliptest_function( func, np, psize, cycles ) == 0 ) {
char buf[100];
_mesa_sprintf( buf, "%s[%d] failed test (%s)",
sprintf( buf, "%s[%d] failed test (%s)",
cnames[np], psize, description );
_mesa_problem( NULL, buf );
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf( " %li\t", benchmark_tab[np][psize-1] );
printf( " %li\t", benchmark_tab[np][psize-1] );
#endif
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf( " | [%s]\n\t", cstrings[np] );
printf( " | [%s]\n\t", cstrings[np] );
#endif
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf( "\n" );
printf( "\n" );
#endif
}

34
src/mesa/math/m_debug_norm.c
View file

@ -294,15 +294,15 @@ static int test_norm_function( normal_func func, int mtype, long *cycles )
for ( i = 0 ; i < TEST_COUNT ; i++ ) {
for ( j = 0 ; j < 3 ; j++ ) {
if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
_mesa_printf( "-----------------------------\n" );
_mesa_printf( "(i = %i, j = %i)\n", i, j );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
printf( "-----------------------------\n" );
printf( "(i = %i, j = %i)\n", i, j );
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d[i][0], r[i][0], r[i][0]/d[i][0],
MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d[i][1], r[i][1], r[i][1]/d[i][1],
MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d[i][2], r[i][2], r[i][2]/d[i][2],
MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
return 0;
@ -310,15 +310,15 @@ static int test_norm_function( normal_func func, int mtype, long *cycles )
if ( norm_normalize_types[mtype] != 0 ) {
if ( significand_match( d2[i][j], r2[i][j] ) < REQUIRED_PRECISION ) {
_mesa_printf( "------------------- precalculated length case ------\n" );
_mesa_printf( "(i = %i, j = %i)\n", i, j );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
printf( "------------------- precalculated length case ------\n" );
printf( "(i = %i, j = %i)\n", i, j );
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d2[i][0], r2[i][0], r2[i][0]/d2[i][0],
MAX_PRECISION - significand_match( d2[i][0], r2[i][0] ) );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d2[i][1], r2[i][1], r2[i][1]/d2[i][1],
MAX_PRECISION - significand_match( d2[i][1], r2[i][1] ) );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d2[i][2], r2[i][2], r2[i][2]/d2[i][2],
MAX_PRECISION - significand_match( d2[i][2], r2[i][2] ) );
return 0;
@ -346,11 +346,11 @@ void _math_test_all_normal_transform_functions( char *description )
if ( mesa_profile ) {
if ( !counter_overhead ) {
INIT_COUNTER();
_mesa_printf( "counter overhead: %ld cycles\n\n", counter_overhead );
printf( "counter overhead: %ld cycles\n\n", counter_overhead );
}
_mesa_printf( "normal transform results after hooking in %s functions:\n",
printf( "normal transform results after hooking in %s functions:\n",
description );
_mesa_printf( "\n-------------------------------------------------------\n" );
printf( "\n-------------------------------------------------------\n" );
}
#endif
@ -360,21 +360,21 @@ void _math_test_all_normal_transform_functions( char *description )
if ( test_norm_function( func, mtype, cycles ) == 0 ) {
char buf[100];
_mesa_sprintf( buf, "_mesa_normal_tab[0][%s] failed test (%s)",
sprintf( buf, "_mesa_normal_tab[0][%s] failed test (%s)",
norm_strings[mtype], description );
_mesa_problem( NULL, buf );
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
_mesa_printf( " %li\t", benchmark_tab[mtype] );
_mesa_printf( " | [%s]\n", norm_strings[mtype] );
printf( " %li\t", benchmark_tab[mtype] );
printf( " | [%s]\n", norm_strings[mtype] );
}
#endif
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
_mesa_printf( "\n" );
printf( "\n" );
}
#endif
}

32
src/mesa/math/m_debug_xform.c
View file

@ -254,18 +254,18 @@ static int test_transform_function( transform_func func, int psize,
for ( i = 0 ; i < TEST_COUNT ; i++ ) {
for ( j = 0 ; j < 4 ; j++ ) {
if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
_mesa_printf("-----------------------------\n" );
_mesa_printf("(i = %i, j = %i)\n", i, j );
_mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n",
printf("-----------------------------\n" );
printf("(i = %i, j = %i)\n", i, j );
printf("%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][0], r[i][0], r[i][0]-d[i][0],
MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
_mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n",
printf("%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][1], r[i][1], r[i][1]-d[i][1],
MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
_mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n",
printf("%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][2], r[i][2], r[i][2]-d[i][2],
MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
_mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n",
printf("%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][3], r[i][3], r[i][3]-d[i][3],
MAX_PRECISION - significand_match( d[i][3], r[i][3] ) );
return 0;
@ -292,19 +292,19 @@ void _math_test_all_transform_functions( char *description )
if ( mesa_profile ) {
if ( !counter_overhead ) {
INIT_COUNTER();
_mesa_printf("counter overhead: %lu cycles\n\n", counter_overhead );
printf("counter overhead: %lu cycles\n\n", counter_overhead );
}
_mesa_printf("transform results after hooking in %s functions:\n", description );
printf("transform results after hooking in %s functions:\n", description );
}
#endif
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
_mesa_printf("\n" );
printf("\n" );
for ( psize = 1 ; psize <= 4 ; psize++ ) {
_mesa_printf(" p%d\t", psize );
printf(" p%d\t", psize );
}
_mesa_printf("\n--------------------------------------------------------\n" );
printf("\n--------------------------------------------------------\n" );
}
#endif
@ -315,23 +315,23 @@ void _math_test_all_transform_functions( char *description )
if ( test_transform_function( func, psize, mtype, cycles ) == 0 ) {
char buf[100];
_mesa_sprintf(buf, "_mesa_transform_tab[0][%d][%s] failed test (%s)",
psize, mstrings[mtype], description );
sprintf(buf, "_mesa_transform_tab[0][%d][%s] failed test (%s)",
psize, mstrings[mtype], description );
_mesa_problem( NULL, buf );
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf(" %li\t", benchmark_tab[psize-1][mtype] );
printf(" %li\t", benchmark_tab[psize-1][mtype] );
#endif
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf(" | [%s]\n", mstrings[mtype] );
printf(" | [%s]\n", mstrings[mtype] );
#endif
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf( "\n" );
printf( "\n" );
#endif
}

16
src/mesa/math/m_vector.c
View file

@ -148,27 +148,27 @@ _mesa_vector4f_print( const GLvector4f *v, const GLubyte *cullmask,
GLfloat *d = (GLfloat *)v->data;
GLuint j, i = 0, count;
_mesa_printf("data-start\n");
printf("data-start\n");
for (; d != v->start; STRIDE_F(d, v->stride), i++)
_mesa_printf(t, i, d[0], d[1], d[2], d[3]);
printf(t, i, d[0], d[1], d[2], d[3]);
_mesa_printf("start-count(%u)\n", v->count);
printf("start-count(%u)\n", v->count);
count = i + v->count;
if (culling) {
for (; i < count; STRIDE_F(d, v->stride), i++)
if (cullmask[i])
_mesa_printf(t, i, d[0], d[1], d[2], d[3]);
printf(t, i, d[0], d[1], d[2], d[3]);
}
else {
for (; i < count; STRIDE_F(d, v->stride), i++)
_mesa_printf(t, i, d[0], d[1], d[2], d[3]);
printf(t, i, d[0], d[1], d[2], d[3]);
}
for (j = v->size; j < 4; j++) {
if ((v->flags & (1<<j)) == 0) {
_mesa_printf("checking col %u is clean as advertised ", j);
printf("checking col %u is clean as advertised ", j);
for (i = 0, d = (GLfloat *) v->data;
i < count && d[j] == c[j];
@ -177,9 +177,9 @@ _mesa_vector4f_print( const GLvector4f *v, const GLubyte *cullmask,
}
if (i == count)
_mesa_printf(" --> ok\n");
printf(" --> ok\n");
else
_mesa_printf(" --> Failed at %u ******\n", i);
printf(" --> Failed at %u ******\n", i);
}
}
}

4
src/mesa/shader/arbprogparse.c
View file

@ -148,7 +148,7 @@ _mesa_parse_arb_fragment_program(GLcontext* ctx, GLenum target,
}
#if DEBUG_FP
_mesa_printf("____________Fragment program %u ________\n", program->Base.Id);
printf("____________Fragment program %u ________\n", program->Base.Id);
_mesa_print_program(&program->Base);
#endif
}
@ -211,7 +211,7 @@ _mesa_parse_arb_vertex_program(GLcontext *ctx, GLenum target,
program->Base.Parameters = prog.Parameters;
#if DEBUG_VP
_mesa_printf("____________Vertex program %u __________\n", program->Base.Id);
printf("____________Vertex program %u __________\n", program->Base.Id);
_mesa_print_program(&program->Base);
#endif
}

6
src/mesa/shader/nvfragparse.c
View file

@ -200,7 +200,7 @@ do { \
#define RETURN_ERROR2(msg1, msg2) \
do { \
char err[1000]; \
_mesa_sprintf(err, "%s %s", msg1, msg2); \
sprintf(err, "%s %s", msg1, msg2); \
record_error(parseState, err, __LINE__); \
return GL_FALSE; \
} while(0)
@ -1566,9 +1566,9 @@ _mesa_parse_nv_fragment_program(GLcontext *ctx, GLenum dstTarget,
#endif
#ifdef DEBUG_foo
_mesa_printf("--- glLoadProgramNV(%d) result ---\n", program->Base.Id);
printf("--- glLoadProgramNV(%d) result ---\n", program->Base.Id);
_mesa_fprint_program_opt(stdout, &program->Base, PROG_PRINT_NV, 0);
_mesa_printf("----------------------------------\n");
printf("----------------------------------\n");
#endif
}
else {

6
src/mesa/shader/nvvertparse.c
View file

@ -111,7 +111,7 @@ do { \
#define RETURN_ERROR2(msg1, msg2) \
do { \
char err[1000]; \
_mesa_sprintf(err, "%s %s", msg1, msg2); \
sprintf(err, "%s %s", msg1, msg2); \
record_error(parseState, err, __LINE__); \
return GL_FALSE; \
} while(0)
@ -1397,9 +1397,9 @@ _mesa_parse_nv_vertex_program(GLcontext *ctx, GLenum dstTarget,
program->IsNVProgram = GL_TRUE;
#ifdef DEBUG_foo
_mesa_printf("--- glLoadProgramNV result ---\n");
printf("--- glLoadProgramNV result ---\n");
_mesa_fprint_program_opt(stdout, &program->Base, PROG_PRINT_NV, 0);
_mesa_printf("------------------------------\n");
printf("------------------------------\n");
#endif
if (program->Base.Parameters)

4
src/mesa/shader/prog_execute.c
View file

@ -1782,8 +1782,8 @@ _mesa_execute_program(GLcontext * ctx,
{
GLfloat a[4];
fetch_vector4(&inst->SrcReg[0], machine, a);
_mesa_printf("%s%g, %g, %g, %g\n", (const char *) inst->Data,
a[0], a[1], a[2], a[3]);
printf("%s%g, %g, %g, %g\n", (const char *) inst->Data,
a[0], a[1], a[2], a[3]);
}
break;
case OPCODE_END:

2
src/mesa/shader/prog_instruction.c
View file

@ -345,7 +345,7 @@ _mesa_opcode_string(gl_inst_opcode opcode)
return InstInfo[opcode].Name;
else {
static char s[20];
_mesa_snprintf(s, sizeof(s), "OP%u", opcode);
snprintf(s, sizeof(s), "OP%u", opcode);
return s;
}
}

62
src/mesa/shader/prog_optimize.c
View file

@ -159,7 +159,7 @@ _mesa_consolidate_registers(struct gl_program *prog)
GLuint tempMax = 0, i;
if (dbg) {
_mesa_printf("Optimize: Begin register consolidation\n");
printf("Optimize: Begin register consolidation\n");
}
memset(tempUsed, 0, sizeof(tempUsed));
@ -196,7 +196,7 @@ _mesa_consolidate_registers(struct gl_program *prog)
for (i = 0; i <= tempMax; i++) {
if (tempUsed[i]) {
tempMap[i] = freeTemp++;
/*_mesa_printf("replace %u with %u\n", i, tempMap[i]);*/
/*printf("replace %u with %u\n", i, tempMap[i]);*/
}
}
if (freeTemp == tempMax + 1) {
@ -204,14 +204,14 @@ _mesa_consolidate_registers(struct gl_program *prog)
return;
}
if (dbg) {
_mesa_printf("Replace regs 0..%u with 0..%u\n", tempMax, freeTemp-1);
printf("Replace regs 0..%u with 0..%u\n", tempMax, freeTemp-1);
}
}
replace_regs(prog, PROGRAM_TEMPORARY, tempMap);
if (dbg) {
_mesa_printf("Optimize: End register consolidation\n");
printf("Optimize: End register consolidation\n");
}
}
@ -232,7 +232,7 @@ _mesa_remove_dead_code(struct gl_program *prog)
memset(tempRead, 0, sizeof(tempRead));
if (dbg) {
_mesa_printf("Optimize: Begin dead code removal\n");
printf("Optimize: Begin dead code removal\n");
/*_mesa_print_program(prog);*/
}
@ -255,7 +255,7 @@ _mesa_remove_dead_code(struct gl_program *prog)
if (inst->SrcReg[j].RelAddr) {
if (dbg)
_mesa_printf("abort remove dead code (indirect temp)\n");
printf("abort remove dead code (indirect temp)\n");
goto done;
}
@ -290,7 +290,7 @@ _mesa_remove_dead_code(struct gl_program *prog)
if (inst->DstReg.RelAddr) {
if (dbg)
_mesa_printf("abort remove dead code (indirect temp)\n");
printf("abort remove dead code (indirect temp)\n");
goto done;
}
@ -319,7 +319,7 @@ _mesa_remove_dead_code(struct gl_program *prog)
if (!tempRead[index][chan] &&
inst->DstReg.WriteMask & (1 << chan)) {
if (dbg) {
_mesa_printf("Remove writemask on %u.%c\n", i,
printf("Remove writemask on %u.%c\n", i,
chan == 3 ? 'w' : 'x' + chan);
}
inst->DstReg.WriteMask &= ~(1 << chan);
@ -330,7 +330,7 @@ _mesa_remove_dead_code(struct gl_program *prog)
if (inst->DstReg.WriteMask == 0) {
/* If we cleared all writes, the instruction can be removed. */
if (dbg)
_mesa_printf("Remove instruction %u: \n", i);
printf("Remove instruction %u: \n", i);
removeInst[i] = GL_TRUE;
}
}
@ -340,9 +340,9 @@ _mesa_remove_dead_code(struct gl_program *prog)
rem = remove_instructions(prog, removeInst);
if (dbg) {
_mesa_printf("Optimize: End dead code removal.\n");
_mesa_printf(" %u channel writes removed\n", rem);
_mesa_printf(" %u instructions removed\n", rem);
printf("Optimize: End dead code removal.\n");
printf(" %u channel writes removed\n", rem);
printf(" %u instructions removed\n", rem);
/*_mesa_print_program(prog);*/
}
@ -427,7 +427,7 @@ _mesa_remove_extra_move_use(struct gl_program *prog)
GLuint i, j;
if (dbg) {
_mesa_printf("Optimize: Begin remove extra move use\n");
printf("Optimize: Begin remove extra move use\n");
_mesa_print_program(prog);
}
@ -518,7 +518,7 @@ _mesa_remove_extra_move_use(struct gl_program *prog)
}
if (dbg) {
_mesa_printf("Optimize: End remove extra move use.\n");
printf("Optimize: End remove extra move use.\n");
/*_mesa_print_program(prog);*/
}
}
@ -533,7 +533,7 @@ _mesa_remove_extra_moves(struct gl_program *prog)
GLuint i, rem, loopNesting = 0, subroutineNesting = 0;
if (dbg) {
_mesa_printf("Optimize: Begin remove extra moves\n");
printf("Optimize: Begin remove extra moves\n");
_mesa_print_program(prog);
}
@ -605,8 +605,8 @@ _mesa_remove_extra_moves(struct gl_program *prog)
removeInst[i] = GL_TRUE;
if (dbg) {
_mesa_printf("Remove MOV at %u\n", i);
_mesa_printf("new prev inst %u: ", prevI);
printf("Remove MOV at %u\n", i);
printf("new prev inst %u: ", prevI);
_mesa_print_instruction(prevInst);
}
}
@ -624,7 +624,7 @@ _mesa_remove_extra_moves(struct gl_program *prog)
free(removeInst);
if (dbg) {
_mesa_printf("Optimize: End remove extra moves. %u instructions removed\n", rem);
printf("Optimize: End remove extra moves. %u instructions removed\n", rem);
/*_mesa_print_program(prog);*/
}
}
@ -837,7 +837,7 @@ find_live_intervals(struct gl_program *prog,
*/
if (dbg) {
_mesa_printf("Optimize: Begin find intervals\n");
printf("Optimize: Begin find intervals\n");
}
/* build intermediate arrays */
@ -864,16 +864,16 @@ find_live_intervals(struct gl_program *prog,
/* print interval info */
for (i = 0; i < liveIntervals->Num; i++) {
const struct interval *inv = liveIntervals->Intervals + i;
_mesa_printf("Reg[%d] live [%d, %d]:",
printf("Reg[%d] live [%d, %d]:",
inv->Reg, inv->Start, inv->End);
if (1) {
GLuint j;
for (j = 0; j < inv->Start; j++)
_mesa_printf(" ");
printf(" ");
for (j = inv->Start; j <= inv->End; j++)
_mesa_printf("x");
printf("x");
}
_mesa_printf("\n");
printf("\n");
}
}
@ -914,7 +914,7 @@ _mesa_reallocate_registers(struct gl_program *prog)
GLint maxTemp = -1;
if (dbg) {
_mesa_printf("Optimize: Begin live-interval register reallocation\n");
printf("Optimize: Begin live-interval register reallocation\n");
_mesa_print_program(prog);
}
@ -925,7 +925,7 @@ _mesa_reallocate_registers(struct gl_program *prog)
if (!find_live_intervals(prog, &liveIntervals)) {
if (dbg)
_mesa_printf("Aborting register reallocation\n");
printf("Aborting register reallocation\n");
return;
}
@ -938,7 +938,7 @@ _mesa_reallocate_registers(struct gl_program *prog)
const struct interval *live = liveIntervals.Intervals + i;
if (dbg)
_mesa_printf("Consider register %u\n", live->Reg);
printf("Consider register %u\n", live->Reg);
/* Expire old intervals. Intervals which have ended with respect
* to the live interval can have their remapped registers freed.
@ -959,7 +959,7 @@ _mesa_reallocate_registers(struct gl_program *prog)
ASSERT(regNew >= 0);
if (dbg)
_mesa_printf(" expire interval for reg %u\n", inv->Reg);
printf(" expire interval for reg %u\n", inv->Reg);
/* remove interval j from active list */
remove_interval(&activeIntervals, inv);
@ -967,7 +967,7 @@ _mesa_reallocate_registers(struct gl_program *prog)
/* return register regNew to the free pool */
if (dbg)
_mesa_printf(" free reg %d\n", regNew);
printf(" free reg %d\n", regNew);
ASSERT(usedRegs[regNew] == GL_TRUE);
usedRegs[regNew] = GL_FALSE;
}
@ -984,7 +984,7 @@ _mesa_reallocate_registers(struct gl_program *prog)
registerMap[live->Reg] = k;
maxTemp = MAX2(maxTemp, k);
if (dbg)
_mesa_printf(" remap register %u -> %d\n", live->Reg, k);
printf(" remap register %u -> %d\n", live->Reg, k);
}
/* Insert this live interval into the active list which is sorted
@ -1005,8 +1005,8 @@ _mesa_reallocate_registers(struct gl_program *prog)
}
if (dbg) {
_mesa_printf("Optimize: End live-interval register reallocation\n");
_mesa_printf("Num temp regs before: %u after: %u\n",
printf("Optimize: End live-interval register reallocation\n");
printf("Num temp regs before: %u after: %u\n",
liveIntervals.Num, maxTemp + 1);
_mesa_print_program(prog);
}

330
src/mesa/shader/prog_print.c
View file

@ -77,7 +77,7 @@ file_string(gl_register_file f, gl_prog_print_mode mode)
default:
{
static char s[20];
_mesa_snprintf(s, sizeof(s), "FILE%u", f);
snprintf(s, sizeof(s), "FILE%u", f);
return s;
}
}
@ -172,12 +172,12 @@ arb_input_attrib_string(GLint index, GLenum progType)
void
_mesa_print_vp_inputs(GLbitfield inputs)
{
_mesa_printf("VP Inputs 0x%x: \n", inputs);
printf("VP Inputs 0x%x: \n", inputs);
while (inputs) {
GLint attr = _mesa_ffs(inputs) - 1;
const char *name = arb_input_attrib_string(attr,
GL_VERTEX_PROGRAM_ARB);
_mesa_printf(" %d: %s\n", attr, name);
printf(" %d: %s\n", attr, name);
inputs &= ~(1 << attr);
}
}
@ -190,12 +190,12 @@ _mesa_print_vp_inputs(GLbitfield inputs)
void
_mesa_print_fp_inputs(GLbitfield inputs)
{
_mesa_printf("FP Inputs 0x%x: \n", inputs);
printf("FP Inputs 0x%x: \n", inputs);
while (inputs) {
GLint attr = _mesa_ffs(inputs) - 1;
const char *name = arb_input_attrib_string(attr,
GL_FRAGMENT_PROGRAM_ARB);
_mesa_printf(" %d: %s\n", attr, name);
printf(" %d: %s\n", attr, name);
inputs &= ~(1 << attr);
}
}
@ -274,46 +274,46 @@ reg_string(gl_register_file f, GLint index, gl_prog_print_mode mode,
switch (mode) {
case PROG_PRINT_DEBUG:
_mesa_sprintf(str, "%s[%s%d]", file_string(f, mode), addr, index);
sprintf(str, "%s[%s%d]", file_string(f, mode), addr, index);
break;
case PROG_PRINT_ARB:
switch (f) {
case PROGRAM_INPUT:
_mesa_sprintf(str, "%s", arb_input_attrib_string(index, prog->Target));
sprintf(str, "%s", arb_input_attrib_string(index, prog->Target));
break;
case PROGRAM_OUTPUT:
_mesa_sprintf(str, "%s", arb_output_attrib_string(index, prog->Target));
sprintf(str, "%s", arb_output_attrib_string(index, prog->Target));
break;
case PROGRAM_TEMPORARY:
_mesa_sprintf(str, "temp%d", index);
sprintf(str, "temp%d", index);
break;
case PROGRAM_ENV_PARAM:
_mesa_sprintf(str, "program.env[%s%d]", addr, index);
sprintf(str, "program.env[%s%d]", addr, index);
break;
case PROGRAM_LOCAL_PARAM:
_mesa_sprintf(str, "program.local[%s%d]", addr, index);
sprintf(str, "program.local[%s%d]", addr, index);
break;
case PROGRAM_VARYING: /* extension */
_mesa_sprintf(str, "varying[%s%d]", addr, index);
sprintf(str, "varying[%s%d]", addr, index);
break;
case PROGRAM_CONSTANT: /* extension */
_mesa_sprintf(str, "constant[%s%d]", addr, index);
sprintf(str, "constant[%s%d]", addr, index);
break;
case PROGRAM_UNIFORM: /* extension */
_mesa_sprintf(str, "uniform[%s%d]", addr, index);
sprintf(str, "uniform[%s%d]", addr, index);
break;
case PROGRAM_STATE_VAR:
{
struct gl_program_parameter *param
= prog->Parameters->Parameters + index;
char *state = _mesa_program_state_string(param->StateIndexes);
_mesa_sprintf(str, state);
sprintf(str, state);
free(state);
}
break;
case PROGRAM_ADDRESS:
_mesa_sprintf(str, "A%d", index);
sprintf(str, "A%d", index);
break;
default:
_mesa_problem(NULL, "bad file in reg_string()");
@ -324,30 +324,30 @@ reg_string(gl_register_file f, GLint index, gl_prog_print_mode mode,
switch (f) {
case PROGRAM_INPUT:
if (prog->Target == GL_VERTEX_PROGRAM_ARB)
_mesa_sprintf(str, "v[%d]", index);
sprintf(str, "v[%d]", index);
else
_mesa_sprintf(str, "f[%d]", index);
sprintf(str, "f[%d]", index);
break;
case PROGRAM_OUTPUT:
_mesa_sprintf(str, "o[%d]", index);
sprintf(str, "o[%d]", index);
break;
case PROGRAM_TEMPORARY:
_mesa_sprintf(str, "R%d", index);
sprintf(str, "R%d", index);
break;
case PROGRAM_ENV_PARAM:
_mesa_sprintf(str, "c[%d]", index);
sprintf(str, "c[%d]", index);
break;
case PROGRAM_VARYING: /* extension */
_mesa_sprintf(str, "varying[%s%d]", addr, index);
sprintf(str, "varying[%s%d]", addr, index);
break;
case PROGRAM_UNIFORM: /* extension */
_mesa_sprintf(str, "uniform[%s%d]", addr, index);
sprintf(str, "uniform[%s%d]", addr, index);
break;
case PROGRAM_CONSTANT: /* extension */
_mesa_sprintf(str, "constant[%s%d]", addr, index);
sprintf(str, "constant[%s%d]", addr, index);
break;
case PROGRAM_STATE_VAR: /* extension */
_mesa_sprintf(str, "state[%s%d]", addr, index);
sprintf(str, "state[%s%d]", addr, index);
break;
default:
_mesa_problem(NULL, "bad file in reg_string()");
@ -419,11 +419,11 @@ void
_mesa_print_swizzle(GLuint swizzle)
{
if (swizzle == SWIZZLE_XYZW) {
_mesa_printf(".xyzw\n");
printf(".xyzw\n");
}
else {
const char *s = _mesa_swizzle_string(swizzle, 0, 0);
_mesa_printf("%s\n", s);
printf("%s\n", s);
}
}
@ -476,23 +476,23 @@ fprint_dst_reg(FILE * f,
gl_prog_print_mode mode,
const struct gl_program *prog)
{
_mesa_fprintf(f, "%s%s",
reg_string((gl_register_file) dstReg->File,
dstReg->Index, mode, dstReg->RelAddr, prog),
_mesa_writemask_string(dstReg->WriteMask));
fprintf(f, "%s%s",
reg_string((gl_register_file) dstReg->File,
dstReg->Index, mode, dstReg->RelAddr, prog),
_mesa_writemask_string(dstReg->WriteMask));
if (dstReg->CondMask != COND_TR) {
_mesa_fprintf(f, " (%s.%s)",
_mesa_condcode_string(dstReg->CondMask),
_mesa_swizzle_string(dstReg->CondSwizzle,
GL_FALSE, GL_FALSE));
fprintf(f, " (%s.%s)",
_mesa_condcode_string(dstReg->CondMask),
_mesa_swizzle_string(dstReg->CondSwizzle,
GL_FALSE, GL_FALSE));
}
#if 0
_mesa_fprintf(f, "%s[%d]%s",
file_string((gl_register_file) dstReg->File, mode),
dstReg->Index,
_mesa_writemask_string(dstReg->WriteMask));
fprintf(f, "%s[%d]%s",
file_string((gl_register_file) dstReg->File, mode),
dstReg->Index,
_mesa_writemask_string(dstReg->WriteMask));
#endif
}
@ -505,19 +505,19 @@ fprint_src_reg(FILE *f,
{
const char *abs = srcReg->Abs ? "|" : "";
_mesa_fprintf(f, "%s%s%s%s",
abs,
reg_string((gl_register_file) srcReg->File,
srcReg->Index, mode, srcReg->RelAddr, prog),
_mesa_swizzle_string(srcReg->Swizzle,
srcReg->Negate, GL_FALSE),
abs);
fprintf(f, "%s%s%s%s",
abs,
reg_string((gl_register_file) srcReg->File,
srcReg->Index, mode, srcReg->RelAddr, prog),
_mesa_swizzle_string(srcReg->Swizzle,
srcReg->Negate, GL_FALSE),
abs);
#if 0
_mesa_fprintf(f, "%s[%d]%s",
file_string((gl_register_file) srcReg->File, mode),
srcReg->Index,
_mesa_swizzle_string(srcReg->Swizzle,
srcReg->Negate, GL_FALSE));
fprintf(f, "%s[%d]%s",
file_string((gl_register_file) srcReg->File, mode),
srcReg->Index,
_mesa_swizzle_string(srcReg->Swizzle,
srcReg->Negate, GL_FALSE));
#endif
}
@ -526,9 +526,9 @@ static void
fprint_comment(FILE *f, const struct prog_instruction *inst)
{
if (inst->Comment)
_mesa_fprintf(f, "; # %s\n", inst->Comment);
fprintf(f, "; # %s\n", inst->Comment);
else
_mesa_fprintf(f, ";\n");
fprintf(f, ";\n");
}
@ -541,29 +541,29 @@ fprint_alu_instruction(FILE *f,
{
GLuint j;
_mesa_fprintf(f, "%s", opcode_string);
fprintf(f, "%s", opcode_string);
if (inst->CondUpdate)
_mesa_fprintf(f, ".C");
fprintf(f, ".C");
/* frag prog only */
if (inst->SaturateMode == SATURATE_ZERO_ONE)
_mesa_fprintf(f, "_SAT");
fprintf(f, "_SAT");
_mesa_fprintf(f, " ");
fprintf(f, " ");
if (inst->DstReg.File != PROGRAM_UNDEFINED) {
fprint_dst_reg(f, &inst->DstReg, mode, prog);
}
else {
_mesa_fprintf(f, " ???");
fprintf(f, " ???");
}
if (numRegs > 0)
_mesa_fprintf(f, ", ");
fprintf(f, ", ");
for (j = 0; j < numRegs; j++) {
fprint_src_reg(f, inst->SrcReg + j, mode, prog);
if (j + 1 < numRegs)
_mesa_fprintf(f, ", ");
fprintf(f, ", ");
}
fprint_comment(f, inst);
@ -598,177 +598,177 @@ _mesa_fprint_instruction_opt(FILE *f,
indent -= 3;
}
for (i = 0; i < indent; i++) {
_mesa_fprintf(f, " ");
fprintf(f, " ");
}
switch (inst->Opcode) {
case OPCODE_PRINT:
_mesa_fprintf(f, "PRINT '%s'", inst->Data);
fprintf(f, "PRINT '%s'", inst->Data);
if (inst->SrcReg[0].File != PROGRAM_UNDEFINED) {
_mesa_fprintf(f, ", ");
_mesa_fprintf(f, "%s[%d]%s",
file_string((gl_register_file) inst->SrcReg[0].File,
mode),
inst->SrcReg[0].Index,
_mesa_swizzle_string(inst->SrcReg[0].Swizzle,
inst->SrcReg[0].Negate, GL_FALSE));
fprintf(f, ", ");
fprintf(f, "%s[%d]%s",
file_string((gl_register_file) inst->SrcReg[0].File,
mode),
inst->SrcReg[0].Index,
_mesa_swizzle_string(inst->SrcReg[0].Swizzle,
inst->SrcReg[0].Negate, GL_FALSE));
}
if (inst->Comment)
_mesa_fprintf(f, " # %s", inst->Comment);
fprintf(f, " # %s", inst->Comment);
fprint_comment(f, inst);
break;
case OPCODE_SWZ:
_mesa_fprintf(f, "SWZ");
fprintf(f, "SWZ");
if (inst->SaturateMode == SATURATE_ZERO_ONE)
_mesa_fprintf(f, "_SAT");
_mesa_fprintf(f, " ");
fprintf(f, "_SAT");
fprintf(f, " ");
fprint_dst_reg(f, &inst->DstReg, mode, prog);
_mesa_fprintf(f, ", %s[%d], %s",
file_string((gl_register_file) inst->SrcReg[0].File,
mode),
inst->SrcReg[0].Index,
_mesa_swizzle_string(inst->SrcReg[0].Swizzle,
inst->SrcReg[0].Negate, GL_TRUE));
fprintf(f, ", %s[%d], %s",
file_string((gl_register_file) inst->SrcReg[0].File,
mode),
inst->SrcReg[0].Index,
_mesa_swizzle_string(inst->SrcReg[0].Swizzle,
inst->SrcReg[0].Negate, GL_TRUE));
fprint_comment(f, inst);
break;
case OPCODE_TEX:
case OPCODE_TXP:
case OPCODE_TXL:
case OPCODE_TXB:
_mesa_fprintf(f, "%s", _mesa_opcode_string(inst->Opcode));
fprintf(f, "%s", _mesa_opcode_string(inst->Opcode));
if (inst->SaturateMode == SATURATE_ZERO_ONE)
_mesa_fprintf(f, "_SAT");
_mesa_fprintf(f, " ");
fprintf(f, "_SAT");
fprintf(f, " ");
fprint_dst_reg(f, &inst->DstReg, mode, prog);
_mesa_fprintf(f, ", ");
fprintf(f, ", ");
fprint_src_reg(f, &inst->SrcReg[0], mode, prog);
_mesa_fprintf(f, ", texture[%d], ", inst->TexSrcUnit);
fprintf(f, ", texture[%d], ", inst->TexSrcUnit);
switch (inst->TexSrcTarget) {
case TEXTURE_1D_INDEX: _mesa_fprintf(f, "1D"); break;
case TEXTURE_2D_INDEX: _mesa_fprintf(f, "2D"); break;
case TEXTURE_3D_INDEX: _mesa_fprintf(f, "3D"); break;
case TEXTURE_CUBE_INDEX: _mesa_fprintf(f, "CUBE"); break;
case TEXTURE_RECT_INDEX: _mesa_fprintf(f, "RECT"); break;
case TEXTURE_1D_INDEX: fprintf(f, "1D"); break;
case TEXTURE_2D_INDEX: fprintf(f, "2D"); break;
case TEXTURE_3D_INDEX: fprintf(f, "3D"); break;
case TEXTURE_CUBE_INDEX: fprintf(f, "CUBE"); break;
case TEXTURE_RECT_INDEX: fprintf(f, "RECT"); break;
default:
;
}
if (inst->TexShadow)
_mesa_fprintf(f, " SHADOW");
fprintf(f, " SHADOW");
fprint_comment(f, inst);
break;
case OPCODE_KIL:
_mesa_fprintf(f, "%s", _mesa_opcode_string(inst->Opcode));
_mesa_fprintf(f, " ");
fprintf(f, "%s", _mesa_opcode_string(inst->Opcode));
fprintf(f, " ");
fprint_src_reg(f, &inst->SrcReg[0], mode, prog);
fprint_comment(f, inst);
break;
case OPCODE_KIL_NV:
_mesa_fprintf(f, "%s", _mesa_opcode_string(inst->Opcode));
_mesa_fprintf(f, " ");
_mesa_fprintf(f, "%s.%s",
_mesa_condcode_string(inst->DstReg.CondMask),
_mesa_swizzle_string(inst->DstReg.CondSwizzle,
GL_FALSE, GL_FALSE));
fprintf(f, "%s", _mesa_opcode_string(inst->Opcode));
fprintf(f, " ");
fprintf(f, "%s.%s",
_mesa_condcode_string(inst->DstReg.CondMask),
_mesa_swizzle_string(inst->DstReg.CondSwizzle,
GL_FALSE, GL_FALSE));
fprint_comment(f, inst);
break;
case OPCODE_ARL:
_mesa_fprintf(f, "ARL ");
fprintf(f, "ARL ");
fprint_dst_reg(f, &inst->DstReg, mode, prog);
_mesa_fprintf(f, ", ");
fprintf(f, ", ");
fprint_src_reg(f, &inst->SrcReg[0], mode, prog);
fprint_comment(f, inst);
break;
case OPCODE_BRA:
_mesa_fprintf(f, "BRA %d (%s%s)",
inst->BranchTarget,
_mesa_condcode_string(inst->DstReg.CondMask),
_mesa_swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE));
fprintf(f, "BRA %d (%s%s)",
inst->BranchTarget,
_mesa_condcode_string(inst->DstReg.CondMask),
_mesa_swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE));
fprint_comment(f, inst);
break;
case OPCODE_IF:
if (inst->SrcReg[0].File != PROGRAM_UNDEFINED) {
/* Use ordinary register */
_mesa_fprintf(f, "IF ");
fprintf(f, "IF ");
fprint_src_reg(f, &inst->SrcReg[0], mode, prog);
_mesa_fprintf(f, "; ");
fprintf(f, "; ");
}
else {
/* Use cond codes */
_mesa_fprintf(f, "IF (%s%s);",
_mesa_condcode_string(inst->DstReg.CondMask),
_mesa_swizzle_string(inst->DstReg.CondSwizzle,
0, GL_FALSE));
fprintf(f, "IF (%s%s);",
_mesa_condcode_string(inst->DstReg.CondMask),
_mesa_swizzle_string(inst->DstReg.CondSwizzle,
0, GL_FALSE));
}
_mesa_fprintf(f, " # (if false, goto %d)", inst->BranchTarget);
fprintf(f, " # (if false, goto %d)", inst->BranchTarget);
fprint_comment(f, inst);
return indent + 3;
case OPCODE_ELSE:
_mesa_fprintf(f, "ELSE; # (goto %d)\n", inst->BranchTarget);
fprintf(f, "ELSE; # (goto %d)\n", inst->BranchTarget);
return indent + 3;
case OPCODE_ENDIF:
_mesa_fprintf(f, "ENDIF;\n");
fprintf(f, "ENDIF;\n");
break;
case OPCODE_BGNLOOP:
_mesa_fprintf(f, "BGNLOOP; # (end at %d)\n", inst->BranchTarget);
fprintf(f, "BGNLOOP; # (end at %d)\n", inst->BranchTarget);
return indent + 3;
case OPCODE_ENDLOOP:
_mesa_fprintf(f, "ENDLOOP; # (goto %d)\n", inst->BranchTarget);
fprintf(f, "ENDLOOP; # (goto %d)\n", inst->BranchTarget);
break;
case OPCODE_BRK:
case OPCODE_CONT:
_mesa_fprintf(f, "%s (%s%s); # (goto %d)",
_mesa_opcode_string(inst->Opcode),
_mesa_condcode_string(inst->DstReg.CondMask),
_mesa_swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE),
inst->BranchTarget);
fprintf(f, "%s (%s%s); # (goto %d)",
_mesa_opcode_string(inst->Opcode),
_mesa_condcode_string(inst->DstReg.CondMask),
_mesa_swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE),
inst->BranchTarget);
fprint_comment(f, inst);
break;
case OPCODE_BGNSUB:
if (mode == PROG_PRINT_NV) {
_mesa_fprintf(f, "%s:\n", inst->Comment); /* comment is label */
fprintf(f, "%s:\n", inst->Comment); /* comment is label */
return indent;
}
else {
_mesa_fprintf(f, "BGNSUB");
fprintf(f, "BGNSUB");
fprint_comment(f, inst);
return indent + 3;
}
case OPCODE_ENDSUB:
if (mode == PROG_PRINT_DEBUG) {
_mesa_fprintf(f, "ENDSUB");
fprintf(f, "ENDSUB");
fprint_comment(f, inst);
}
break;
case OPCODE_CAL:
if (mode == PROG_PRINT_NV) {
_mesa_fprintf(f, "CAL %s; # (goto %d)\n", inst->Comment, inst->BranchTarget);
fprintf(f, "CAL %s; # (goto %d)\n", inst->Comment, inst->BranchTarget);
}
else {
_mesa_fprintf(f, "CAL %u", inst->BranchTarget);
fprintf(f, "CAL %u", inst->BranchTarget);
fprint_comment(f, inst);
}
break;
case OPCODE_RET:
_mesa_fprintf(f, "RET (%s%s)",
_mesa_condcode_string(inst->DstReg.CondMask),
_mesa_swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE));
fprintf(f, "RET (%s%s)",
_mesa_condcode_string(inst->DstReg.CondMask),
_mesa_swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE));
fprint_comment(f, inst);
break;
case OPCODE_END:
_mesa_fprintf(f, "END\n");
fprintf(f, "END\n");
break;
case OPCODE_NOP:
if (mode == PROG_PRINT_DEBUG) {
_mesa_fprintf(f, "NOP");
fprintf(f, "NOP");
fprint_comment(f, inst);
}
else if (inst->Comment) {
/* ARB/NV extensions don't have NOP instruction */
_mesa_fprintf(f, "# %s\n", inst->Comment);
fprintf(f, "# %s\n", inst->Comment);
}
break;
/* XXX may need other special-case instructions */
@ -825,26 +825,26 @@ _mesa_fprint_program_opt(FILE *f,
switch (prog->Target) {
case GL_VERTEX_PROGRAM_ARB:
if (mode == PROG_PRINT_ARB)
_mesa_fprintf(f, "!!ARBvp1.0\n");
fprintf(f, "!!ARBvp1.0\n");
else if (mode == PROG_PRINT_NV)
_mesa_fprintf(f, "!!VP1.0\n");
fprintf(f, "!!VP1.0\n");
else
_mesa_fprintf(f, "# Vertex Program/Shader %u\n", prog->Id);
fprintf(f, "# Vertex Program/Shader %u\n", prog->Id);
break;
case GL_FRAGMENT_PROGRAM_ARB:
case GL_FRAGMENT_PROGRAM_NV:
if (mode == PROG_PRINT_ARB)
_mesa_fprintf(f, "!!ARBfp1.0\n");
fprintf(f, "!!ARBfp1.0\n");
else if (mode == PROG_PRINT_NV)
_mesa_fprintf(f, "!!FP1.0\n");
fprintf(f, "!!FP1.0\n");
else
_mesa_fprintf(f, "# Fragment Program/Shader %u\n", prog->Id);
fprintf(f, "# Fragment Program/Shader %u\n", prog->Id);
break;
}
for (i = 0; i < prog->NumInstructions; i++) {
if (lineNumbers)
_mesa_fprintf(f, "%3d: ", i);
fprintf(f, "%3d: ", i);
indent = _mesa_fprint_instruction_opt(f, prog->Instructions + i,
indent, mode, prog);
}
@ -896,30 +896,30 @@ _mesa_fprint_program_parameters(FILE *f,
{
GLuint i;
_mesa_fprintf(f, "InputsRead: 0x%x (0b%s)\n",
fprintf(f, "InputsRead: 0x%x (0b%s)\n",
prog->InputsRead, binary(prog->InputsRead));
_mesa_fprintf(f, "OutputsWritten: 0x%llx (0b%s)\n",
fprintf(f, "OutputsWritten: 0x%llx (0b%s)\n",
prog->OutputsWritten, binary(prog->OutputsWritten));
_mesa_fprintf(f, "NumInstructions=%d\n", prog->NumInstructions);
_mesa_fprintf(f, "NumTemporaries=%d\n", prog->NumTemporaries);
_mesa_fprintf(f, "NumParameters=%d\n", prog->NumParameters);
_mesa_fprintf(f, "NumAttributes=%d\n", prog->NumAttributes);
_mesa_fprintf(f, "NumAddressRegs=%d\n", prog->NumAddressRegs);
_mesa_fprintf(f, "SamplersUsed: 0x%x (0b%s)\n",
fprintf(f, "NumInstructions=%d\n", prog->NumInstructions);
fprintf(f, "NumTemporaries=%d\n", prog->NumTemporaries);
fprintf(f, "NumParameters=%d\n", prog->NumParameters);
fprintf(f, "NumAttributes=%d\n", prog->NumAttributes);
fprintf(f, "NumAddressRegs=%d\n", prog->NumAddressRegs);
fprintf(f, "SamplersUsed: 0x%x (0b%s)\n",
prog->SamplersUsed, binary(prog->SamplersUsed));
_mesa_fprintf(f, "Samplers=[ ");
fprintf(f, "Samplers=[ ");
for (i = 0; i < MAX_SAMPLERS; i++) {
_mesa_fprintf(f, "%d ", prog->SamplerUnits[i]);
fprintf(f, "%d ", prog->SamplerUnits[i]);
}
_mesa_fprintf(f, "]\n");
fprintf(f, "]\n");
_mesa_load_state_parameters(ctx, prog->Parameters);
#if 0
_mesa_fprintf(f, "Local Params:\n");
fprintf(f, "Local Params:\n");
for (i = 0; i < MAX_PROGRAM_LOCAL_PARAMS; i++){
const GLfloat *p = prog->LocalParams[i];
_mesa_fprintf(f, "%2d: %f, %f, %f, %f\n", i, p[0], p[1], p[2], p[3]);
fprintf(f, "%2d: %f, %f, %f, %f\n", i, p[0], p[1], p[2], p[3]);
}
#endif
_mesa_print_parameter_list(prog->Parameters);
@ -950,24 +950,24 @@ _mesa_fprint_parameter_list(FILE *f,
return;
if (0)
_mesa_fprintf(f, "param list %p\n", (void *) list);
_mesa_fprintf(f, "dirty state flags: 0x%x\n", list->StateFlags);
fprintf(f, "param list %p\n", (void *) list);
fprintf(f, "dirty state flags: 0x%x\n", list->StateFlags);
for (i = 0; i < list->NumParameters; i++){
struct gl_program_parameter *param = list->Parameters + i;
const GLfloat *v = list->ParameterValues[i];
_mesa_fprintf(f, "param[%d] sz=%d %s %s = {%.3g, %.3g, %.3g, %.3g}",
i, param->Size,
file_string(list->Parameters[i].Type, mode),
param->Name, v[0], v[1], v[2], v[3]);
fprintf(f, "param[%d] sz=%d %s %s = {%.3g, %.3g, %.3g, %.3g}",
i, param->Size,
file_string(list->Parameters[i].Type, mode),
param->Name, v[0], v[1], v[2], v[3]);
if (param->Flags & PROG_PARAM_BIT_CENTROID)
_mesa_fprintf(f, " Centroid");
fprintf(f, " Centroid");
if (param->Flags & PROG_PARAM_BIT_INVARIANT)
_mesa_fprintf(f, " Invariant");
fprintf(f, " Invariant");
if (param->Flags & PROG_PARAM_BIT_FLAT)
_mesa_fprintf(f, " Flat");
fprintf(f, " Flat");
if (param->Flags & PROG_PARAM_BIT_LINEAR)
_mesa_fprintf(f, " Linear");
_mesa_fprintf(f, "\n");
fprintf(f, " Linear");
fprintf(f, "\n");
}
}
@ -997,7 +997,7 @@ _mesa_write_shader_to_file(const struct gl_shader *shader)
else
type = "vert";
_mesa_snprintf(filename, sizeof(filename), "shader_%u.%s", shader->Name, type);
snprintf(filename, sizeof(filename), "shader_%u.%s", shader->Name, type);
f = fopen(filename, "w");
if (!f) {
fprintf(stderr, "Unable to open %s for writing\n", filename);
@ -1047,7 +1047,7 @@ _mesa_append_uniforms_to_file(const struct gl_shader *shader,
else
type = "vert";
_mesa_snprintf(filename, sizeof(filename), "shader_%u.%s", shader->Name, type);
snprintf(filename, sizeof(filename), "shader_%u.%s", shader->Name, type);
f = fopen(filename, "a"); /* append */
if (!f) {
fprintf(stderr, "Unable to open %s for appending\n", filename);

6
src/mesa/shader/prog_statevars.c
View file

@ -950,7 +950,7 @@ static void
append_index(char *dst, GLint index)
{
char s[20];
_mesa_sprintf(s, "[%d]", index);
sprintf(s, "[%d]", index);
append(dst, s);
}
@ -1029,9 +1029,9 @@ _mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
if (modifier)
append_token(str, modifier);
if (firstRow == lastRow)
_mesa_sprintf(tmp, ".row[%d]", firstRow);
sprintf(tmp, ".row[%d]", firstRow);
else
_mesa_sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
append(str, tmp);
}
break;

6
src/mesa/shader/program_parse.tab.c
View file

@ -2984,7 +2984,7 @@ yyreduce:
{
if (((yyvsp[(1) - (1)].integer) < 0) || ((yyvsp[(1) - (1)].integer) > 63)) {
char s[100];
_mesa_snprintf(s, sizeof(s),
snprintf(s, sizeof(s),
"relative address offset too large (%d)", (yyvsp[(1) - (1)].integer));
yyerror(& (yylsp[(1) - (1)]), state, s);
YYERROR;
@ -3001,7 +3001,7 @@ yyreduce:
{
if (((yyvsp[(1) - (1)].integer) < 0) || ((yyvsp[(1) - (1)].integer) > 64)) {
char s[100];
_mesa_snprintf(s, sizeof(s),
snprintf(s, sizeof(s),
"relative address offset too large (%d)", (yyvsp[(1) - (1)].integer));
yyerror(& (yylsp[(1) - (1)]), state, s);
YYERROR;
@ -4915,7 +4915,7 @@ yyreduce:
if (exist != NULL) {
char m[1000];
_mesa_snprintf(m, sizeof(m), "redeclared identifier: %s", (yyvsp[(2) - (4)].string));
snprintf(m, sizeof(m), "redeclared identifier: %s", (yyvsp[(2) - (4)].string));
free((yyvsp[(2) - (4)].string));
yyerror(& (yylsp[(2) - (4)]), state, m);
YYERROR;

6
src/mesa/shader/program_parse.y
View file

@ -936,7 +936,7 @@ addrRegPosOffset: INTEGER
{
if (($1 < 0) || ($1 > 63)) {
char s[100];
_mesa_snprintf(s, sizeof(s),
snprintf(s, sizeof(s),
"relative address offset too large (%d)", $1);
yyerror(& @1, state, s);
YYERROR;
@ -950,7 +950,7 @@ addrRegNegOffset: INTEGER
{
if (($1 < 0) || ($1 > 64)) {
char s[100];
_mesa_snprintf(s, sizeof(s),
snprintf(s, sizeof(s),
"relative address offset too large (%d)", $1);
yyerror(& @1, state, s);
YYERROR;
@ -2173,7 +2173,7 @@ ALIAS_statement: ALIAS IDENTIFIER '=' USED_IDENTIFIER
if (exist != NULL) {
char m[1000];
_mesa_snprintf(m, sizeof(m), "redeclared identifier: %s", $2);
snprintf(m, sizeof(m), "redeclared identifier: %s", $2);
free($2);
yyerror(& @2, state, m);
YYERROR;

36
src/mesa/shader/shader_api.c
View file

@ -1483,12 +1483,12 @@ _mesa_link_program(GLcontext *ctx, GLuint program)
if (0) {
GLuint i;
_mesa_printf("Link %u shaders in program %u: %s\n",
printf("Link %u shaders in program %u: %s\n",
shProg->NumShaders, shProg->Name,
shProg->LinkStatus ? "Success" : "Failed");
for (i = 0; i < shProg->NumShaders; i++) {
_mesa_printf(" shader %u, type 0x%x\n",
printf(" shader %u, type 0x%x\n",
shProg->Shaders[i]->Name,
shProg->Shaders[i]->Type);
}
@ -1504,7 +1504,7 @@ print_shader_info(const struct gl_shader_program *shProg)
{
GLuint i;
_mesa_printf("Mesa: glUseProgram(%u)\n", shProg->Name);
printf("Mesa: glUseProgram(%u)\n", shProg->Name);
for (i = 0; i < shProg->NumShaders; i++) {
const char *s;
switch (shProg->Shaders[i]->Type) {
@ -1520,14 +1520,14 @@ print_shader_info(const struct gl_shader_program *shProg)
default:
s = "";
}
_mesa_printf(" %s shader %u, checksum %u\n", s,
shProg->Shaders[i]->Name,
shProg->Shaders[i]->SourceChecksum);
printf(" %s shader %u, checksum %u\n", s,
shProg->Shaders[i]->Name,
shProg->Shaders[i]->SourceChecksum);
}
if (shProg->VertexProgram)
_mesa_printf(" vert prog %u\n", shProg->VertexProgram->Base.Id);
printf(" vert prog %u\n", shProg->VertexProgram->Base.Id);
if (shProg->FragmentProgram)
_mesa_printf(" frag prog %u\n", shProg->FragmentProgram->Base.Id);
printf(" frag prog %u\n", shProg->FragmentProgram->Base.Id);
}
@ -1697,8 +1697,8 @@ set_program_uniform(GLcontext *ctx, struct gl_program *program,
/* This maps a sampler to a texture unit: */
if (sampler < MAX_SAMPLERS) {
#if 0
_mesa_printf("Set program %p sampler %d '%s' to unit %u\n",
program, sampler, param->Name, texUnit);
printf("Set program %p sampler %d '%s' to unit %u\n",
program, sampler, param->Name, texUnit);
#endif
if (program->SamplerUnits[sampler] != texUnit) {
program->SamplerUnits[sampler] = texUnit;
@ -1861,21 +1861,21 @@ _mesa_uniform(GLcontext *ctx, GLint location, GLsizei count,
if (ctx->Shader.Flags & GLSL_UNIFORMS) {
GLint i;
_mesa_printf("Mesa: set program %u uniform %s (loc %d) to: ",
shProg->Name, uniform->Name, location);
printf("Mesa: set program %u uniform %s (loc %d) to: ",
shProg->Name, uniform->Name, location);
if (basicType == GL_INT) {
const GLint *v = (const GLint *) values;
for (i = 0; i < count * elems; i++) {
_mesa_printf("%d ", v[i]);
printf("%d ", v[i]);
}
}
else {
const GLfloat *v = (const GLfloat *) values;
for (i = 0; i < count * elems; i++) {
_mesa_printf("%g ", v[i]);
printf("%g ", v[i]);
}
}
_mesa_printf("\n");
printf("\n");
}
/* A uniform var may be used by both a vertex shader and a fragment
@ -2076,9 +2076,9 @@ validate_samplers(GLcontext *ctx, const struct gl_program *prog, char *errMsg)
unit = prog->SamplerUnits[sampler];
target = prog->SamplerTargets[sampler];
if (targetUsed[unit] != -1 && targetUsed[unit] != target) {
_mesa_snprintf(errMsg, 100,
"Texture unit %d is accessed both as %s and %s",
unit, targetName[targetUsed[unit]], targetName[target]);
snprintf(errMsg, 100,
"Texture unit %d is accessed both as %s and %s",
unit, targetName[targetUsed[unit]], targetName[target]);
return GL_FALSE;
}
targetUsed[unit] = target;

4
src/mesa/shader/slang/slang_codegen.c
View file

@ -1643,7 +1643,7 @@ _slang_gen_function_call(slang_assemble_ctx *A, slang_function *fun,
if (A->pragmas->Debug) {
char s[1000];
_mesa_snprintf(s, sizeof(s), "Call/inline %s()", (char *) fun->header.a_name);
snprintf(s, sizeof(s), "Call/inline %s()", (char *) fun->header.a_name);
n->Comment = _slang_strdup(s);
}
@ -2190,7 +2190,7 @@ _slang_make_array_constructor(slang_assemble_ctx *A, slang_operation *oper)
*/
slang_variable *p = slang_variable_scope_grow(fun->parameters);
char name[10];
_mesa_snprintf(name, sizeof(name), "p%d", i);
snprintf(name, sizeof(name), "p%d", i);
p->a_name = slang_atom_pool_atom(A->atoms, name);
p->type.qualifier = SLANG_QUAL_CONST;
p->type.specifier.type = baseType;

4
src/mesa/shader/slang/slang_emit.c
View file

@ -2303,8 +2303,8 @@ emit_var_ref(slang_emit_info *emitInfo, slang_ir_node *n)
/* error */
char s[100];
/* XXX isn't this really an out of memory/resources error? */
_mesa_snprintf(s, sizeof(s), "Undefined variable '%s'",
(char *) n->Var->a_name);
snprintf(s, sizeof(s), "Undefined variable '%s'",
(char *) n->Var->a_name);
slang_info_log_error(emitInfo->log, s);
return NULL;
}

2
src/mesa/shader/slang/slang_label.c
View file

@ -37,7 +37,7 @@ _slang_label_new_unique(const char *name)
free(l);
return NULL;
}
_mesa_sprintf(l->Name, "%s_%d", name, id);
sprintf(l->Name, "%s_%d", name, id);
id++;
l->Location = -1;
}

26
src/mesa/shader/slang/slang_link.c
View file

@ -139,16 +139,16 @@ link_varying_vars(GLcontext *ctx,
}
if (!bits_agree(var->Flags, v->Flags, PROG_PARAM_BIT_CENTROID)) {
char msg[100];
_mesa_snprintf(msg, sizeof(msg),
"centroid modifier mismatch for '%s'", var->Name);
snprintf(msg, sizeof(msg),
"centroid modifier mismatch for '%s'", var->Name);
link_error(shProg, msg);
free(map);
return GL_FALSE;
}
if (!bits_agree(var->Flags, v->Flags, PROG_PARAM_BIT_INVARIANT)) {
char msg[100];
_mesa_snprintf(msg, sizeof(msg),
"invariant modifier mismatch for '%s'", var->Name);
snprintf(msg, sizeof(msg),
"invariant modifier mismatch for '%s'", var->Name);
link_error(shProg, msg);
free(map);
return GL_FALSE;
@ -269,8 +269,8 @@ link_uniform_vars(GLcontext *ctx,
GLuint newSampNum = *numSamplers;
if (newSampNum >= ctx->Const.MaxTextureImageUnits) {
char s[100];
_mesa_sprintf(s, "Too many texture samplers (%u, max is %u)",
newSampNum, ctx->Const.MaxTextureImageUnits);
sprintf(s, "Too many texture samplers (%u, max is %u)",
newSampNum, ctx->Const.MaxTextureImageUnits);
link_error(shProg, s);
return GL_FALSE;
}
@ -631,7 +631,7 @@ concat_shaders(struct gl_shader_program *shProg, GLenum shaderType)
}
source[len] = '\0';
/*
_mesa_printf("---NEW CONCATENATED SHADER---:\n%s\n------------\n", source);
printf("---NEW CONCATENATED SHADER---:\n%s\n------------\n", source);
*/
free(shaderLengths);
@ -875,11 +875,11 @@ _slang_link(GLcontext *ctx,
vertNotify = ctx->Driver.ProgramStringNotify(ctx, GL_FRAGMENT_PROGRAM_ARB,
&shProg->FragmentProgram->Base);
if (ctx->Shader.Flags & GLSL_DUMP) {
_mesa_printf("Mesa pre-link fragment program:\n");
printf("Mesa pre-link fragment program:\n");
_mesa_print_program(&fragProg->Base);
_mesa_print_program_parameters(ctx, &fragProg->Base);
_mesa_printf("Mesa post-link fragment program:\n");
printf("Mesa post-link fragment program:\n");
_mesa_print_program(&shProg->FragmentProgram->Base);
_mesa_print_program_parameters(ctx, &shProg->FragmentProgram->Base);
}
@ -893,11 +893,11 @@ _slang_link(GLcontext *ctx,
fragNotify = ctx->Driver.ProgramStringNotify(ctx, GL_VERTEX_PROGRAM_ARB,
&shProg->VertexProgram->Base);
if (ctx->Shader.Flags & GLSL_DUMP) {
_mesa_printf("Mesa pre-link vertex program:\n");
printf("Mesa pre-link vertex program:\n");
_mesa_print_program(&vertProg->Base);
_mesa_print_program_parameters(ctx, &vertProg->Base);
_mesa_printf("Mesa post-link vertex program:\n");
printf("Mesa post-link vertex program:\n");
_mesa_print_program(&shProg->VertexProgram->Base);
_mesa_print_program_parameters(ctx, &shProg->VertexProgram->Base);
}
@ -912,10 +912,10 @@ _slang_link(GLcontext *ctx,
}
if (ctx->Shader.Flags & GLSL_DUMP) {
_mesa_printf("Varying vars:\n");
printf("Varying vars:\n");
_mesa_print_parameter_list(shProg->Varying);
if (shProg->InfoLog) {
_mesa_printf("Info Log: %s\n", shProg->InfoLog);
printf("Info Log: %s\n", shProg->InfoLog);
}
}

6
src/mesa/shader/slang/slang_log.c
View file

@ -86,7 +86,7 @@ slang_info_log_print(slang_info_log * log, const char *msg, ...)
char buf[1024];
va_start(va, msg);
_mesa_vsprintf(buf, msg, va);
vsprintf(buf, msg, va);
va_end(va);
return slang_info_log_message(log, NULL, buf);
}
@ -98,7 +98,7 @@ slang_info_log_error(slang_info_log * log, const char *msg, ...)
char buf[1024];
va_start(va, msg);
_mesa_vsprintf(buf, msg, va);
vsprintf(buf, msg, va);
va_end(va);
log->error_flag = GL_TRUE;
if (slang_info_log_message(log, "Error", buf))
@ -114,7 +114,7 @@ slang_info_log_warning(slang_info_log * log, const char *msg, ...)
char buf[1024];
va_start(va, msg);
_mesa_vsprintf(buf, msg, va);
vsprintf(buf, msg, va);
va_end(va);
if (slang_info_log_message(log, "Warning", buf))
return 1;

2
src/mesa/shader/slang/slang_utility.c
View file

@ -120,7 +120,7 @@ slang_string_pushi (slang_string *self, GLint i)
{
char buffer[12];
_mesa_sprintf (buffer, "%d", i);
sprintf (buffer, "%d", i);
slang_string_pushs (self, buffer, strlen (buffer));
}

10
src/mesa/state_tracker/st_atom.c
View file

@ -143,7 +143,7 @@ void st_validate_state( struct st_context *st )
if (state->st == 0)
return;
/*_mesa_printf("%s %x/%x\n", __FUNCTION__, state->mesa, state->st);*/
/*printf("%s %x/%x\n", __FUNCTION__, state->mesa, state->st);*/
if (1) {
/* Debug version which enforces various sanity checks on the
@ -158,17 +158,17 @@ void st_validate_state( struct st_context *st )
const struct st_tracked_state *atom = atoms[i];
struct st_state_flags generated;
/*_mesa_printf("atom %s %x/%x\n", atom->name, atom->dirty.mesa, atom->dirty.st);*/
/*printf("atom %s %x/%x\n", atom->name, atom->dirty.mesa, atom->dirty.st);*/
if (!(atom->dirty.mesa || atom->dirty.st) ||
!atom->update) {
_mesa_printf("malformed atom %s\n", atom->name);
printf("malformed atom %s\n", atom->name);
assert(0);
}
if (check_state(state, &atom->dirty)) {
atoms[i]->update( st );
/*_mesa_printf("after: %x\n", atom->dirty.mesa);*/
/*printf("after: %x\n", atom->dirty.mesa);*/
}
accumulate_state(&examined, &atom->dirty);
@ -181,7 +181,7 @@ void st_validate_state( struct st_context *st )
assert(!check_state(&examined, &generated));
prev = *state;
}
/*_mesa_printf("\n");*/
/*printf("\n");*/
}
else {

2
src/mesa/swrast/s_lines.c
View file

@ -233,7 +233,7 @@ static const char *lineFuncName = NULL;
#define USE(lineFunc) \
do { \
lineFuncName = #lineFunc; \
/*_mesa_printf("%s\n", lineFuncName);*/ \
/*printf("%s\n", lineFuncName);*/ \
swrast->Line = lineFunc; \
} while (0)

10
src/mesa/tnl/t_draw.c
View file

@ -413,12 +413,12 @@ void _tnl_draw_prims( GLcontext *ctx,
if (0)
{
_mesa_printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
for (i = 0; i < nr_prims; i++)
_mesa_printf("prim %d: %s start %d count %d\n", i,
_mesa_lookup_enum_by_nr(prim[i].mode),
prim[i].start,
prim[i].count);
printf("prim %d: %s start %d count %d\n", i,
_mesa_lookup_enum_by_nr(prim[i].mode),
prim[i].start,
prim[i].count);
}
if (min_index) {

16
src/mesa/tnl/t_vb_cliptmp.h
View file

@ -202,12 +202,12 @@ TAG(clip_tri)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLubyte mask )
if (0) {
/* print pre-clip vertex coords */
GLuint i, j;
_mesa_printf("pre clip:\n");
printf("pre clip:\n");
for (i = 0; i < n; i++) {
j = inlist[i];
_mesa_printf(" %u: %u: %f, %f, %f, %f\n",
i, j,
coord[j][0], coord[j][1], coord[j][2], coord[j][3]);
printf(" %u: %u: %f, %f, %f, %f\n",
i, j,
coord[j][0], coord[j][1], coord[j][2], coord[j][3]);
assert(!IS_INF_OR_NAN(coord[j][0]));
assert(!IS_INF_OR_NAN(coord[j][1]));
assert(!IS_INF_OR_NAN(coord[j][2]));
@ -247,12 +247,12 @@ TAG(clip_tri)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLubyte mask )
if (0) {
/* print post-clip vertex coords */
GLuint i, j;
_mesa_printf("post clip:\n");
printf("post clip:\n");
for (i = 0; i < n; i++) {
j = inlist[i];
_mesa_printf(" %u: %u: %f, %f, %f, %f\n",
i, j,
coord[j][0], coord[j][1], coord[j][2], coord[j][3]);
printf(" %u: %u: %f, %f, %f, %f\n",
i, j,
coord[j][0], coord[j][1], coord[j][2], coord[j][3]);
}
}

10
src/mesa/tnl/t_vertex.c
View file

@ -307,8 +307,8 @@ GLuint _tnl_install_attrs( GLcontext *ctx, const struct tnl_attr_map *map,
const GLuint format = map[i].format;
if (format == EMIT_PAD) {
if (DBG)
_mesa_printf("%d: pad %d, offset %d\n", i,
map[i].offset, offset);
printf("%d: pad %d, offset %d\n", i,
map[i].offset, offset);
offset += map[i].offset;
@ -338,9 +338,9 @@ GLuint _tnl_install_attrs( GLcontext *ctx, const struct tnl_attr_map *map,
if (DBG)
_mesa_printf("%d: %s, vp %p, offset %d\n", i,
_tnl_format_info[format].name, (void *)vp,
vtx->attr[j].vertoffset);
printf("%d: %s, vp %p, offset %d\n", i,
_tnl_format_info[format].name, (void *)vp,
vtx->attr[j].vertoffset);
offset += _tnl_format_info[format].attrsize;
j++;

8
src/mesa/tnl/t_vertex_sse.c
View file

@ -496,7 +496,7 @@ static GLboolean build_vertex_emit( struct x86_program *p )
update_src_ptr(p, srcECX, vtxESI, a);
}
else {
_mesa_printf("Can't emit 1ub %x %x %d\n", a->vertoffset, a[-1].vertoffset, a[-1].vertattrsize );
printf("Can't emit 1ub %x %x %d\n", a->vertoffset, a[-1].vertoffset, a[-1].vertattrsize );
return GL_FALSE;
}
break;
@ -542,7 +542,7 @@ static GLboolean build_vertex_emit( struct x86_program *p )
j++; /* NOTE: two attrs consumed */
}
else {
_mesa_printf("Can't emit 3ub\n");
printf("Can't emit 3ub\n");
return GL_FALSE; /* add this later */
}
break;
@ -590,12 +590,12 @@ static GLboolean build_vertex_emit( struct x86_program *p )
break;
case GL_UNSIGNED_SHORT:
default:
_mesa_printf("unknown CHAN_TYPE %s\n", _mesa_lookup_enum_by_nr(CHAN_TYPE));
printf("unknown CHAN_TYPE %s\n", _mesa_lookup_enum_by_nr(CHAN_TYPE));
return GL_FALSE;
}
break;
default:
_mesa_printf("unknown a[%d].format %d\n", j, a->format);
printf("unknown a[%d].format %d\n", j, a->format);
return GL_FALSE; /* catch any new opcodes */
}

6
src/mesa/vbo/vbo_exec_api.c
View file

@ -857,7 +857,7 @@ void vbo_exec_vtx_destroy( struct vbo_exec_context *exec )
void vbo_exec_BeginVertices( GLcontext *ctx )
{
struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
if (0) _mesa_printf("%s\n", __FUNCTION__);
if (0) printf("%s\n", __FUNCTION__);
vbo_exec_vtx_map( exec );
assert((exec->ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0);
@ -892,10 +892,10 @@ void vbo_exec_FlushVertices( GLcontext *ctx, GLuint flags )
assert(exec->flush_call_depth == 1);
#endif
if (0) _mesa_printf("%s\n", __FUNCTION__);
if (0) printf("%s\n", __FUNCTION__);
if (exec->ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
if (0) _mesa_printf("%s - inside begin/end\n", __FUNCTION__);
if (0) printf("%s - inside begin/end\n", __FUNCTION__);
#ifdef DEBUG
exec->flush_call_depth--;
assert(exec->flush_call_depth == 0);

70
src/mesa/vbo/vbo_exec_array.c
View file

@ -136,13 +136,13 @@ check_array_data(GLcontext *ctx, struct gl_client_array *array,
for (k = 0; k < array->Size; k++) {
if (IS_INF_OR_NAN(f[k]) ||
f[k] >= 1.0e20 || f[k] <= -1.0e10) {
_mesa_printf("Bad array data:\n");
_mesa_printf(" Element[%u].%u = %f\n", j, k, f[k]);
_mesa_printf(" Array %u at %p\n", attrib, (void* ) array);
_mesa_printf(" Type 0x%x, Size %d, Stride %d\n",
array->Type, array->Size, array->Stride);
_mesa_printf(" Address/offset %p in Buffer Object %u\n",
array->Ptr, array->BufferObj->Name);
printf("Bad array data:\n");
printf(" Element[%u].%u = %f\n", j, k, f[k]);
printf(" Array %u at %p\n", attrib, (void* ) array);
printf(" Type 0x%x, Size %d, Stride %d\n",
array->Type, array->Size, array->Stride);
printf(" Address/offset %p in Buffer Object %u\n",
array->Ptr, array->BufferObj->Name);
f[k] = 1.0; /* XXX replace the bad value! */
}
/*assert(!IS_INF_OR_NAN(f[k]));*/
@ -257,21 +257,21 @@ print_draw_arrays(GLcontext *ctx, struct vbo_exec_context *exec,
{
int i;
_mesa_printf("vbo_exec_DrawArrays(mode 0x%x, start %d, count %d):\n",
mode, start, count);
printf("vbo_exec_DrawArrays(mode 0x%x, start %d, count %d):\n",
mode, start, count);
for (i = 0; i < 32; i++) {
GLuint bufName = exec->array.inputs[i]->BufferObj->Name;
GLint stride = exec->array.inputs[i]->Stride;
_mesa_printf("attr %2d: size %d stride %d enabled %d "
"ptr %p Bufobj %u\n",
i,
exec->array.inputs[i]->Size,
stride,
/*exec->array.inputs[i]->Enabled,*/
exec->array.legacy_array[i]->Enabled,
exec->array.inputs[i]->Ptr,
bufName);
printf("attr %2d: size %d stride %d enabled %d "
"ptr %p Bufobj %u\n",
i,
exec->array.inputs[i]->Size,
stride,
/*exec->array.inputs[i]->Enabled,*/
exec->array.legacy_array[i]->Enabled,
exec->array.inputs[i]->Ptr,
bufName);
if (bufName) {
struct gl_buffer_object *buf = _mesa_lookup_bufferobj(ctx, bufName);
@ -284,9 +284,9 @@ print_draw_arrays(GLcontext *ctx, struct vbo_exec_context *exec,
int n = (count * stride) / 4;
if (n > 32)
n = 32;
_mesa_printf(" Data at offset %d:\n", offset);
printf(" Data at offset %d:\n", offset);
for (i = 0; i < n; i++) {
_mesa_printf(" float[%d] = 0x%08x %f\n", i, k[i], f[i]);
printf(" float[%d] = 0x%08x %f\n", i, k[i], f[i]);
}
ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER_ARB, buf);
}
@ -548,11 +548,11 @@ dump_element_buffer(GLcontext *ctx, GLenum type)
const GLubyte *us = (const GLubyte *) map;
GLint i;
for (i = 0; i < ctx->Array.ElementArrayBufferObj->Size; i++) {
_mesa_printf("%02x ", us[i]);
printf("%02x ", us[i]);
if (i % 32 == 31)
_mesa_printf("\n");
printf("\n");
}
_mesa_printf("\n");
printf("\n");
}
break;
case GL_UNSIGNED_SHORT:
@ -560,11 +560,11 @@ dump_element_buffer(GLcontext *ctx, GLenum type)
const GLushort *us = (const GLushort *) map;
GLint i;
for (i = 0; i < ctx->Array.ElementArrayBufferObj->Size / 2; i++) {
_mesa_printf("%04x ", us[i]);
printf("%04x ", us[i]);
if (i % 16 == 15)
_mesa_printf("\n");
printf("\n");
}
_mesa_printf("\n");
printf("\n");
}
break;
case GL_UNSIGNED_INT:
@ -572,11 +572,11 @@ dump_element_buffer(GLcontext *ctx, GLenum type)
const GLuint *us = (const GLuint *) map;
GLint i;
for (i = 0; i < ctx->Array.ElementArrayBufferObj->Size / 4; i++) {
_mesa_printf("%08x ", us[i]);
printf("%08x ", us[i]);
if (i % 8 == 7)
_mesa_printf("\n");
printf("\n");
}
_mesa_printf("\n");
printf("\n");
}
break;
default:
@ -754,12 +754,12 @@ vbo_exec_DrawRangeElementsBaseVertex(GLenum mode,
end = ctx->Array.ArrayObj->_MaxElement - 1;
}
else if (0) {
_mesa_printf("glDraw[Range]Elements{,BaseVertex}"
"(start %u, end %u, type 0x%x, count %d) ElemBuf %u, "
"base %d\n",
start, end, type, count,
ctx->Array.ElementArrayBufferObj->Name,
basevertex);
printf("glDraw[Range]Elements{,BaseVertex}"
"(start %u, end %u, type 0x%x, count %d) ElemBuf %u, "
"base %d\n",
start, end, type, count,
ctx->Array.ElementArrayBufferObj->Name,
basevertex);
}
#if 0

32
src/mesa/vbo/vbo_exec_draw.c
View file

@ -43,22 +43,22 @@ vbo_exec_debug_verts( struct vbo_exec_context *exec )
GLuint count = exec->vtx.vert_count;
GLuint i;
_mesa_printf("%s: %u vertices %d primitives, %d vertsize\n",
__FUNCTION__,
count,
exec->vtx.prim_count,
exec->vtx.vertex_size);
printf("%s: %u vertices %d primitives, %d vertsize\n",
__FUNCTION__,
count,
exec->vtx.prim_count,
exec->vtx.vertex_size);
for (i = 0 ; i < exec->vtx.prim_count ; i++) {
struct _mesa_prim *prim = &exec->vtx.prim[i];
_mesa_printf(" prim %d: %s%s %d..%d %s %s\n",
i,
_mesa_lookup_prim_by_nr(prim->mode),
prim->weak ? " (weak)" : "",
prim->start,
prim->start + prim->count,
prim->begin ? "BEGIN" : "(wrap)",
prim->end ? "END" : "(wrap)");
printf(" prim %d: %s%s %d..%d %s %s\n",
i,
_mesa_lookup_prim_by_nr(prim->mode),
prim->weak ? " (weak)" : "",
prim->start,
prim->start + prim->count,
prim->begin ? "BEGIN" : "(wrap)",
prim->end ? "END" : "(wrap)");
}
}
@ -343,7 +343,7 @@ vbo_exec_vtx_map( struct vbo_exec_context *exec )
}
if (0)
_mesa_printf("map %d..\n", exec->vtx.buffer_used);
printf("map %d..\n", exec->vtx.buffer_used);
}
@ -378,8 +378,8 @@ vbo_exec_vtx_flush( struct vbo_exec_context *exec, GLboolean unmap )
}
if (0)
_mesa_printf("%s %d %d\n", __FUNCTION__, exec->vtx.prim_count,
exec->vtx.vert_count);
printf("%s %d %d\n", __FUNCTION__, exec->vtx.prim_count,
exec->vtx.vert_count);
vbo_context(ctx)->draw_prims( ctx,
exec->vtx.inputs,

2
src/mesa/vbo/vbo_rebase.c
View file

@ -124,7 +124,7 @@ void vbo_rebase_prims( GLcontext *ctx,
assert(min_index != 0);
if (0)
_mesa_printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
/* XXX this path is disabled for now.

8
src/mesa/vbo/vbo_save_api.c
View file

@ -1185,10 +1185,10 @@ static void vbo_print_vertex_list( GLcontext *ctx, void *data )
GLuint i;
(void) ctx;
_mesa_printf("VBO-VERTEX-LIST, %u vertices %d primitives, %d vertsize\n",
node->count,
node->prim_count,
node->vertex_size);
printf("VBO-VERTEX-LIST, %u vertices %d primitives, %d vertsize\n",
node->count,
node->prim_count,
node->vertex_size);
for (i = 0 ; i < node->prim_count ; i++) {
struct _mesa_prim *prim = &node->prim[i];

2
src/mesa/vbo/vbo_save_draw.c
View file

@ -243,7 +243,7 @@ void vbo_save_playback_vertex_list( GLcontext *ctx, void *data )
* includes operations such as glBegin or glDrawArrays.
*/
if (0)
_mesa_printf("displaylist recursive begin");
printf("displaylist recursive begin");
vbo_save_loopback_vertex_list( ctx, node );
return;

12
src/mesa/vbo/vbo_save_loopback.c
View file

@ -95,12 +95,12 @@ static void loopback_prim( GLcontext *ctx,
GLuint k;
if (0)
_mesa_printf("loopback prim %s(%s,%s) verts %d..%d\n",
_mesa_lookup_prim_by_nr(prim->mode),
prim->begin ? "begin" : "..",
prim->end ? "end" : "..",
start,
end);
printf("loopback prim %s(%s,%s) verts %d..%d\n",
_mesa_lookup_prim_by_nr(prim->mode),
prim->begin ? "begin" : "..",
prim->end ? "end" : "..",
start,
end);
if (prim->begin) {
CALL_Begin(GET_DISPATCH(), ( prim->mode ));

36
src/mesa/vbo/vbo_split_copy.c
View file

@ -147,21 +147,21 @@ dump_draw_info(GLcontext *ctx,
{
GLuint i, j;
_mesa_printf("VBO Draw:\n");
printf("VBO Draw:\n");
for (i = 0; i < nr_prims; i++) {
_mesa_printf("Prim %u of %u\n", i, nr_prims);
_mesa_printf(" Prim mode 0x%x\n", prims[i].mode);
_mesa_printf(" IB: %p\n", (void*) ib);
printf("Prim %u of %u\n", i, nr_prims);
printf(" Prim mode 0x%x\n", prims[i].mode);
printf(" IB: %p\n", (void*) ib);
for (j = 0; j < VERT_ATTRIB_MAX; j++) {
_mesa_printf(" array %d at %p:\n", j, (void*) arrays[j]);
_mesa_printf(" enabled %d, ptr %p, size %d, type 0x%x, stride %d\n",
arrays[j]->Enabled, arrays[j]->Ptr,
arrays[j]->Size, arrays[j]->Type, arrays[j]->StrideB);
printf(" array %d at %p:\n", j, (void*) arrays[j]);
printf(" enabled %d, ptr %p, size %d, type 0x%x, stride %d\n",
arrays[j]->Enabled, arrays[j]->Ptr,
arrays[j]->Size, arrays[j]->Type, arrays[j]->StrideB);
if (0) {
GLint k = prims[i].start + prims[i].count - 1;
GLfloat *last = (GLfloat *) (arrays[j]->Ptr + arrays[j]->Stride * k);
_mesa_printf(" last: %f %f %f\n",
last[0], last[1], last[2]);
printf(" last: %f %f %f\n",
last[0], last[1], last[2]);
}
}
}
@ -235,7 +235,7 @@ elt(struct copy_context *copy, GLuint elt_idx)
GLuint elt = copy->srcelt[elt_idx];
GLuint slot = elt & (ELT_TABLE_SIZE-1);
/* _mesa_printf("elt %d\n", elt); */
/* printf("elt %d\n", elt); */
/* Look up the incoming element in the vertex cache. Re-emit if
* necessary.
@ -244,7 +244,7 @@ elt(struct copy_context *copy, GLuint elt_idx)
GLubyte *csr = copy->dstptr;
GLuint i;
/* _mesa_printf(" --> emit to dstelt %d\n", copy->dstbuf_nr); */
/* printf(" --> emit to dstelt %d\n", copy->dstbuf_nr); */
for (i = 0; i < copy->nr_varying; i++) {
const struct gl_client_array *srcarray = copy->varying[i].array;
@ -268,10 +268,10 @@ elt(struct copy_context *copy, GLuint elt_idx)
{
const GLuint *f = (const GLuint *)srcptr;
GLuint j;
_mesa_printf(" varying %d: ", i);
printf(" varying %d: ", i);
for(j = 0; j < copy->varying[i].size / 4; j++)
_mesa_printf("%x ", f[j]);
_mesa_printf("\n");
printf("%x ", f[j]);
printf("\n");
}
}
@ -284,9 +284,9 @@ elt(struct copy_context *copy, GLuint elt_idx)
copy->dstbuf_nr * copy->vertex_size));
}
/* else */
/* _mesa_printf(" --> reuse vertex\n"); */
/* printf(" --> reuse vertex\n"); */
/* _mesa_printf(" --> emit %d\n", copy->vert_cache[slot].out); */
/* printf(" --> emit %d\n", copy->vert_cache[slot].out); */
copy->dstelt[copy->dstelt_nr++] = copy->vert_cache[slot].out;
return check_flush(copy);
}
@ -300,7 +300,7 @@ end( struct copy_context *copy, GLboolean end_flag )
{
struct _mesa_prim *prim = &copy->dstprim[copy->dstprim_nr];
/* _mesa_printf("end (%d)\n", end_flag); */
/* printf("end (%d)\n", end_flag); */
prim->end = end_flag;
prim->count = copy->dstelt_nr - prim->start;

10
src/mesa/vf/vf.c
View file

@ -162,8 +162,8 @@ GLuint vf_set_vertex_attributes( struct vertex_fetch *vf,
const GLuint format = map[i].format;
if (format == EMIT_PAD) {
if (DBG)
_mesa_printf("%d: pad %d, offset %d\n", i,
map[i].offset, offset);
printf("%d: pad %d, offset %d\n", i,
map[i].offset, offset);
offset += map[i].offset;
@ -180,9 +180,9 @@ GLuint vf_set_vertex_attributes( struct vertex_fetch *vf,
vf->attr[j].vertoffset = offset;
if (DBG)
_mesa_printf("%d: %s, offset %d\n", i,
vf_format_info[format].name,
vf->attr[j].vertoffset);
printf("%d: %s, offset %d\n", i,
vf_format_info[format].name,
vf->attr[j].vertoffset);
offset += vf_format_info[format].attrsize;
j++;

8
src/mesa/vf/vf_sse.c
View file

@ -482,7 +482,7 @@ static GLboolean build_vertex_emit( struct x86_program *p )
update_src_ptr(p, srcECX, vfESI, a);
}
else {
_mesa_printf("Can't emit 1ub %x %x %d\n", a->vertoffset, a[-1].vertoffset, a[-1].vertattrsize );
printf("Can't emit 1ub %x %x %d\n", a->vertoffset, a[-1].vertoffset, a[-1].vertattrsize );
return GL_FALSE;
}
break;
@ -527,7 +527,7 @@ static GLboolean build_vertex_emit( struct x86_program *p )
j++; /* NOTE: two attrs consumed */
}
else {
_mesa_printf("Can't emit 3ub\n");
printf("Can't emit 3ub\n");
}
return GL_FALSE; /* add this later */
break;
@ -575,12 +575,12 @@ static GLboolean build_vertex_emit( struct x86_program *p )
break;
case GL_UNSIGNED_SHORT:
default:
_mesa_printf("unknown CHAN_TYPE %s\n", _mesa_lookup_enum_by_nr(CHAN_TYPE));
printf("unknown CHAN_TYPE %s\n", _mesa_lookup_enum_by_nr(CHAN_TYPE));
return GL_FALSE;
}
break;
default:
_mesa_printf("unknown a[%d].format %d\n", j, a->format);
printf("unknown a[%d].format %d\n", j, a->format);
return GL_FALSE; /* catch any new opcodes */
}

2
src/mesa/x86/rtasm/x86sse.c
View file

@ -1184,7 +1184,7 @@ void x86_release_func( struct x86_function *p )
void (*x86_get_func( struct x86_function *p ))(void)
{
if (DISASSEM && p->store)
_mesa_printf("disassemble %p %p\n", p->store, p->csr);
printf("disassemble %p %p\n", p->store, p->csr);
return (void (*)(void)) (unsigned long) p->store;
}