source/glprint.c

   1 /* $Id$
   2
   3 This file is part of gldbg
   4 Copyright © 2009  Mikko Rasa, Mikkosoft Productions
   5 Distributed under the GPL
   6 */
   7
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <ctype.h>
  12 #include "arraysize.h"
  13 #include "enums.h"
  14 #include "glprint.h"
  15 #include "tmpalloc.h"
  16
  17 typedef struct sGlPrintData
  18 {
  19         char *buffer;
  20         unsigned bufsize;
  21         int free_buf;
  22 } GlPrintData;
  23
  24 static void init_print(GlDecoder *);
  25 static void glprint_free(void *);
  26 static void print_gldError(void *, GLenum);
  27 static void print_unhandled(void *, unsigned short);
  28
  29 GlDecoder *glprint_new(char *buffer, unsigned bufsize)
  30 {
  31         GlDecoder *dec;
  32         GlPrintData *gpd;
  33
  34         gpd = (GlPrintData *)malloc(sizeof(GlPrintData));
  35         gpd->buffer = buffer;
  36         gpd->bufsize = bufsize;
  37         gpd->free_buf = 0;
  38         if(!gpd->buffer)
  39         {
  40                 if(!gpd->bufsize)
  41                         gpd->bufsize = 1024;
  42                 gpd->buffer = (char *)malloc(gpd->bufsize);
  43                 gpd->free_buf = 1;
  44         }
  45         dec = gldecoder_new(gpd, glprint_free);
  46
  47         init_print(dec);
  48         dec->gldError = print_gldError;
  49         dec->unhandled = print_unhandled;
  50
  51         return dec;
  52 }
  53
  54 char *glprint_get_buffer(GlDecoder *dec)
  55 {
  56         return ((GlPrintData *)dec->user_data)->buffer;
  57 }
  58
  59 static void glprint_free(void *data)
  60 {
  61         GlPrintData *gpd = (GlPrintData *)data;
  62         if(gpd->free_buf)
  63         {
  64                 free(gpd->buffer);
  65                 free(gpd);
  66         }
  67         tmpfree();
  68 }
  69
  70 static const char *print_array(const char *fmt, const void *data, unsigned elem_size, unsigned count)
  71 {
  72         const char *cptr;
  73         char type = 0;
  74         char *buffer;
  75         unsigned buf_size;
  76         char *ptr;
  77         unsigned i;
  78
  79         if(!data)
  80                 return "NULL";
  81
  82         for(cptr=fmt; (type<2 && *cptr); ++cptr)
  83         {
  84                 if(*cptr=='%')
  85                         type = 1;
  86                 else if(type==1 && isalpha(*cptr))
  87                         type = *cptr;
  88         }
  89
  90         count /= elem_size;
  91         buf_size = count*20;
  92         if(type=='s')
  93                 buf_size *= 50;
  94         buffer = tmpalloc(buf_size);
  95         ptr = buffer;
  96         *ptr++ = '{';
  97         for(i=0; i<count; ++i)
  98         {
  99                 long long element = 0;
 100                 unsigned len;
 101
 102                 if(i>0)
 103                 {
 104                         *ptr++ = ',';
 105                         *ptr++ = ' ';
 106                 }
 107                 memcpy(&element, (const char *)data+i*elem_size, elem_size);
 108                 if(type>='e' && type<='g' && elem_size==sizeof(float))
 109                         *(double *)&element = *(float *)&element;
 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_data(const void *data, unsigned size)
 121 {
 122         if(!data)
 123                 return "NULL";
 124         else if(!size)
 125                 return "/* data */";
 126         else
 127         {
 128                 char *buffer = tmpalloc(50);
 129                 snprintf(buffer, 50, "/* data: %d bytes */", size);
 130                 return buffer;
 131         }
 132 }
 133
 134 #include "gensrc/glprint.funcs"
 135
 136 static void print_gldError(void *user_data, GLenum code)
 137 {
 138         GlPrintData *gpd = (GlPrintData *)user_data;
 139         snprintf(gpd->buffer, gpd->bufsize, "ERROR: %s", describe_enum(code, "ErrorCode"));
 140 }
 141
 142 static void print_unhandled(void *user_data, unsigned short func)
 143 {
 144         GlPrintData *gpd = (GlPrintData *)user_data;
 145         gpd->buffer[0] = 0;
 146 }