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' && elem_size==sizeof(float))
 104                         *(double *)&element = *(float *)&element;
 105                 len = snprintf(ptr, buf_size, fmt, element);
 106                 ptr += len;
 107                 buf_size -= len;
 108         }
 109         *ptr++ = '}';
 110         *ptr = 0;
 111
 112         return buffer;
 113 }
 114
 115 static const char *print_array_described(const char *(*describe)(GLenum, const char *), const char *categ, const void *data, unsigned elem_size, unsigned count)
 116 {
 117         char *buffer;
 118         unsigned buf_size;
 119         char *ptr;
 120         unsigned i;
 121
 122         if(!data)
 123                 return NULL;
 124
 125         count /= elem_size;
 126         buf_size = count*50;
 127         buffer = tmpalloc(buf_size);
 128         ptr = buffer;
 129         *ptr++ = '{';
 130         for(i=0; i<count; ++i)
 131         {
 132                 int element = 0;
 133                 unsigned len;
 134
 135                 if(i>0)
 136                 {
 137                         *ptr++ = ',';
 138                         *ptr++ = ' ';
 139                 }
 140                 memcpy(&element, (const char *)data+i*elem_size, elem_size);
 141                 len = snprintf(ptr, buf_size, "%s", describe(element, categ));
 142                 ptr += len;
 143                 buf_size -= len;
 144         }
 145         *ptr++ = '}';
 146         *ptr = 0;
 147
 148         return buffer;
 149 }
 150
 151 static const char *print_parameter(int pname, int param)
 152 {
 153         char *buffer;
 154
 155         // XXX Need to move the param names to flavor
 156         switch(pname)
 157         {
 158         case GL_TEXTURE_MIN_FILTER:
 159         case GL_TEXTURE_MAG_FILTER:
 160         case GL_TEXTURE_WRAP_S:
 161         case GL_TEXTURE_WRAP_T:
 162                 return describe_enum(param, "");
 163         }
 164
 165         buffer = tmpalloc(11);
 166         snprintf(buffer, 11, "%i", param);
 167         return buffer;
 168 }
 169
 170 static const char *print_internal_format(int fmt)
 171 {
 172         char *buffer;
 173
 174         if(fmt>4)
 175                 return describe_enum(fmt, "PixelFormat");
 176
 177         buffer = tmpalloc(2);
 178         snprintf(buffer, 2, "%i", fmt);
 179         return buffer;
 180 }
 181
 182 static const char *print_data(const void *data, unsigned size)
 183 {
 184         if(!data)
 185                 return "NULL";
 186         else if((unsigned long)data<0x100000)
 187         {
 188                 char *buffer = tmpalloc(20);
 189                 snprintf(buffer, 20, "%p", data);
 190                 return buffer;
 191         }
 192         else if(!size)
 193                 return "/* data */";
 194         else
 195         {
 196                 char *buffer = tmpalloc(50);
 197                 snprintf(buffer, 50, "/* data: %d bytes */", size);
 198                 return buffer;
 199         }
 200 }
 201
 202 #include "gensrc/glprint.funcs"
 203
 204 static void print_gldError(void *user_data, GLenum code)
 205 {
 206         GlPrintData *gpd = (GlPrintData *)user_data;
 207         snprintf(gpd->buffer, gpd->bufsize, "ERROR: %s", describe_enum(code, "ErrorCode"));
 208 }
 209
 210 static void print_unhandled(void *user_data, unsigned short func UNUSED)
 211 {
 212         GlPrintData *gpd = (GlPrintData *)user_data;
 213         gpd->buffer[0] = 0;
 214 }