X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fgldecoder.c;h=6444fcaac8515b5054f7ea97a09ce354f6577f1b;hb=498c37732c8849b49819c6b64fe42256ca7f6e04;hp=93a525876c64c4b033bb92cd6f770239fcbc2dd9;hpb=9d1825d591a7261b1cff620ba535d333352984bf;p=gldbg.git

diff --git a/source/gldecoder.c b/source/gldecoder.c
index 93a5258..6444fca 100644
--- a/source/gldecoder.c
+++ b/source/gldecoder.c
@@ -9,6 +9,19 @@ Distributed under the GPL
 #include <string.h>
 #include "functions.h"
 #include "gldecoder.h"
+#include "tmpalloc.h"
+
+typedef struct sGlPacket
+{
+	const char *ptr;
+	unsigned chunk;
+	unsigned total;
+} GlPacket;
+
+static void read_short(short *, GlPacket *);
+static void read_int(int *, GlPacket *);
+static int decode_func(GlDecoder *, unsigned short, GlPacket *);
+static int decode_gldfunc(GlDecoder *, unsigned short, GlPacket *);
 
 GlDecoder *gldecoder_new(void *user_data, void (*destroy)(void *))
 {
@@ -29,72 +42,178 @@ void gldecoder_delete(GlDecoder *dec)
 	free(dec);
 }
 
-unsigned read_char(char *v, const char *data, unsigned len)
+int gldecoder_decode(GlDecoder *dec, const char *data, unsigned len)
+{
+	unsigned short func;
+	GlPacket packet;
+
+	if(len<sizeof(int)+sizeof(short))
+		return -1;
+
+	packet.ptr = data;
+	packet.chunk = len;
+	read_int((int *)&packet.chunk, &packet);
+
+	if(packet.chunk&0x80000000)
+	{
+		packet.chunk &= 0x7FFFFFFF;
+		packet.total = packet.chunk;
+
+		while(1)
+		{
+			if(len<packet.total+sizeof(int))
+				return -1;
+
+			GlPacket p = { packet.ptr+packet.total, len-packet.total, 0 };
+			unsigned chunk;
+			read_int((int *)&chunk, &p);
+			packet.total += chunk&0x7FFFFFFF;
+			if(!(chunk&0x80000000))
+				break;
+		}
+	}
+	else
+		packet.total = packet.chunk;
+
+	if(len<packet.total)
+		return -1;
+
+	read_short((short *)&func, &packet);
+
+	if(dec)
+	{
+		int ret = 0;
+
+		if(func&0x8000)
+			ret = decode_gldfunc(dec, func, &packet);
+		else
+			ret = decode_func(dec, func, &packet);
+		if(ret<0)
+			return -1;
+	}
+
+	return packet.ptr+packet.total-data;
+}
+
+static void next_chunk(GlPacket *pkt)
 {
-	*v = *data;
-	return 1;
+	if(pkt->total==0)
+		return;
+	pkt->chunk = pkt->total;
+	read_int((int *)&pkt->chunk, pkt);
+	pkt->chunk &= 0x7FFFFFFF;
 }
 
-unsigned read_short(short *v, const char *data, unsigned len)
+static void read_generic(void *v, unsigned size, int byteswap, GlPacket *pkt)
 {
-	*v = *(short *)data;
-	return sizeof(short);
+	if(pkt->chunk==0)
+		next_chunk(pkt);
+
+	if(pkt->chunk>=size)
+	{
+		// TODO: Actually implement byteswap if needed
+		(void)byteswap;
+		memcpy(v, pkt->ptr, size);
+		pkt->ptr += size;
+		pkt->chunk -= size;
+		pkt->total -= size;
+	}
+	else
+	{
+		memset(v, 0, size);
+		pkt->total -= pkt->chunk;
+		pkt->chunk = 0;
+	}
 }
 
-unsigned read_int(int *v, const char *data, unsigned len)
+static void read_char(char *v, GlPacket *pkt)
 {
-	*v = *(int *)data;
-	return sizeof(int);
+	read_generic(v, 1, 0, pkt);
 }
 
-unsigned read_long(long *v, const char *data, unsigned len)
+static void read_short(short *v, GlPacket *pkt)
 {
-	*v = *(long *)data;
-	return sizeof(long);
+	read_generic(v, sizeof(short), 1, pkt);
 }
 
-unsigned read_ulong(unsigned long *v, const char *data, unsigned len)
+static void read_int(int *v, GlPacket *pkt)
 {
-	*v = *(unsigned long *)data;
-	return sizeof(unsigned long);
+	read_generic(v, sizeof(int), 1, pkt);
 }
 
-unsigned read_longlong(long long *v, const char *data, unsigned len)
+static void read_long(long *v, GlPacket *pkt)
 {
-	*v = *(long long *)data;
-	return sizeof(long long);
+	read_generic(v, sizeof(long), 1, pkt);
 }
 
-unsigned read_float(float *v, const char *data, unsigned len)
+static void read_long_long(long long *v, GlPacket *pkt)
 {
-	*v = *(float *)data;
-	return sizeof(float);
+	read_generic(v, sizeof(long long), 1, pkt);
 }
 
-unsigned read_double(double *v, const char *data, unsigned len)
+static void read_float(float *v, GlPacket *pkt)
 {
-	*v = *(double *)data;
-	return sizeof(double);
+	read_generic(v, sizeof(float), 1, pkt);
 }
 
-unsigned read_pointer(void **v, const char *data, unsigned len)
+static void read_double(double *v, GlPacket *pkt)
+{
+	read_generic(v, sizeof(double), 1, pkt);
+}
+
+typedef const void *pointer;
+
+static void read_pointer(pointer *v, GlPacket *pkt)
 {
-	*v = *(void **)data;
-	return sizeof(void *);
+	read_generic(v, sizeof(pointer), 1, pkt);
 }
 
-unsigned read_data(const void **v, const char *data, unsigned len)
+static void read_data(pointer *v, GlPacket *pkt)
 {
 	int vlen;
-	unsigned pos = 0;
-	pos += read_int(&vlen, data, len);
-	*v = data+pos;
-	return pos+vlen;
+	read_int(&vlen, pkt);
+	if(vlen)
+		*v = pkt->ptr;
+	else
+		*v = NULL;
+	pkt->ptr += vlen;
+	pkt->chunk -= vlen;
+	pkt->total -= vlen;
 }
 
-unsigned read_string(const unsigned char **v, const char *data, unsigned len)
+typedef const char *string;
+
+static void read_string(string *v, GlPacket *pkt)
+{
+	read_data((pointer *)v, pkt);
+}
+
+static void read_string_array(string **v, GlPacket *pkt)
+{
+	int count;
+	int i;
+	read_int(&count, pkt);
+	*v = (string *)tmpalloc(count*sizeof(string));
+	for(i=0; i<count; ++i)
+		read_string(*v+i, pkt);
+}
+
+#include "gensrc/gldecoder.funcs"
+
+static void decode_gldError(GlDecoder *dec, GlPacket *pkt)
 {
-	return read_data((const void **)v, data, len);
+	GLenum code;
+	read_int((int *)&code, pkt);
+	if(dec->gldError)
+		dec->gldError(dec->user_data, code);
 }
 
-#include "gldecoder.funcs"
+static int decode_gldfunc(GlDecoder *dec, unsigned short func, GlPacket *pkt)
+{
+	switch(func)
+	{
+	case FUNC_GLDERROR: decode_gldError(dec, pkt); break;
+	default: return -1;
+	}
+	return 0;
+}