Source/pack_private.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 "pack_private.h"
  23
  24 void BinIOPack(void *context, int type, int byte_order, int count)
  25 {
  26     struct BinIOPackContext *ctx = (struct BinIOPackContext*)context;
  27     if (count == -1)
  28     {
  29         switch (type)
  30         {
  31             case BinIO_TYPE_IGNORE_BYTE:
  32                 {
  33                     ctx->buffer += 1;
  34                 }
  35                 break;
  36             case BinIO_TYPE_BYTE:
  37                 {
  38                     uint8_t value = va_arg(ctx->args, int);
  39                     BinIOConvert1(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  40                     ctx->buffer += 1;
  41                 }
  42                 break;
  43             case BinIO_TYPE_INT16:
  44                 {
  45                     uint16_t value = va_arg(ctx->args, int);
  46                     BinIOConvert2(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  47                     ctx->buffer += 2;
  48                 }
  49                 break;
  50             case BinIO_TYPE_INT32:
  51                 {
  52                     int value = va_arg(ctx->args, int);
  53                     BinIOConvert4(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  54                     ctx->buffer += 4;
  55                 }
  56                 break;
  57             case BinIO_TYPE_INT64:
  58                 {
  59                     uint64_t value = va_arg(ctx->args, uint64_t);
  60                     BinIOConvert8(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  61                     ctx->buffer += 8;
  62                 }
  63                 break;
  64             case BinIO_TYPE_FLOAT32:
  65                 {
  66                     float32_t value = (float32_t)va_arg(ctx->args, double);
  67                     BinIOConvert4(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  68                     ctx->buffer += 4;
  69                 }
  70                 break;
  71             case BinIO_TYPE_FLOAT64:
  72                 {
  73                     float64_t value = va_arg(ctx->args, float64_t);
  74                     BinIOConvert8(BinIO_HOST_BYTE_ORDER, byte_order, (const uint8_t *)&value, ctx->buffer, 1);
  75                     ctx->buffer += 8;
  76                 }
  77                 break;
  78         }
  79     }
  80     else
  81     {
  82         switch (type)
  83         {
  84             case BinIO_TYPE_IGNORE_BYTE:                                                                                                     ctx->buffer += 1 * count; break;
  85             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;
  86             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;
  87             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;
  88             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;
  89             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;
  90             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;
  91         }
  92     }
  93 }