Source/pack.c

   1 /*
   2 Copyright (C) 2003, 2010 - Wolfire Games
   3
   4 This file is part of Lugaru.
   5
   6 Lugaru is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU General Public License
   8 as published by the Free Software Foundation; either version 2
   9 of the License, or (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14
  15 See the GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20 */
  21
  22 #include <stdlib.h>
  23
  24 #include "binio.h"
  25 #include "private.h"
  26
  27 struct BinIOPackContext
  28 {
  29     uint8_t *buffer;
  30     va_list  args;
  31 };
  32
  33 static void BinIOPack(void *context, int type, int byte_order, int count)
  34 {
  35     struct BinIOPackContext *ctx = (struct BinIOPackContext*)context;
  36     if (count == -1)
  37     {
  38         switch (type)
  39         {
  40             case BinIO_TYPE_IGNORE_BYTE:
  41                 {
  42                     ctx->buffer += 1;
  43                 }
  44                 break;
  45             case BinIO_TYPE_BYTE:
  46                 {
  47                     uint8_t value = va_arg(ctx->args, int);
  48                     BinIOConvert1(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  49                     ctx->buffer += 1;
  50                 }
  51                 break;
  52             case BinIO_TYPE_INT16:
  53                 {
  54                     uint16_t value = va_arg(ctx->args, int);
  55                     BinIOConvert2(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  56                     ctx->buffer += 2;
  57                 }
  58                 break;
  59             case BinIO_TYPE_INT32:
  60                 {
  61                     int value = va_arg(ctx->args, int);
  62                     BinIOConvert4(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  63                     ctx->buffer += 4;
  64                 }
  65                 break;
  66             case BinIO_TYPE_INT64:
  67                 {
  68                     uint64_t value = va_arg(ctx->args, uint64_t);
  69                     BinIOConvert8(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  70                     ctx->buffer += 8;
  71                 }
  72                 break;
  73             case BinIO_TYPE_FLOAT32:
  74                 {
  75                     float32_t value = (float32_t)va_arg(ctx->args, double);
  76                     BinIOConvert4(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  77                     ctx->buffer += 4;
  78                 }
  79                 break;
  80             case BinIO_TYPE_FLOAT64:
  81                 {
  82                     float64_t value = va_arg(ctx->args, float64_t);
  83                     BinIOConvert8(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  84                     ctx->buffer += 8;
  85                 }
  86                 break;
  87         }
  88     }
  89     else
  90     {
  91         switch (type)
  92         {
  93             case BinIO_TYPE_IGNORE_BYTE:                                                                                                     ctx->buffer += 1 * count; break;
  94             case BinIO_TYPE_BYTE:        BinIOConvert1(BinIO_HOST_BYTE_ORDER, byte_order, va_arg(ctx->args, uint8_t *), ctx->buffer, count); ctx->buffer += 1 * count; break;
  95             case BinIO_TYPE_INT16:       BinIOConvert2(BinIO_HOST_BYTE_ORDER, byte_order, va_arg(ctx->args, uint8_t *), ctx->buffer, count); ctx->buffer += 2 * count; break;
  96             case BinIO_TYPE_INT32:       BinIOConvert4(BinIO_HOST_BYTE_ORDER, byte_order, va_arg(ctx->args, uint8_t *), ctx->buffer, count); ctx->buffer += 4 * count; break;
  97             case BinIO_TYPE_INT64:       BinIOConvert8(BinIO_HOST_BYTE_ORDER, byte_order, va_arg(ctx->args, uint8_t *), ctx->buffer, count); ctx->buffer += 8 * count; break;
  98             case BinIO_TYPE_FLOAT32:     BinIOConvert4(BinIO_HOST_BYTE_ORDER, byte_order, va_arg(ctx->args, uint8_t *), ctx->buffer, count); ctx->buffer += 4 * count; break;
  99             case BinIO_TYPE_FLOAT64:     BinIOConvert8(BinIO_HOST_BYTE_ORDER, byte_order, va_arg(ctx->args, uint8_t *), ctx->buffer, count); ctx->buffer += 8 * count; break;
 100         }
 101     }
 102 }
 103
 104 extern void packf(const char *format, ...)
 105 {
 106     va_list args;
 107     va_start(args, format);
 108     vfpackf(stdout, format, args);
 109     va_end(args);
 110 }
 111
 112 extern void spackf(void *buffer, const char *format, ...)
 113 {
 114     va_list args;
 115     va_start(args, format);
 116     vspackf(buffer, format, args);
 117     va_end(args);
 118 }
 119
 120 extern void fpackf(FILE *file, const char *format, ...)
 121 {
 122     va_list args;
 123     va_start(args, format);
 124     vfpackf(file, format, args);
 125     va_end(args);
 126 }
 127
 128 extern void vspackf(void *buffer, const char *format, va_list args)
 129 {
 130     struct BinIOFormatCursor cursor;
 131     struct BinIOPackContext context;
 132
 133     BinIOInitFormatCursor(&cursor, format);
 134
 135     context.buffer = (unsigned char *)buffer;
 136     va_copy(context.args, args);
 137
 138     while (BinIONextChar(&context, &cursor, BinIOPack)) {}
 139
 140     va_end(context.args);
 141 }
 142
 143 extern void vfpackf(FILE *file, const char *format, va_list args)
 144 {
 145     size_t n_bytes = BinIOFormatByteCount(format);
 146     void* buffer = malloc(n_bytes);
 147
 148     vspackf(buffer, format, args);
 149
 150     fwrite(buffer, n_bytes, 1, file);
 151     free(buffer);
 152 }