include/lang/ReadWriteMacros.h

   1 /*
   2         SuperCollider real time audio synthesis system
   3         Copyright (c) 2002 James McCartney. All rights reserved.
   4         http://www.audiosynth.com
   5
   6         This program is free software; you can redistribute it and/or modify
   7         it under the terms of the GNU General Public License as published by
   8         the Free Software Foundation; either version 2 of the License, or
   9         (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.  See the
  14         GNU General Public License for more details.
  15
  16         You should have received a copy of the GNU General Public License
  17         along with this program; if not, write to the Free Software
  18         Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19 */
  20
  21
  22 #ifndef _ReadWriteMacros_
  23 #define _ReadWriteMacros_
  24
  25 #include "SC_Types.h"
  26 #include "SC_Endian.h"
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <stdexcept>
  30
  31 template <class T>
  32 class SC_IOStream
  33 {
  34 protected:
  35         T s;
  36 public:
  37         SC_IOStream() : s(0) {}
  38         SC_IOStream(T inStream) : s(inStream) {}
  39
  40         void SetStream(T inStream) { s = inStream; }
  41         T GetStream() { return s; }
  42
  43         // core routines
  44         void readData(char *data, size_t size);
  45         uint8 readUInt8();
  46
  47         void writeData(char *data, size_t size);
  48         void writeUInt8(uint8 inInt);
  49
  50         // built using core routines
  51         void writeInt8(int8 inInt)
  52         {
  53                 writeUInt8((uint8)inInt);
  54         }
  55
  56         void writeInt16_be(int16 inInt)
  57         {
  58                 writeUInt8((uint8)(inInt >> 8));
  59                 writeUInt8(inInt);
  60         }
  61
  62         void writeInt16_le(int16 inInt)
  63         {
  64                 writeUInt8((uint8)inInt);
  65                 writeUInt8((uint8)(inInt >> 8));
  66         }
  67
  68         void writeInt32_be(int32 inInt)
  69         {
  70                 writeUInt8((uint8)(inInt >> 24));
  71                 writeUInt8((uint8)(inInt >> 16));
  72                 writeUInt8((uint8)(inInt >> 8));
  73                 writeUInt8((uint8)inInt);
  74         }
  75
  76         void writeInt32_le(int32 inInt)
  77         {
  78                 writeUInt8((uint8)inInt);
  79                 writeUInt8((uint8)(inInt >> 8));
  80                 writeUInt8((uint8)(inInt >> 16));
  81                 writeUInt8((uint8)(inInt >> 24));
  82         }
  83
  84 #if BYTE_ORDER == BIG_ENDIAN
  85         void writeFloat_be(float inFloat)
  86 #else
  87         void writeFloat_le(float inFloat)
  88 #endif
  89         {
  90                 union {
  91                         float f;
  92                         uint8 c[4];
  93                 } u;
  94                 u.f = inFloat;
  95                 writeUInt8(u.c[0]);
  96                 writeUInt8(u.c[1]);
  97                 writeUInt8(u.c[2]);
  98                 writeUInt8(u.c[3]);
  99         }
 100
 101 #if BYTE_ORDER == BIG_ENDIAN
 102         void writeFloat_le(float inFloat)
 103 #else
 104         void writeFloat_be(float inFloat)
 105 #endif
 106         {
 107                 union {
 108                         float f;
 109                         uint8 c[4];
 110                 } u;
 111                 u.f = inFloat;
 112                 writeUInt8(u.c[3]);
 113                 writeUInt8(u.c[2]);
 114                 writeUInt8(u.c[1]);
 115                 writeUInt8(u.c[0]);
 116         }
 117
 118
 119 #if BYTE_ORDER == BIG_ENDIAN
 120         void writeDouble_be(double inDouble)
 121 #else
 122         void writeDouble_le(double inDouble)
 123 #endif
 124         {
 125                 union {
 126                         double f;
 127                         uint8 c[8];
 128                 } u;
 129                 u.f = inDouble;
 130                 writeUInt8(u.c[0]);
 131                 writeUInt8(u.c[1]);
 132                 writeUInt8(u.c[2]);
 133                 writeUInt8(u.c[3]);
 134                 writeUInt8(u.c[4]);
 135                 writeUInt8(u.c[5]);
 136                 writeUInt8(u.c[6]);
 137                 writeUInt8(u.c[7]);
 138         }
 139
 140 #if BYTE_ORDER == BIG_ENDIAN
 141         void writeDouble_le(double inDouble)
 142 #else
 143         void writeDouble_be(double inDouble)
 144 #endif
 145         {
 146                 union {
 147                         double f;
 148                         uint8 c[8];
 149                 } u;
 150                 u.f = inDouble;
 151                 writeUInt8(u.c[7]);
 152                 writeUInt8(u.c[6]);
 153                 writeUInt8(u.c[5]);
 154                 writeUInt8(u.c[4]);
 155                 writeUInt8(u.c[3]);
 156                 writeUInt8(u.c[2]);
 157                 writeUInt8(u.c[1]);
 158                 writeUInt8(u.c[0]);
 159         }
 160
 161
 162         int8 readInt8()
 163         {
 164                 return (int8)readUInt8();
 165         }
 166
 167         int16 readInt16_be()
 168         {
 169                 uint8 a = readUInt8();
 170                 uint8 b = readUInt8();
 171                 return (int16)((a << 8) | b);
 172         }
 173
 174         int16 readInt16_le()
 175         {
 176                 uint8 a = readUInt8();
 177                 uint8 b = readUInt8();
 178                 return (int16)((b << 8) | a);
 179         }
 180
 181         int32 readInt32_be()
 182         {
 183                 uint8 a = readUInt8();
 184                 uint8 b = readUInt8();
 185                 uint8 c = readUInt8();
 186                 uint8 d = readUInt8();
 187                 return (int32)((a << 24) | (b << 16) | (c << 8) | d);
 188         }
 189
 190         int32 readInt32_le()
 191         {
 192                 uint8 a = readUInt8();
 193                 uint8 b = readUInt8();
 194                 uint8 c = readUInt8();
 195                 uint8 d = readUInt8();
 196                 return (int32)((d << 24) | (c << 16) | (b << 8) | a);
 197         }
 198
 199 #if BYTE_ORDER == BIG_ENDIAN
 200         float readFloat_be()
 201 #else
 202         float readFloat_le()
 203 #endif
 204         {
 205                 union {
 206                         float f;
 207                         uint8 c[4];
 208                 } u;
 209                 u.c[0] = readUInt8();
 210                 u.c[1] = readUInt8();
 211                 u.c[2] = readUInt8();
 212                 u.c[3] = readUInt8();
 213                 return u.f;
 214         }
 215
 216 #if BYTE_ORDER == BIG_ENDIAN
 217         float readFloat_le()
 218 #else
 219         float readFloat_be()
 220 #endif
 221         {
 222                 union {
 223                         float f;
 224                         uint8 c[4];
 225                 } u;
 226                 u.c[3] = readUInt8();
 227                 u.c[2] = readUInt8();
 228                 u.c[1] = readUInt8();
 229                 u.c[0] = readUInt8();
 230                 return u.f;
 231         }
 232
 233
 234 #if BYTE_ORDER == BIG_ENDIAN
 235         double readDouble_be()
 236 #else
 237         double readDouble_le()
 238 #endif
 239         {
 240                 union {
 241                         double f;
 242                         uint8 c[8];
 243                 } u;
 244                 u.c[0] = readUInt8();
 245                 u.c[1] = readUInt8();
 246                 u.c[2] = readUInt8();
 247                 u.c[3] = readUInt8();
 248                 u.c[4] = readUInt8();
 249                 u.c[5] = readUInt8();
 250                 u.c[6] = readUInt8();
 251                 u.c[7] = readUInt8();
 252                 return u.f;
 253         }
 254
 255 #if BYTE_ORDER == BIG_ENDIAN
 256         double readDouble_le()
 257 #else
 258         double readDouble_be()
 259 #endif
 260         {
 261                 union {
 262                         double f;
 263                         uint8 c[8];
 264                 } u;
 265                 u.c[7] = readUInt8();
 266                 u.c[6] = readUInt8();
 267                 u.c[5] = readUInt8();
 268                 u.c[4] = readUInt8();
 269                 u.c[3] = readUInt8();
 270                 u.c[2] = readUInt8();
 271                 u.c[1] = readUInt8();
 272                 u.c[0] = readUInt8();
 273                 return u.f;
 274         }
 275
 276         void readSymbol(char *outString)
 277         {
 278                 int length = readUInt8();
 279                 readData(outString, length);
 280                 outString[length] = 0;
 281         }
 282
 283         void writeSymbol(char *inString)
 284         {
 285                 size_t length = strlen(inString);
 286                 writeUInt8((uint8)length);
 287                 writeData(inString, length);
 288         }
 289 };
 290
 291
 292 // core routines
 293 template <>
 294 inline void SC_IOStream<FILE*>::readData(char *data, size_t size)
 295 {
 296         size_t read = fread(data, 1, size, s);
 297         if (read != size)
 298                 throw std::runtime_error("SC_IOStream<FILE*>::readData: read != size");
 299 }
 300
 301 template <>
 302 inline uint8 SC_IOStream<FILE*>::readUInt8()
 303 {
 304         return (uint8)fgetc(s);
 305 }
 306
 307 template <>
 308 inline void SC_IOStream<FILE*>::writeData(char *data, size_t size)
 309 {
 310         fwrite(data, 1, size, s);
 311 }
 312
 313 template <>
 314 inline void SC_IOStream<FILE*>::writeUInt8(uint8 inInt)
 315 {
 316         fputc(inInt, s);
 317 }
 318
 319 // core routines
 320 template <>
 321 inline void SC_IOStream<char*>::readData(char *data, size_t size)
 322 {
 323         memcpy(data, s, size);
 324         s += size;
 325 }
 326
 327 template <>
 328 inline uint8 SC_IOStream<char*>::readUInt8()
 329 {
 330         return (uint8)*s++;
 331 }
 332
 333 template <>
 334 inline void SC_IOStream<char*>::writeData(char *data, size_t size)
 335 {
 336         memcpy(s, data, size);
 337         s += size;
 338 }
 339
 340 template <>
 341 inline void SC_IOStream<char*>::writeUInt8(uint8 inInt)
 342 {
 343         *s++ = (inInt & 255);
 344 }
 345
 346
 347 #endif
 348