plomlompom.com Git - plomrogue/blob - src/readwrite.c

   1 /* readwrite.c */
   2
   3 #include "readwrite.h"
   4 #include <stdio.h> /* for FILE typedef*/
   5 #include <stdint.h> /* for uint16_t, uint32_t */
   6
   7
   8
   9 /* Read/write "x" from/to "file" as bigendian representation of "size" bits.
  10  * Only multiples of 8 allowed for "size". On failure, return 1, else 0.
  11  *
  12  * As of of now, all other read/write functions build on top of these. TODO:
  13  * Consider externing these so-far internal functions and dropping the
  14  * interfaces to them, instead relying on their internal validity checks.
  15  * (Usage of padded memory copies instead of directly manipulating * x as is
  16  * done in read_uint* would need to be added, though.)
  17  */
  18 static uint8_t read_uintX_bigendian(FILE * file, uint32_t * x, uint8_t size);
  19 static uint8_t write_uintX_bigendian(FILE * file, uint32_t x, uint8_t size);
  20
  21
  22
  23 static uint8_t read_uintX_bigendian(FILE * file, uint32_t * x, uint8_t size)
  24 {
  25     if (0 != size % 8)           /* This bit number validity check is redundant */
  26     {                            /* as long as this function is only available  */
  27         return 1;                /* through extern interfaces pre-defining the  */
  28     }                            /* bit number. TODO: Consider dropping it.     */
  29     int16_t bitshift = size - 8;
  30
  31     * x = 0;
  32     int test;
  33     for (; bitshift >= 0; bitshift = bitshift - 8)
  34     {
  35         test = fgetc(file);
  36         if (EOF == test)
  37         {
  38             return 1;
  39         }
  40         * x = * x + ((uint32_t) test << bitshift);
  41     }
  42     return 0;
  43 }
  44
  45
  46
  47 static uint8_t write_uintX_bigendian(FILE * file, uint32_t x, uint8_t size)
  48 {
  49     if (0 != size % 8)                             /* See comment             */
  50     {                                              /* on identical            */
  51         return 1;                                  /* code block in           */
  52     }                                              /* read_uintX_bigendian(). */
  53     int16_t bitshift = size - 8;
  54
  55     for (; bitshift >= 0; bitshift = bitshift - 8)
  56     {
  57         if (EOF == fputc((x >> bitshift) & 0xFF, file))
  58         {
  59             return 1;
  60         }
  61     }
  62     return 0;
  63 }
  64
  65
  66
  67 extern uint8_t read_uint8(FILE * file, uint8_t * x)
  68 {
  69     /* Since read_uintX_bigendian() works on -- and zeroes -- four bytes, direct
  70      * work on values of fewer bytes would corrupt immediate neighbor values.
  71      */
  72     uint32_t y = * x;
  73     uint8_t err = read_uintX_bigendian(file, &y, 8);
  74     * x = (uint8_t) y;
  75     return err;
  76 }
  77
  78
  79
  80 extern uint8_t read_uint16_bigendian(FILE * file, uint16_t * x)
  81 {
  82     /* See read_uint8() introductory comment for rationale. */
  83     uint32_t y = * x;
  84     uint8_t err = read_uintX_bigendian(file, &y, 16);
  85     * x = (uint16_t) y;
  86     return err;
  87 }
  88
  89
  90
  91 extern uint8_t read_uint32_bigendian(FILE * file, uint32_t * x)
  92 {
  93     return read_uintX_bigendian(file, x, 32);
  94 }
  95
  96
  97
  98 extern uint8_t write_uint8(uint8_t x, FILE * file)
  99 {
 100     return write_uintX_bigendian(file, x, 8);
 101 }
 102
 103
 104
 105 extern uint8_t write_uint16_bigendian(uint16_t x, FILE * file)
 106 {
 107     return write_uintX_bigendian(file, x, 16);
 108 }
 109
 110
 111
 112 extern uint8_t write_uint32_bigendian(uint32_t x, FILE * file)
 113 {
 114     return write_uintX_bigendian(file, x, 32);
 115 }