source/glprint.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <ctype.h>
   5 #include "arraysize.h"
   6 #include "enums.h"
   7 #include "glprint.h"
   8 #include "tmpalloc.h"
   9
  10 #define UNUSED __attribute__((unused))
  11
  12 typedef struct sGlPrintData
  13 {
  14         char *buffer;
  15         unsigned bufsize;
  16         int free_buf;
  17 } GlPrintData;
  18
  19 static void init_print(GlDecoder *);
  20 static void glprint_free(void *);
  21 static void print_gldError(void *, GLenum);
  22 static void print_unhandled(void *, unsigned short);
  23
  24 GlDecoder *glprint_new(char *buffer, unsigned bufsize)
  25 {
  26         GlDecoder *dec;
  27         GlPrintData *gpd;
  28
  29         gpd = (GlPrintData *)malloc(sizeof(GlPrintData));
  30         gpd->buffer = buffer;
  31         gpd->bufsize = bufsize;
  32         gpd->free_buf = 0;
  33         if(!gpd->buffer)
  34         {
  35                 if(!gpd->bufsize)
  36                         gpd->bufsize = 1024;
  37                 gpd->buffer = (char *)malloc(gpd->bufsize);
  38                 gpd->free_buf = 1;
  39         }
  40         dec = gldecoder_new(gpd, glprint_free);
  41
  42         init_print(dec);
  43         dec->gldError = print_gldError;
  44         dec->unhandled = print_unhandled;
  45
  46         return dec;
  47 }
  48
  49 char *glprint_get_buffer(GlDecoder *dec)
  50 {
  51         return ((GlPrintData *)dec->user_data)->buffer;
  52 }
  53
  54 static void glprint_free(void *data)
  55 {
  56         GlPrintData *gpd = (GlPrintData *)data;
  57         if(gpd->free_buf)
  58         {
  59                 free(gpd->buffer);
  60                 free(gpd);
  61         }
  62         tmpfree();
  63 }
  64
  65 static const char *print_array(const char *fmt, const void *data, unsigned elem_size, unsigned count)
  66 {
  67         const char *cptr;
  68         char type = 0;
  69         char *buffer;
  70         unsigned buf_size;
  71         char *ptr;
  72         unsigned i;
  73
  74         if(!data)
  75                 return "NULL";
  76
  77         for(cptr=fmt; (type<2 && *cptr); ++cptr)
  78         {
  79                 if(*cptr=='%')
  80                         type = 1;
  81                 else if(type==1 && isalpha(*cptr))
  82                         type = *cptr;
  83         }
  84
  85         count /= elem_size;
  86         buf_size = count*20;
  87         if(type=='s')
  88                 buf_size *= 50;
  89         buffer = tmpalloc(buf_size);
  90         ptr = buffer;
  91         *ptr++ = '{';
  92         for(i=0; i<count; ++i)
  93         {
  94                 long long element = 0;
  95                 unsigned len;
  96
  97                 if(i>0)
  98                 {
  99                         *ptr++ = ',';
 100                         *ptr++ = ' ';
 101                 }
 102                 memcpy(&element, (const char *)data+i*elem_size, elem_size);
 103                 if(type>='e' && type<='g')
 104                 {
 105                         if(elem_size==sizeof(float))
 106                                 *(double *)&element = *(float *)&element;
 107                         len = snprintf(ptr, buf_size, fmt, *(double *)&element);
 108                 }
 109                 else
 110                         len = snprintf(ptr, buf_size, fmt, element);
 111                 ptr += len;
 112                 buf_size -= len;
 113         }
 114         *ptr++ = '}';
 115         *ptr = 0;
 116
 117         return buffer;
 118 }
 119
 120 static const char *print_array_described(const char *(*describe)(GLenum, const char *), const char *categ, const void *data, unsigned elem_size, unsigned count)
 121 {
 122         char *buffer;
 123         unsigned buf_size;
 124         char *ptr;
 125         unsigned i;
 126
 127         if(!data)
 128                 return NULL;
 129
 130         count /= elem_size;
 131         buf_size = count*50;
 132         buffer = tmpalloc(buf_size);
 133         ptr = buffer;
 134         *ptr++ = '{';
 135         for(i=0; i<count; ++i)
 136         {
 137                 int element = 0;
 138                 unsigned len;
 139
 140                 if(i>0)
 141                 {
 142                         *ptr++ = ',';
 143                         *ptr++ = ' ';
 144                 }
 145                 memcpy(&element, (const char *)data+i*elem_size, elem_size);
 146                 len = snprintf(ptr, buf_size, "%s", describe(element, categ));
 147                 ptr += len;
 148                 buf_size -= len;
 149         }
 150         *ptr++ = '}';
 151         *ptr = 0;
 152
 153         return buffer;
 154 }
 155
 156 static const char *print_parameter(int pname, int param)
 157 {
 158         char *buffer;
 159
 160         // XXX Need to move the param names to flavor
 161         switch(pname)
 162         {
 163         case GL_TEXTURE_MIN_FILTER:
 164         case GL_TEXTURE_MAG_FILTER:
 165         case GL_TEXTURE_WRAP_S:
 166         case GL_TEXTURE_WRAP_T:
 167                 return describe_enum(param, "");
 168         }
 169
 170         buffer = tmpalloc(11);
 171         snprintf(buffer, 11, "%i", param);
 172         return buffer;
 173 }
 174
 175 static const char *print_internal_format(int fmt)
 176 {
 177         char *buffer;
 178
 179         if(fmt>4)
 180                 return describe_enum(fmt, "PixelFormat");
 181
 182         buffer = tmpalloc(2);
 183         snprintf(buffer, 2, "%i", fmt);
 184         return buffer;
 185 }
 186
 187 static const char *print_data(const void *data, unsigned size)
 188 {
 189         if(!data)
 190                 return "NULL";
 191         else if((unsigned long)data<0x100000)
 192         {
 193                 char *buffer = tmpalloc(20);
 194                 snprintf(buffer, 20, "%p", data);
 195                 return buffer;
 196         }
 197         else if(!size)
 198                 return "/* data */";
 199         else
 200         {
 201                 char *buffer = tmpalloc(50);
 202                 snprintf(buffer, 50, "/* data: %d bytes */", size);
 203                 return buffer;
 204         }
 205 }
 206
 207 #include "gensrc/glprint.funcs"
 208
 209 static void print_gldError(void *user_data, GLenum code)
 210 {
 211         GlPrintData *gpd = (GlPrintData *)user_data;
 212         snprintf(gpd->buffer, gpd->bufsize, "ERROR: %s", describe_enum(code, "ErrorCode"));
 213 }
 214
 215 static void print_unhandled(void *user_data, unsigned short func UNUSED)
 216 {
 217         GlPrintData *gpd = (GlPrintData *)user_data;
 218         gpd->buffer[0] = 0;
 219 }