#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "glxserver.h"
#include "glxutil.h"
#include "glxext.h"
#include "indirect_dispatch.h"
#include "unpack.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
int __glXDisp_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
{
GLsizei size;
GLenum type;
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
size = *(GLsizei *)(pc+0);
type = *(GLenum *)(pc+4);
if (cx->feedbackBufSize < size) {
cx->feedbackBuf = (GLfloat *) realloc(cx->feedbackBuf,
(size_t)size
* __GLX_SIZE_FLOAT32);
if (!cx->feedbackBuf) {
cl->client->errorValue = size;
return BadAlloc;
}
cx->feedbackBufSize = size;
}
CALL_FeedbackBuffer( GET_DISPATCH(), (size, type, cx->feedbackBuf) );
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
int __glXDisp_SelectBuffer(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
GLsizei size;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
size = *(GLsizei *)(pc+0);
if (cx->selectBufSize < size) {
cx->selectBuf = (GLuint *) realloc(cx->selectBuf,
(size_t) size
* __GLX_SIZE_CARD32);
if (!cx->selectBuf) {
cl->client->errorValue = size;
return BadAlloc;
}
cx->selectBufSize = size;
}
CALL_SelectBuffer( GET_DISPATCH(), (size, cx->selectBuf) );
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
int __glXDisp_RenderMode(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client;
xGLXRenderModeReply reply;
__GLXcontext *cx;
GLint nitems=0, retBytes=0, retval, newModeCheck;
GLubyte *retBuffer = NULL;
GLenum newMode;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
newMode = *(GLenum*) pc;
retval = CALL_RenderMode( GET_DISPATCH(), (newMode) );
CALL_GetIntegerv( GET_DISPATCH(), (GL_RENDER_MODE, &newModeCheck) );
if (newModeCheck != newMode) {
newMode = newModeCheck;
goto noChangeAllowed;
}
switch (cx->renderMode) {
case GL_RENDER:
cx->renderMode = newMode;
break;
case GL_FEEDBACK:
if (retval < 0) {
nitems = cx->feedbackBufSize;
} else {
nitems = retval;
}
retBytes = nitems * __GLX_SIZE_FLOAT32;
retBuffer = (GLubyte*) cx->feedbackBuf;
cx->renderMode = newMode;
break;
case GL_SELECT:
if (retval < 0) {
nitems = cx->selectBufSize;
} else {
GLuint *bp = cx->selectBuf;
GLint i;
nitems = 0;
i = retval;
while (--i >= 0) {
GLuint n;
n = *bp;
bp += 3 + n;
}
nitems = bp - cx->selectBuf;
}
retBytes = nitems * __GLX_SIZE_CARD32;
retBuffer = (GLubyte*) cx->selectBuf;
cx->renderMode = newMode;
break;
}
noChangeAllowed:;
client = cl->client;
reply.length = nitems;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
reply.retval = retval;
reply.size = nitems;
reply.newMode = newMode;
WriteToClient(client, sz_xGLXRenderModeReply, (char *)&reply);
if (retBytes) {
WriteToClient(client, retBytes, (char *)retBuffer);
}
return Success;
}
int __glXDisp_Flush(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
CALL_Flush( GET_DISPATCH(), () );
__GLX_NOTE_FLUSHED_CMDS(cx);
return Success;
}
int __glXDisp_Finish(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
ClientPtr client;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
CALL_Finish( GET_DISPATCH(), () );
__GLX_NOTE_FLUSHED_CMDS(cx);
client = cl->client;
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
return Success;
}
#define SEPARATOR " "
char *__glXcombine_strings(const char *cext_string, const char *sext_string)
{
size_t clen, slen;
char *combo_string, *token, *s1;
const char *s2, *end;
if (!cext_string)
cext_string = "";
if (!sext_string)
sext_string = "";
clen = strlen(cext_string);
slen = strlen(sext_string);
if (clen > slen) {
combo_string = (char *) malloc(slen + 2);
s1 = (char *) malloc(slen + 2);
if (s1) strcpy(s1, sext_string);
s2 = cext_string;
} else {
combo_string = (char *) malloc(clen + 2);
s1 = (char *) malloc(clen + 2);
if (s1) strcpy(s1, cext_string);
s2 = sext_string;
}
if (!combo_string || !s1) {
free(combo_string);
free(s1);
return NULL;
}
combo_string[0] = '\0';
token = strtok( s1, SEPARATOR);
while ( token != NULL ) {
const char *p = s2;
end = p + strlen(p);
while (p < end) {
size_t n = strcspn(p, SEPARATOR);
if ((strlen(token) == n) && (strncmp(token, p, n) == 0)) {
combo_string = strcat(combo_string, token);
combo_string = strcat(combo_string, SEPARATOR);
}
p += (n + 1);
}
token = strtok( NULL, SEPARATOR);
}
free(s1);
return combo_string;
}
int DoGetString(__GLXclientState *cl, GLbyte *pc, GLboolean need_swap)
{
ClientPtr client;
__GLXcontext *cx;
GLenum name;
const char *string;
__GLX_DECLARE_SWAP_VARIABLES;
int error;
char *buf = NULL, *buf1 = NULL;
GLint length = 0;
if ( need_swap ) {
__GLX_SWAP_INT(pc + 4);
__GLX_SWAP_INT(pc + __GLX_SINGLE_HDR_SIZE);
}
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
name = *(GLenum *)(pc + 0);
string = (const char *) CALL_GetString( GET_DISPATCH(), (name) );
client = cl->client;
if (string == NULL)
string = "";
if (name == GL_EXTENSIONS) {
buf1 = __glXcombine_strings(string,
cl->GLClientextensions);
buf = __glXcombine_strings(buf1,
cx->pGlxScreen->GLextensions);
free(buf1);
string = buf;
}
else if ( name == GL_VERSION ) {
if ( atof( string ) > atof( GLServerVersion ) ) {
buf = malloc( strlen( string ) + strlen( GLServerVersion ) + 4 );
if ( buf == NULL ) {
string = GLServerVersion;
}
else {
sprintf( buf, "%s (%s)", GLServerVersion, string );
string = buf;
}
}
}
if (string) {
length = strlen((const char *) string) + 1;
}
__GLX_BEGIN_REPLY(length);
__GLX_PUT_SIZE(length);
if ( need_swap ) {
__GLX_SWAP_REPLY_SIZE();
__GLX_SWAP_REPLY_HEADER();
}
__GLX_SEND_HEADER();
WriteToClient(client, length, (char *) string);
free(buf);
return Success;
}
int __glXDisp_GetString(__GLXclientState *cl, GLbyte *pc)
{
return DoGetString(cl, pc, GL_FALSE);
}