git.sur5r.net Git - cc65/blob - src/ar65/fileio.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                 fileio.c                                  */
   4 /*                                                                           */
   5 /*                      File I/O for the ar65 archiver                       */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 1998-2003 Ullrich von Bassewitz                                       */
  10 /*               Römerstrasse 52                                             */
  11 /*               D-70794 Filderstadt                                         */
  12 /* EMail:        uz@cc65.org                                                 */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include <string.h>
  37
  38 /* common */
  39 #include "xmalloc.h"
  40
  41 /* ar65 */
  42 #include "error.h"
  43 #include "fileio.h"
  44
  45
  46
  47 /*****************************************************************************/
  48 /*                                   Code                                    */
  49 /*****************************************************************************/
  50
  51
  52
  53 void Write8 (FILE* F, unsigned char Val)
  54 /* Write an 8 bit value to the file */
  55 {
  56     if (putc (Val, F) == EOF) {
  57         Error ("Write error (disk full?)");
  58     }
  59 }
  60
  61
  62
  63 void Write16 (FILE* F, unsigned Val)
  64 /* Write a 16 bit value to the file */
  65 {
  66     Write8 (F, (unsigned char) Val);
  67     Write8 (F, (unsigned char) (Val >> 8));
  68 }
  69
  70
  71
  72 void Write32 (FILE* F, unsigned long Val)
  73 /* Write a 32 bit value to the file */
  74 {
  75     Write8 (F, (unsigned char) Val);
  76     Write8 (F, (unsigned char) (Val >> 8));
  77     Write8 (F, (unsigned char) (Val >> 16));
  78     Write8 (F, (unsigned char) (Val >> 24));
  79 }
  80
  81
  82
  83 void WriteVar (FILE* F, unsigned long V)
  84 /* Write a variable sized value to the file in special encoding */
  85 {
  86     /* We will write the value to the file in 7 bit chunks. If the 8th bit
  87      * is clear, we're done, if it is set, another chunk follows. This will
  88      * allow us to encode smaller values with less bytes, at the expense of
  89      * needing 5 bytes if a 32 bit value is written to file.
  90      */
  91     do {
  92         unsigned char C = (V & 0x7F);
  93         V >>= 7;
  94         if (V) {
  95             C |= 0x80;
  96         }
  97         Write8 (F, C);
  98     } while (V != 0);
  99 }
 100
 101
 102
 103 void WriteStr (FILE* F, const char* S)
 104 /* Write a string to the file */
 105 {
 106     unsigned Len = strlen (S);
 107     WriteVar (F, Len);
 108     WriteData (F, S, Len);
 109 }
 110
 111
 112
 113 void WriteData (FILE* F, const void* Data, unsigned Size)
 114 /* Write data to the file */
 115 {
 116     if (fwrite (Data, 1, Size, F) != Size) {
 117         Error ("Write error (disk full?)");
 118     }
 119 }
 120
 121
 122
 123 unsigned Read8 (FILE* F)
 124 /* Read an 8 bit value from the file */
 125 {
 126     int C = getc (F);
 127     if (C == EOF) {
 128         Error ("Read error (file corrupt?)");
 129     }
 130     return C;
 131 }
 132
 133
 134
 135 unsigned Read16 (FILE* F)
 136 /* Read a 16 bit value from the file */
 137 {
 138     unsigned Lo = Read8 (F);
 139     unsigned Hi = Read8 (F);
 140     return (Hi << 8) | Lo;
 141 }
 142
 143
 144
 145 unsigned long Read32 (FILE* F)
 146 /* Read a 32 bit value from the file */
 147 {
 148     unsigned long Lo = Read16 (F);
 149     unsigned long Hi = Read16 (F);
 150     return (Hi << 16) | Lo;
 151 }
 152
 153
 154
 155 unsigned long ReadVar (FILE* F)
 156 /* Read a variable size value from the file */
 157 {
 158     /* The value was written to the file in 7 bit chunks LSB first. If there
 159      * are more bytes, bit 8 is set, otherwise it is clear.
 160      */
 161     unsigned char C;
 162     unsigned long V = 0;
 163     unsigned Shift = 0;
 164     do {
 165         /* Read one byte */
 166         C = Read8 (F);
 167         /* Encode it into the target value */
 168         V |= ((unsigned long)(C & 0x7F)) << Shift;
 169         /* Next value */
 170         Shift += 7;
 171     } while (C & 0x80);
 172
 173     /* Return the value read */
 174     return V;
 175 }
 176
 177
 178
 179 char* ReadStr (FILE* F)
 180 /* Read a string from the file (the memory will be malloc'ed) */
 181 {
 182     /* Read the length */
 183     unsigned Len = ReadVar (F);
 184
 185     /* Allocate memory and read the string itself */
 186     char* S = xmalloc (Len + 1);
 187     ReadData (F, S, Len);
 188
 189     /* Terminate the string and return it */
 190     S [Len] = '\0';
 191     return S;
 192 }
 193
 194
 195
 196 void* ReadData (FILE* F, void* Data, unsigned Size)
 197 /* Read data from the file */
 198 {
 199     if (fread (Data, 1, Size, F) != Size) {
 200         Error ("Read error (file corrupt?)");
 201     }
 202     return Data;
 203 }
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254