ukengine/byteio.cpp

   1 // -*- coding:unix; mode:c++; tab-width:4; c-basic-offset:4; indent-tabs-mode:nil -*-
   2 #include <string.h>
   3 #include "byteio.h"
   4
   5 //------------------------------------------------
   6 StringBIStream::StringBIStream(UKBYTE *data, int len, int elementSize)
   7 {
   8         m_data = m_current = data;
   9         m_len = m_left = len;
  10     if (len == -1) {
  11         if (elementSize == 2)
  12             m_eos = (*(UKWORD *)data == 0);
  13         else if (elementSize == 4)
  14             m_eos = (*(UKDWORD *)data == 4);
  15         else
  16             m_eos = (*data == 0);
  17     }
  18         else
  19                 m_eos = (len <= 0);
  20         m_didBookmark = 0;
  21 }
  22
  23 //------------------------------------------------
  24 int StringBIStream::eos()
  25 {
  26         return m_eos;
  27 }
  28
  29 //------------------------------------------------
  30 int StringBIStream::getNext(UKBYTE & b)
  31 {
  32         if (m_eos)
  33                 return 0;
  34         b = *m_current++;
  35         if (m_len == -1) {
  36                 m_eos = (b == 0);
  37         }
  38         else {
  39                 m_left--;
  40                 m_eos = (m_left <= 0);
  41         }
  42         return 1;
  43 }
  44
  45 //------------------------------------------------
  46 int StringBIStream::unget(UKBYTE b)
  47 {
  48         if (m_current != m_data) {
  49                 *--m_current = b;
  50                 m_eos = 0;
  51                 if (m_len != -1)
  52                         m_left++;
  53         }
  54         return 1;
  55 }
  56
  57 //------------------------------------------------
  58 int StringBIStream::getNextW(UKWORD & w)
  59 {
  60         if (m_eos) return 0;
  61         w = *((UKWORD *)m_current);
  62         m_current += 2;
  63         if (m_len == -1)
  64                 m_eos = (w == 0);
  65         else {
  66                 m_left -= 2;
  67                 m_eos = (m_left <= 0);
  68         }
  69         return 1;
  70 }
  71
  72 //------------------------------------------------
  73 int StringBIStream::getNextDW(UKDWORD & dw)
  74 {
  75         if (m_eos) return 0;
  76
  77         dw = *((UKDWORD *)m_current);
  78         m_current += 4;
  79         if (m_len == -1)
  80                 m_eos = (dw == 0);
  81         else {
  82                 m_left -= 4;
  83                 m_eos = (m_left <= 0);
  84         }
  85         return 1;
  86 }
  87
  88 //------------------------------------------------
  89 int StringBIStream::peekNext(UKBYTE & b)
  90 {
  91         if (m_eos)
  92                 return 0;
  93         b = *m_current;
  94         return 1;
  95 }
  96
  97 //------------------------------------------------
  98 int StringBIStream::peekNextW(UKWORD & w)
  99 {
 100         if (m_eos)
 101                 return 0;
 102         w = *((UKWORD *)m_current);
 103         return 1;
 104 }
 105
 106 /*
 107 //------------------------------------------------
 108 int StringBIStream::peekNextDW(UKDWORD & dw)
 109 {
 110         if (m_eos)
 111                 return 0;
 112         dw = *((UKDWORD *)m_current);
 113         return 1;
 114 }
 115 */
 116
 117 //------------------------------------------------
 118 void StringBIStream::reopen()
 119 {
 120         m_current = m_data;
 121         m_left = m_len;
 122         if (m_len == -1)
 123                 m_eos = (m_data == 0);
 124         else
 125                 m_eos = (m_len <= 0);
 126         m_didBookmark = 0;
 127 }
 128
 129 //------------------------------------------------
 130 int StringBIStream::bookmark()
 131 {
 132         m_didBookmark = 1;
 133         m_bookmark.current = m_current;
 134         m_bookmark.data = m_data;
 135         m_bookmark.eos = m_eos;
 136         m_bookmark.left = m_left;
 137         m_bookmark.len = m_len;
 138         return 1;
 139 }
 140
 141 //------------------------------------------------
 142 int StringBIStream::gotoBookmark()
 143 {
 144         if (!m_didBookmark)
 145                 return 0;
 146         m_current = m_bookmark.current;
 147         m_data = m_bookmark.data;
 148         m_eos = m_bookmark.eos;
 149         m_left = m_bookmark.left;
 150         m_len = m_bookmark.len;
 151         return 1;
 152 }
 153
 154 //------------------------------------------------
 155 int StringBIStream::close()
 156 {
 157         return 1;
 158 };
 159
 160 //////////////////////////////////////////////////
 161 // Class StringBOStream
 162 //////////////////////////////////////////////////
 163
 164 //------------------------------------------------
 165 StringBOStream::StringBOStream(UKBYTE *buf, int len)
 166 {
 167         m_current = m_buf = buf;
 168         m_len = len;
 169         m_out = 0;
 170         m_bad = 0;
 171 }
 172
 173 //------------------------------------------------
 174 int StringBOStream::putB(UKBYTE b)
 175 {
 176         m_out++;
 177 /*
 178         if (m_out >= 2147483647) {
 179                 int err;
 180                 err = 1;
 181         }
 182 */
 183         if (m_bad)
 184                 return 0;
 185 /*
 186         if (m_out < 0) {
 187                 int i;
 188                 i = 1;
 189         }
 190 */
 191         if (m_out <= m_len) {
 192                 *m_current++ = b;
 193                 return 1;
 194         }
 195         m_bad = 1;
 196         return 0;
 197 }
 198
 199 //------------------------------------------------
 200 int StringBOStream::putW(UKWORD w)
 201 {
 202         m_out += 2;
 203         if (m_bad)
 204                 return 0;
 205         if (m_out <= m_len) {
 206                 *((UKWORD *)m_current) = w;
 207                 m_current += 2;
 208                 return 1;
 209         }
 210         m_bad = 1;
 211         return 0;
 212 }
 213
 214 //------------------------------------------------
 215 int StringBOStream::puts(const char *s, int size)
 216 {
 217         if (size == -1) {
 218                 while (*s) {
 219                         m_out++;
 220                         if (m_out <= m_len)
 221                                 *m_current++ = *s;
 222                         s++;
 223                 }
 224                 if (!m_bad && m_out > m_len)
 225                         m_bad = 1;
 226                 return (!m_bad);
 227         }
 228
 229         int n;
 230         if (!m_bad && m_out <= m_len) {
 231                 n = m_len - m_out;
 232                 if (n>size)
 233                         n = size;
 234                 memcpy(m_current, s, n);
 235                 m_current += n;
 236         }
 237
 238         m_out += size;
 239         if (!m_bad && m_out > m_len)
 240                 m_bad = 1;
 241         return (!m_bad);
 242 }
 243
 244 //------------------------------------------------
 245 void StringBOStream::reopen()
 246 {
 247         m_current = m_buf;
 248         m_out = 0;
 249         m_bad = 0;
 250 }
 251
 252
 253 //------------------------------------------------
 254 int StringBOStream::isOK()
 255 {
 256         return !m_bad;
 257 }
 258
 259
 260 ////////////////////////////////////////////////////
 261 // Class FileBIStream                             //
 262 ////////////////////////////////////////////////////
 263
 264 //----------------------------------------------------
 265 FileBIStream::FileBIStream(int bufSize, char *buf)
 266 {
 267         m_file = NULL;
 268         m_buf = buf;
 269         m_bufSize = bufSize;
 270         m_own = 1;
 271         m_didBookmark = 0;
 272
 273         m_readAhead = 0;
 274         m_lastIsAhead = 0;
 275 }
 276
 277 //----------------------------------------------------
 278 FileBIStream::~FileBIStream()
 279 {
 280         if (m_own)
 281                 close();
 282 }
 283
 284 //----------------------------------------------------
 285 int FileBIStream::open(const char *fileName)
 286 {
 287         m_file = fopen(fileName, "rb");
 288         if (m_file == NULL)
 289                 return 0;
 290         setvbuf(m_file, m_buf, _IOFBF, m_bufSize);
 291         m_own = 0;
 292         m_readAhead = 0;
 293         m_lastIsAhead = 0;
 294         return 1;
 295 }
 296
 297 //----------------------------------------------------
 298 int FileBIStream::close()
 299 {
 300         if (m_file != NULL) {
 301                 fclose(m_file);
 302                 m_file = NULL;
 303         }
 304         return 1;
 305 }
 306
 307 //----------------------------------------------------
 308 void FileBIStream::attach(FILE * f)
 309 {
 310         m_file = f;
 311         m_own = 0;
 312         m_readAhead = 0;
 313         m_lastIsAhead = 0;
 314 }
 315
 316 //----------------------------------------------------
 317 int FileBIStream::eos()
 318 {
 319   if (m_readAhead)
 320     return 0;
 321   return feof(m_file);
 322 }
 323
 324 //----------------------------------------------------
 325 int FileBIStream::getNext(UKBYTE &b)
 326 {
 327   if (m_readAhead) {
 328     m_readAhead = 0;
 329     b = m_readByte;
 330     m_lastIsAhead = 1;
 331     return 1;
 332   }
 333
 334   m_lastIsAhead = 0;
 335   b = fgetc(m_file);
 336   return (!feof(m_file));
 337 }
 338
 339 //----------------------------------------------------
 340 int FileBIStream::peekNext(UKBYTE &b)
 341 {
 342   if (m_readAhead) {
 343     b = m_readByte;
 344     return 1;
 345   }
 346
 347   b = fgetc(m_file);
 348   if (feof(m_file))
 349     return 0;
 350   ungetc(b, m_file);
 351   return 1;
 352 }
 353
 354 //----------------------------------------------------
 355 int FileBIStream::unget(UKBYTE b)
 356 {
 357   if (m_lastIsAhead) {
 358     m_lastIsAhead = 0;
 359     m_readAhead = 1;
 360     m_readByte = b;
 361     return 1;
 362   }
 363
 364   ungetc(b, m_file);
 365   return 1;
 366 }
 367
 368 //----------------------------------------------------
 369 int FileBIStream::getNextW(UKWORD &w)
 370 {
 371   UKBYTE b1, b2;
 372
 373   if (getNext(b1)) {
 374     if (getNext(b2)) {
 375       *((UKBYTE *)&w) = b1;
 376       *(((UKBYTE *)&w)+1) = b2;
 377       return 1;
 378     }
 379   }
 380   return 0;
 381 }
 382
 383 //----------------------------------------------------
 384 int FileBIStream::getNextDW(UKDWORD &dw)
 385 {
 386   UKWORD w1, w2;
 387   if (getNextW(w1)) {
 388     if (getNextW(w2)) {
 389       *((UKWORD *)&dw) = w1;
 390       *(((UKWORD *)&dw)+1) = w2;
 391       return 1;
 392     }
 393   }
 394   return 0;
 395
 396 }
 397 //----------------------------------------------------
 398 int FileBIStream::peekNextW(UKWORD &w)
 399 {
 400   UKBYTE hi, low;
 401   if (getNext(low)) {
 402     if (getNext(hi)) {
 403       unget(hi);
 404       w = hi;
 405       w = (w << 8) + low;
 406       m_readAhead = 1;
 407       m_readByte = low;
 408       m_lastIsAhead = 0;
 409       return 1;
 410     }
 411
 412     m_readAhead = 1;
 413     m_readByte = low;
 414     m_lastIsAhead = 0;
 415     return 0;
 416   }
 417   return 0;
 418 }
 419
 420 //----------------------------------------------------
 421 int FileBIStream::bookmark()
 422 {
 423         m_didBookmark = 1;
 424         m_bookmark.pos = ftell(m_file);
 425         return 1;
 426 }
 427
 428
 429 //----------------------------------------------------
 430 int FileBIStream::gotoBookmark()
 431 {
 432         if (!m_didBookmark)
 433                 return 0;
 434         fseek(m_file, m_bookmark.pos, SEEK_SET);
 435         return 1;
 436 }
 437
 438 ////////////////////////////////////////////////////
 439 // Class FileBOStream                             //
 440 ////////////////////////////////////////////////////
 441 //----------------------------------------------------
 442 FileBOStream::FileBOStream(int bufSize, char *buf)
 443 {
 444         m_file = NULL;
 445         m_buf = buf;
 446         m_bufSize = bufSize;
 447         m_own = 1;
 448         m_bad = 1;
 449 }
 450
 451 //----------------------------------------------------
 452 FileBOStream::~FileBOStream()
 453 {
 454         if (m_own)
 455                 close();
 456 }
 457
 458 //----------------------------------------------------
 459 int FileBOStream::open(const char *fileName)
 460 {
 461         m_file = fopen(fileName, "wb");
 462         if (m_file == NULL)
 463                 return 0;
 464         m_bad = 0;
 465         setvbuf(m_file, m_buf, _IOFBF, m_bufSize);
 466         m_own = 1;
 467         return 1;
 468 }
 469
 470 //----------------------------------------------------
 471 void FileBOStream::attach(FILE * f)
 472 {
 473         m_file = f;
 474         m_own = 0;
 475         m_bad = 0;
 476 }
 477
 478 //----------------------------------------------------
 479 int FileBOStream::close()
 480 {
 481         if (m_file != NULL) {
 482                 fclose(m_file);
 483                 m_file = NULL;
 484         }
 485         return 1;
 486 }
 487
 488 //----------------------------------------------------
 489 int FileBOStream::putB(UKBYTE b)
 490 {
 491         if (m_bad)
 492                 return 0;
 493         m_bad = (fputc(b, m_file) == EOF);
 494         return (!m_bad);
 495 }
 496
 497 //----------------------------------------------------
 498 int FileBOStream::putW(UKWORD w)
 499 {
 500         if (m_bad)
 501                 return 0;
 502         //      m_bad = (fputwc(w, m_file) == WEOF);
 503         m_bad = (fputc((UKBYTE)w, m_file) == EOF);
 504         if (m_bad)
 505           return 0;
 506         m_bad = (fputc((UKBYTE)(w >> 8), m_file) == EOF);
 507         return (!m_bad);
 508 }
 509
 510 //----------------------------------------------------
 511 int FileBOStream::puts(const char *s, int size)
 512 {
 513         if (m_bad)
 514                 return 0;
 515         if (size == -1) {
 516                 m_bad = (fputs(s, m_file) == EOF);
 517                 return (!m_bad);
 518         }
 519         int out = fwrite(s, 1, size, m_file);
 520         m_bad = (out != size);
 521         return (!m_bad);
 522 }
 523
 524 //----------------------------------------------------
 525 int FileBOStream::isOK()
 526 {
 527         return !m_bad;
 528 }