src/gdcmjasper/src/libjasper/base/jas_stream.c

   1 /*
   2  * Copyright (c) 1999-2000 Image Power, Inc. and the University of
   3  *   British Columbia.
   4  * Copyright (c) 2001-2003 Michael David Adams.
   5  * All rights reserved.
   6  */
   7
   8 /* __START_OF_JASPER_LICENSE__
   9  *
  10  * JasPer License Version 2.0
  11  *
  12  * Copyright (c) 1999-2000 Image Power, Inc.
  13  * Copyright (c) 1999-2000 The University of British Columbia
  14  * Copyright (c) 2001-2003 Michael David Adams
  15  *
  16  * All rights reserved.
  17  *
  18  * Permission is hereby granted, free of charge, to any person (the
  19  * "User") obtaining a copy of this software and associated documentation
  20  * files (the "Software"), to deal in the Software without restriction,
  21  * including without limitation the rights to use, copy, modify, merge,
  22  * publish, distribute, and/or sell copies of the Software, and to permit
  23  * persons to whom the Software is furnished to do so, subject to the
  24  * following conditions:
  25  *
  26  * 1.  The above copyright notices and this permission notice (which
  27  * includes the disclaimer below) shall be included in all copies or
  28  * substantial portions of the Software.
  29  *
  30  * 2.  The name of a copyright holder shall not be used to endorse or
  31  * promote products derived from the Software without specific prior
  32  * written permission.
  33  *
  34  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
  35  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  36  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
  37  * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
  38  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  39  * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO
  40  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
  41  * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
  42  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  43  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  44  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE
  45  * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
  46  * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
  47  * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
  48  * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
  49  * PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS
  50  * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
  51  * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE
  52  * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
  53  * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
  54  * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
  55  * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
  56  * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
  57  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
  58  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
  59  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
  60  *
  61  * __END_OF_JASPER_LICENSE__
  62  */
  63
  64 /*
  65  * I/O Stream Library
  66  *
  67  * $Id: jas_stream.c,v 1.3 2005/06/11 14:23:07 malaterre Exp $
  68  */
  69
  70 /******************************************************************************\
  71 * Includes.
  72 \******************************************************************************/
  73
  74 #include <assert.h>
  75 #if defined(HAVE_FCNTL_H)
  76 #include <fcntl.h>
  77 #endif
  78 #include <stdlib.h>
  79 #include <stdarg.h>
  80 #include <stdio.h>
  81 #include <ctype.h>
  82 #if defined(HAVE_UNISTD_H)
  83 #include <unistd.h>
  84 #endif
  85 #if defined(WIN32) || defined(HAVE_IO_H)
  86 #include <io.h>
  87 #endif
  88
  89 #include "jasper/jas_types.h"
  90 #include "jasper/jas_stream.h"
  91 #include "jasper/jas_malloc.h"
  92 #include "jasper/jas_math.h"
  93
  94 /******************************************************************************\
  95 * Local function prototypes.
  96 \******************************************************************************/
  97
  98 static int jas_strtoopenmode(const char *s);
  99 static void jas_stream_destroy(jas_stream_t *stream);
 100 static jas_stream_t *jas_stream_create(void);
 101 static void jas_stream_initbuf(jas_stream_t *stream, int bufmode, char *buf,
 102   int bufsize);
 103
 104 static int mem_read(jas_stream_obj_t *obj, char *buf, int cnt);
 105 static int mem_write(jas_stream_obj_t *obj, char *buf, int cnt);
 106 static long mem_seek(jas_stream_obj_t *obj, long offset, int origin);
 107 static int mem_close(jas_stream_obj_t *obj);
 108
 109 static int sfile_read(jas_stream_obj_t *obj, char *buf, int cnt);
 110 static int sfile_write(jas_stream_obj_t *obj, char *buf, int cnt);
 111 static long sfile_seek(jas_stream_obj_t *obj, long offset, int origin);
 112 static int sfile_close(jas_stream_obj_t *obj);
 113
 114 static int file_read(jas_stream_obj_t *obj, char *buf, int cnt);
 115 static int file_write(jas_stream_obj_t *obj, char *buf, int cnt);
 116 static long file_seek(jas_stream_obj_t *obj, long offset, int origin);
 117 static int file_close(jas_stream_obj_t *obj);
 118
 119 /******************************************************************************\
 120 * Local data.
 121 \******************************************************************************/
 122
 123 static jas_stream_ops_t jas_stream_fileops = {
 124   file_read,
 125   file_write,
 126   file_seek,
 127   file_close
 128 };
 129
 130 static jas_stream_ops_t jas_stream_sfileops = {
 131   sfile_read,
 132   sfile_write,
 133   sfile_seek,
 134   sfile_close
 135 };
 136
 137 static jas_stream_ops_t jas_stream_memops = {
 138   mem_read,
 139   mem_write,
 140   mem_seek,
 141   mem_close
 142 };
 143
 144 /******************************************************************************\
 145 * Code for opening and closing streams.
 146 \******************************************************************************/
 147
 148 static jas_stream_t *jas_stream_create()
 149 {
 150   jas_stream_t *stream;
 151
 152   if (!(stream = jas_malloc(sizeof(jas_stream_t)))) {
 153     return 0;
 154   }
 155   stream->openmode_ = 0;
 156   stream->bufmode_ = 0;
 157   stream->flags_ = 0;
 158   stream->bufbase_ = 0;
 159   stream->bufstart_ = 0;
 160   stream->bufsize_ = 0;
 161   stream->ptr_ = 0;
 162   stream->cnt_ = 0;
 163   stream->ops_ = 0;
 164   stream->obj_ = 0;
 165   stream->rwcnt_ = 0;
 166   stream->rwlimit_ = -1;
 167
 168   return stream;
 169 }
 170
 171 JASGLOBAL(jas_stream_t) *jas_stream_memopen(char *buf, int bufsize)
 172 {
 173   jas_stream_t *stream;
 174   jas_stream_memobj_t *obj;
 175
 176   if (!(stream = jas_stream_create())) {
 177     return 0;
 178   }
 179
 180   /* A stream associated with a memory buffer is always opened
 181   for both reading and writing in binary mode. */
 182   stream->openmode_ = JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY;
 183
 184   /* Since the stream data is already resident in memory, buffering
 185   is not necessary. */
 186   /* But... It still may be faster to use buffering anyways. */
 187   jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
 188
 189   /* Select the operations for a memory stream. */
 190   stream->ops_ = &jas_stream_memops;
 191
 192   /* Allocate memory for the underlying memory stream object. */
 193   if (!(obj = jas_malloc(sizeof(jas_stream_memobj_t)))) {
 194     jas_stream_destroy(stream);
 195     return 0;
 196   }
 197   stream->obj_ = (void *) obj;
 198
 199   /* Initialize a few important members of the memory stream object. */
 200   obj->myalloc_ = 0;
 201   obj->buf_ = 0;
 202
 203   /* If the buffer size specified is nonpositive, then the buffer
 204   is allocated internally and automatically grown as needed. */
 205   if (bufsize <= 0) {
 206     obj->bufsize_ = 1024;
 207     obj->growable_ = 1;
 208   } else {
 209     obj->bufsize_ = bufsize;
 210     obj->growable_ = 0;
 211   }
 212   if (buf) {
 213     obj->buf_ = (unsigned char *) buf;
 214   } else {
 215     obj->buf_ = jas_malloc(obj->bufsize_ * sizeof(char));
 216     obj->myalloc_ = 1;
 217   }
 218   if (!obj->buf_) {
 219     jas_stream_close(stream);
 220     return 0;
 221   }
 222
 223   if (bufsize > 0 && buf) {
 224     /* If a buffer was supplied by the caller and its length is positive,
 225       make the associated buffer data appear in the stream initially. */
 226     obj->len_ = bufsize;
 227   } else {
 228     /* The stream is initially empty. */
 229     obj->len_ = 0;
 230   }
 231   obj->pos_ = 0;
 232
 233   return stream;
 234 }
 235
 236 jas_stream_t *jas_stream_fopen(const char *filename, const char *mode)
 237 {
 238   jas_stream_t *stream;
 239   jas_stream_fileobj_t *obj;
 240   int openflags;
 241
 242   /* Allocate a stream object. */
 243   if (!(stream = jas_stream_create())) {
 244     return 0;
 245   }
 246
 247   /* Parse the mode string. */
 248   stream->openmode_ = jas_strtoopenmode(mode);
 249
 250   /* Determine the correct flags to use for opening the file. */
 251   if ((stream->openmode_ & JAS_STREAM_READ) &&
 252     (stream->openmode_ & JAS_STREAM_WRITE)) {
 253     openflags = O_RDWR;
 254   } else if (stream->openmode_ & JAS_STREAM_READ) {
 255     openflags = O_RDONLY;
 256   } else if (stream->openmode_ & JAS_STREAM_WRITE) {
 257     openflags = O_WRONLY;
 258   } else {
 259     openflags = 0;
 260   }
 261   if (stream->openmode_ & JAS_STREAM_APPEND) {
 262     openflags |= O_APPEND;
 263   }
 264   if (stream->openmode_ & JAS_STREAM_BINARY) {
 265     openflags |= O_BINARY;
 266   }
 267   if (stream->openmode_ & JAS_STREAM_CREATE) {
 268     openflags |= O_CREAT | O_TRUNC;
 269   }
 270
 271   /* Allocate space for the underlying file stream object. */
 272   if (!(obj = jas_malloc(sizeof(jas_stream_fileobj_t)))) {
 273     jas_stream_destroy(stream);
 274     return 0;
 275   }
 276   obj->fd = -1;
 277   obj->flags = 0;
 278   obj->pathname[0] = '\0';
 279   stream->obj_ = (void *) obj;
 280
 281   /* Select the operations for a file stream object. */
 282   stream->ops_ = &jas_stream_fileops;
 283
 284   /* Open the underlying file. */
 285   if ((obj->fd = open(filename, openflags, JAS_STREAM_PERMS)) < 0) {
 286     jas_stream_destroy(stream);
 287     return 0;
 288   }
 289
 290   /* By default, use full buffering for this type of stream. */
 291   jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
 292
 293   return stream;
 294 }
 295
 296 jas_stream_t *jas_stream_freopen(const char *path, const char *mode, FILE *fp)
 297 {
 298   jas_stream_t *stream;
 299   int openflags;
 300
 301   /* Eliminate compiler warning about unused variable. */
 302   path = 0;
 303
 304   /* Allocate a stream object. */
 305   if (!(stream = jas_stream_create())) {
 306     return 0;
 307   }
 308
 309   /* Parse the mode string. */
 310   stream->openmode_ = jas_strtoopenmode(mode);
 311
 312   /* Determine the correct flags to use for opening the file. */
 313   if ((stream->openmode_ & JAS_STREAM_READ) &&
 314     (stream->openmode_ & JAS_STREAM_WRITE)) {
 315     openflags = O_RDWR;
 316   } else if (stream->openmode_ & JAS_STREAM_READ) {
 317     openflags = O_RDONLY;
 318   } else if (stream->openmode_ & JAS_STREAM_WRITE) {
 319     openflags = O_WRONLY;
 320   } else {
 321     openflags = 0;
 322   }
 323   if (stream->openmode_ & JAS_STREAM_APPEND) {
 324     openflags |= O_APPEND;
 325   }
 326   if (stream->openmode_ & JAS_STREAM_BINARY) {
 327     openflags |= O_BINARY;
 328   }
 329   if (stream->openmode_ & JAS_STREAM_CREATE) {
 330     openflags |= O_CREAT | O_TRUNC;
 331   }
 332
 333   stream->obj_ = JAS_CAST(void *, fp);
 334
 335   /* Select the operations for a file stream object. */
 336   stream->ops_ = &jas_stream_sfileops;
 337
 338   /* By default, use full buffering for this type of stream. */
 339   jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
 340
 341   return stream;
 342 }
 343
 344 jas_stream_t *jas_stream_tmpfile()
 345 {
 346   jas_stream_t *stream;
 347   jas_stream_fileobj_t *obj;
 348
 349   if (!(stream = jas_stream_create())) {
 350     return 0;
 351   }
 352
 353   /* A temporary file stream is always opened for both reading and
 354   writing in binary mode. */
 355   stream->openmode_ = JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY;
 356
 357   /* Allocate memory for the underlying temporary file object. */
 358   if (!(obj = jas_malloc(sizeof(jas_stream_fileobj_t)))) {
 359     jas_stream_destroy(stream);
 360     return 0;
 361   }
 362   obj->fd = -1;
 363   obj->flags = 0;
 364   obj->pathname[0] = '\0';
 365   stream->obj_ = obj;
 366
 367   /* Choose a file name. */
 368   tmpnam(obj->pathname);
 369
 370   /* Open the underlying file. */
 371   if ((obj->fd = open(obj->pathname, O_CREAT | O_EXCL | O_RDWR | O_TRUNC | O_BINARY,
 372     JAS_STREAM_PERMS)) < 0) {
 373     jas_stream_destroy(stream);
 374     return 0;
 375   }
 376
 377   /* Unlink the file so that it will disappear if the program
 378   terminates abnormally. */
 379   /* Under UNIX, one can unlink an open file and continue to do I/O
 380   on it.  Not all operating systems support this functionality, however.
 381   For example, under Microsoft Windows the unlink operation will fail,
 382   since the file is open. */
 383   if (unlink(obj->pathname)) {
 384     /* We will try unlinking the file again after it is closed. */
 385     obj->flags |= JAS_STREAM_FILEOBJ_DELONCLOSE;
 386   }
 387
 388   /* Use full buffering. */
 389   jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
 390
 391   stream->ops_ = &jas_stream_fileops;
 392
 393   return stream;
 394 }
 395
 396 jas_stream_t *jas_stream_fdopen(int fd, const char *mode)
 397 {
 398   jas_stream_t *stream;
 399   jas_stream_fileobj_t *obj;
 400
 401   /* Allocate a stream object. */
 402   if (!(stream = jas_stream_create())) {
 403     return 0;
 404   }
 405
 406   /* Parse the mode string. */
 407   stream->openmode_ = jas_strtoopenmode(mode);
 408
 409 #if defined(WIN32)
 410   /* Argh!!!  Someone ought to banish text mode (i.e., O_TEXT) to the
 411     greatest depths of purgatory! */
 412   /* Ensure that the file descriptor is in binary mode, if the caller
 413     has specified the binary mode flag.  Arguably, the caller ought to
 414     take care of this, but text mode is a ugly wart anyways, so we save
 415     the caller some grief by handling this within the stream library. */
 416   /* This ugliness is mainly for the benefit of those who run the
 417     JasPer software under Windows from shells that insist on opening
 418     files in text mode.  For example, in the Cygwin environment,
 419     shells often open files in text mode when I/O redirection is
 420     used.  Grr... */
 421   if (stream->openmode_ & JAS_STREAM_BINARY) {
 422     setmode(fd, O_BINARY);
 423   }
 424 #endif
 425
 426   /* Allocate space for the underlying file stream object. */
 427   if (!(obj = jas_malloc(sizeof(jas_stream_fileobj_t)))) {
 428     jas_stream_destroy(stream);
 429     return 0;
 430   }
 431   obj->fd = fd;
 432   obj->flags = 0;
 433   obj->pathname[0] = '\0';
 434   stream->obj_ = (void *) obj;
 435
 436   /* Do not close the underlying file descriptor when the stream is
 437   closed. */
 438   obj->flags |= JAS_STREAM_FILEOBJ_NOCLOSE;
 439
 440   /* By default, use full buffering for this type of stream. */
 441   jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
 442
 443   /* Select the operations for a file stream object. */
 444   stream->ops_ = &jas_stream_fileops;
 445
 446   return stream;
 447 }
 448
 449 static void jas_stream_destroy(jas_stream_t *stream)
 450 {
 451   /* If the memory for the buffer was allocated with malloc, free
 452   this memory. */
 453   if ((stream->bufmode_ & JAS_STREAM_FREEBUF) && stream->bufbase_) {
 454     jas_free(stream->bufbase_);
 455     stream->bufbase_ = 0;
 456   }
 457   jas_free(stream);
 458 }
 459
 460 JASGLOBAL(int) jas_stream_close(jas_stream_t *stream)
 461 {
 462   /* Flush buffer if necessary. */
 463   jas_stream_flush(stream);
 464
 465   /* Close the underlying stream object. */
 466   (*stream->ops_->close_)(stream->obj_);
 467
 468   jas_stream_destroy(stream);
 469
 470   return 0;
 471 }
 472
 473 /******************************************************************************\
 474 * Code for reading and writing streams.
 475 \******************************************************************************/
 476
 477 int jas_stream_getc_func(jas_stream_t *stream)
 478 {
 479   assert(stream->ptr_ - stream->bufbase_ <= stream->bufsize_ +
 480     JAS_STREAM_MAXPUTBACK);
 481   return jas_stream_getc_macro(stream);
 482 }
 483
 484 int jas_stream_putc_func(jas_stream_t *stream, int c)
 485 {
 486   assert(stream->ptr_ - stream->bufstart_ <= stream->bufsize_);
 487   return jas_stream_putc_macro(stream, c);
 488 }
 489
 490 int jas_stream_ungetc(jas_stream_t *stream, int c)
 491 {
 492   if (!stream->ptr_ || stream->ptr_ == stream->bufbase_) {
 493     return -1;
 494   }
 495
 496   /* Reset the EOF indicator (since we now have at least one character
 497     to read). */
 498   stream->flags_ &= ~JAS_STREAM_EOF;
 499
 500   --stream->rwcnt_;
 501   --stream->ptr_;
 502   ++stream->cnt_;
 503   *stream->ptr_ = c;
 504   return 0;
 505 }
 506
 507 int jas_stream_read(jas_stream_t *stream, void *buf, int cnt)
 508 {
 509   int n;
 510   int c;
 511   char *bufptr;
 512
 513   bufptr = buf;
 514
 515   n = 0;
 516   while (n < cnt) {
 517     if ((c = jas_stream_getc(stream)) == EOF) {
 518       return n;
 519     }
 520     *bufptr++ = c;
 521     ++n;
 522   }
 523
 524   return n;
 525 }
 526
 527 int jas_stream_write(jas_stream_t *stream, const void *buf, int cnt)
 528 {
 529   int n;
 530   const char *bufptr;
 531
 532   bufptr = buf;
 533
 534   n = 0;
 535   while (n < cnt) {
 536     if (jas_stream_putc(stream, *bufptr) == EOF) {
 537       return n;
 538     }
 539     ++bufptr;
 540     ++n;
 541   }
 542
 543   return n;
 544 }
 545
 546 /* Note: This function uses a fixed size buffer.  Therefore, it cannot
 547   handle invocations that will produce more output than can be held
 548   by the buffer. */
 549 int jas_stream_printf(jas_stream_t *stream, const char *fmt, ...)
 550 {
 551   va_list ap;
 552   char buf[4096];
 553   int ret;
 554
 555   va_start(ap, fmt);
 556   ret = vsprintf(buf, fmt, ap);
 557   jas_stream_puts(stream, buf);
 558   va_end(ap);
 559   return ret;
 560 }
 561
 562 int jas_stream_puts(jas_stream_t *stream, const char *s)
 563 {
 564   while (*s != '\0') {
 565     if (jas_stream_putc_macro(stream, *s) == EOF) {
 566       return -1;
 567     }
 568     ++s;
 569   }
 570   return 0;
 571 }
 572
 573 char *jas_stream_gets(jas_stream_t *stream, char *buf, int bufsize)
 574 {
 575   int c;
 576   char *bufptr;
 577   assert(bufsize > 0);
 578
 579   bufptr = buf;
 580   while (bufsize > 1) {
 581     if ((c = jas_stream_getc(stream)) == EOF) {
 582       break;
 583     }
 584     *bufptr++ = c;
 585     --bufsize;
 586     if (c == '\n') {
 587       break;
 588     }
 589   }
 590   *bufptr = '\0';
 591   return buf;
 592 }
 593
 594 int jas_stream_gobble(jas_stream_t *stream, int n)
 595 {
 596   int m;
 597   m = n;
 598   for (m = n; m > 0; --m) {
 599     if (jas_stream_getc(stream) == EOF) {
 600       return n - m;
 601     }
 602   }
 603   return n;
 604 }
 605
 606 int jas_stream_pad(jas_stream_t *stream, int n, int c)
 607 {
 608   int m;
 609   m = n;
 610   for (m = n; m > 0; --m) {
 611     if (jas_stream_putc(stream, c) == EOF)
 612       return n - m;
 613   }
 614   return n;
 615 }
 616
 617 /******************************************************************************\
 618 * Code for getting and setting the stream position.
 619 \******************************************************************************/
 620
 621 int jas_stream_isseekable(jas_stream_t *stream)
 622 {
 623   if (stream->ops_ == &jas_stream_memops) {
 624     return 1;
 625   } else if (stream->ops_ == &jas_stream_fileops) {
 626     if ((*stream->ops_->seek_)(stream->obj_, 0, SEEK_CUR) < 0) {
 627       return 0;
 628     }
 629     return 1;
 630   } else {
 631     return 0;
 632   }
 633 }
 634
 635 int jas_stream_rewind(jas_stream_t *stream)
 636 {
 637   return jas_stream_seek(stream, 0, SEEK_SET);
 638 }
 639
 640 long jas_stream_seek(jas_stream_t *stream, long offset, int origin)
 641 {
 642   long newpos;
 643
 644   /* The buffer cannot be in use for both reading and writing. */
 645   assert(!((stream->bufmode_ & JAS_STREAM_RDBUF) && (stream->bufmode_ &
 646     JAS_STREAM_WRBUF)));
 647
 648   /* Reset the EOF indicator (since we may not be at the EOF anymore). */
 649   stream->flags_ &= ~JAS_STREAM_EOF;
 650
 651   if (stream->bufmode_ & JAS_STREAM_RDBUF) {
 652     if (origin == SEEK_CUR) {
 653       offset -= stream->cnt_;
 654     }
 655   } else if (stream->bufmode_ & JAS_STREAM_WRBUF) {
 656     if (jas_stream_flush(stream)) {
 657       return -1;
 658     }
 659   }
 660   stream->cnt_ = 0;
 661   stream->ptr_ = stream->bufstart_;
 662   stream->bufmode_ &= ~(JAS_STREAM_RDBUF | JAS_STREAM_WRBUF);
 663
 664   if ((newpos = (*stream->ops_->seek_)(stream->obj_, offset, origin))
 665     < 0) {
 666     return -1;
 667   }
 668
 669   return newpos;
 670 }
 671
 672 long jas_stream_tell(jas_stream_t *stream)
 673 {
 674   int adjust;
 675   int offset;
 676
 677   if (stream->bufmode_ & JAS_STREAM_RDBUF) {
 678     adjust = -stream->cnt_;
 679   } else if (stream->bufmode_ & JAS_STREAM_WRBUF) {
 680     adjust = stream->ptr_ - stream->bufstart_;
 681   } else {
 682     adjust = 0;
 683   }
 684
 685   if ((offset = (*stream->ops_->seek_)(stream->obj_, 0, SEEK_CUR)) < 0) {
 686     return -1;
 687   }
 688
 689   return offset + adjust;
 690 }
 691
 692 /******************************************************************************\
 693 * Buffer initialization code.
 694 \******************************************************************************/
 695
 696 static void jas_stream_initbuf(jas_stream_t *stream, int bufmode, char *buf,
 697   int bufsize)
 698 {
 699   /* If this function is being called, the buffer should not have been
 700     initialized yet. */
 701   assert(!stream->bufbase_);
 702
 703   if (bufmode != JAS_STREAM_UNBUF) {
 704     /* The full- or line-buffered mode is being employed. */
 705     if (!buf) {
 706       /* The caller has not specified a buffer to employ, so allocate
 707         one. */
 708       if ((stream->bufbase_ = jas_malloc(JAS_STREAM_BUFSIZE +
 709         JAS_STREAM_MAXPUTBACK))) {
 710         stream->bufmode_ |= JAS_STREAM_FREEBUF;
 711         stream->bufsize_ = JAS_STREAM_BUFSIZE;
 712       } else {
 713         /* The buffer allocation has failed.  Resort to unbuffered
 714           operation. */
 715         stream->bufbase_ = stream->tinybuf_;
 716         stream->bufsize_ = 1;
 717       }
 718     } else {
 719       /* The caller has specified a buffer to employ. */
 720       /* The buffer must be large enough to accommodate maximum
 721         putback. */
 722       assert(bufsize > JAS_STREAM_MAXPUTBACK);
 723       stream->bufbase_ = JAS_CAST(uchar *, buf);
 724       stream->bufsize_ = bufsize - JAS_STREAM_MAXPUTBACK;
 725     }
 726   } else {
 727     /* The unbuffered mode is being employed. */
 728     /* A buffer should not have been supplied by the caller. */
 729     assert(!buf);
 730     /* Use a trivial one-character buffer. */
 731     stream->bufbase_ = stream->tinybuf_;
 732     stream->bufsize_ = 1;
 733   }
 734   stream->bufstart_ = &stream->bufbase_[JAS_STREAM_MAXPUTBACK];
 735   stream->ptr_ = stream->bufstart_;
 736   stream->cnt_ = 0;
 737   stream->bufmode_ |= bufmode & JAS_STREAM_BUFMODEMASK;
 738 }
 739
 740 /******************************************************************************\
 741 * Buffer filling and flushing code.
 742 \******************************************************************************/
 743
 744 int jas_stream_flush(jas_stream_t *stream)
 745 {
 746   if (stream->bufmode_ & JAS_STREAM_RDBUF) {
 747     return 0;
 748   }
 749   return jas_stream_flushbuf(stream, EOF);
 750 }
 751
 752 int jas_stream_fillbuf(jas_stream_t *stream, int getflag)
 753 {
 754   int c;
 755
 756   /* The stream must not be in an error or EOF state. */
 757   if ((stream->flags_ & (JAS_STREAM_ERRMASK)) != 0) {
 758     return EOF;
 759   }
 760
 761   /* The stream must be open for reading. */
 762   if ((stream->openmode_ & JAS_STREAM_READ) == 0) {
 763     return EOF;
 764   }
 765
 766   /* Make a half-hearted attempt to confirm that the buffer is not
 767   currently being used for writing.  This check is not intended
 768   to be foolproof! */
 769   assert((stream->bufmode_ & JAS_STREAM_WRBUF) == 0);
 770
 771   assert(stream->ptr_ - stream->bufstart_ <= stream->bufsize_);
 772
 773   /* Mark the buffer as being used for reading. */
 774   stream->bufmode_ |= JAS_STREAM_RDBUF;
 775
 776   /* Read new data into the buffer. */
 777   stream->ptr_ = stream->bufstart_;
 778   if ((stream->cnt_ = (*stream->ops_->read_)(stream->obj_,
 779     (char *) stream->bufstart_, stream->bufsize_)) <= 0) {
 780     if (stream->cnt_ < 0) {
 781       stream->flags_ |= JAS_STREAM_ERR;
 782     } else {
 783       stream->flags_ |= JAS_STREAM_EOF;
 784     }
 785     stream->cnt_ = 0;
 786     return EOF;
 787   }
 788
 789   assert(stream->cnt_ > 0);
 790   /* Get or peek at the first character in the buffer. */
 791   c = (getflag) ? jas_stream_getc2(stream) : (*stream->ptr_);
 792
 793   return c;
 794 }
 795
 796 int jas_stream_flushbuf(jas_stream_t *stream, int c)
 797 {
 798   int len;
 799   int n;
 800
 801   /* The stream should not be in an error or EOF state. */
 802   if ((stream->flags_ & (JAS_STREAM_ERRMASK)) != 0) {
 803     return EOF;
 804   }
 805
 806   /* The stream must be open for writing. */
 807   if ((stream->openmode_ & (JAS_STREAM_WRITE | JAS_STREAM_APPEND)) == 0) {
 808     return EOF;
 809   }
 810
 811   /* The buffer should not currently be in use for reading. */
 812   assert(!(stream->bufmode_ & JAS_STREAM_RDBUF));
 813
 814   /* Note: Do not use the quantity stream->cnt to determine the number
 815   of characters in the buffer!  Depending on how this function was
 816   called, the stream->cnt value may be "off-by-one". */
 817   len = stream->ptr_ - stream->bufstart_;
 818   if (len > 0) {
 819     n = (*stream->ops_->write_)(stream->obj_, (char *)
 820       stream->bufstart_, len);
 821     if (n != len) {
 822       stream->flags_ |= JAS_STREAM_ERR;
 823       return EOF;
 824     }
 825   }
 826   stream->cnt_ = stream->bufsize_;
 827   stream->ptr_ = stream->bufstart_;
 828
 829   stream->bufmode_ |= JAS_STREAM_WRBUF;
 830
 831   if (c != EOF) {
 832     assert(stream->cnt_ > 0);
 833     return jas_stream_putc2(stream, c);
 834   }
 835
 836   return 0;
 837 }
 838
 839 /******************************************************************************\
 840 * Miscellaneous code.
 841 \******************************************************************************/
 842
 843 static int jas_strtoopenmode(const char *s)
 844 {
 845   int openmode = 0;
 846   while (*s != '\0') {
 847     switch (*s) {
 848     case 'r':
 849       openmode |= JAS_STREAM_READ;
 850       break;
 851     case 'w':
 852       openmode |= JAS_STREAM_WRITE | JAS_STREAM_CREATE;
 853       break;
 854     case 'b':
 855       openmode |= JAS_STREAM_BINARY;
 856       break;
 857     case 'a':
 858       openmode |= JAS_STREAM_APPEND;
 859       break;
 860     case '+':
 861       openmode |= JAS_STREAM_READ | JAS_STREAM_WRITE;
 862       break;
 863     default:
 864       break;
 865     }
 866     ++s;
 867   }
 868   return openmode;
 869 }
 870
 871 int jas_stream_copy(jas_stream_t *out, jas_stream_t *in, int n)
 872 {
 873   int all;
 874   int c;
 875   int m;
 876
 877   all = (n < 0) ? 1 : 0;
 878
 879   m = n;
 880   while (all || m > 0) {
 881     if ((c = jas_stream_getc_macro(in)) == EOF) {
 882       /* The next character of input could not be read. */
 883       /* Return with an error if an I/O error occured
 884         (not including EOF) or if an explicit copy count
 885         was specified. */
 886       return (!all || jas_stream_error(in)) ? (-1) : 0;
 887     }
 888     if (jas_stream_putc_macro(out, c) == EOF) {
 889       return -1;
 890     }
 891     --m;
 892   }
 893   return 0;
 894 }
 895
 896 long jas_stream_setrwcount(jas_stream_t *stream, long rwcnt)
 897 {
 898   int old;
 899
 900   old = stream->rwcnt_;
 901   stream->rwcnt_ = rwcnt;
 902   return old;
 903 }
 904
 905 int jas_stream_display(jas_stream_t *stream, FILE *fp, int n)
 906 {
 907   unsigned char buf[16];
 908   int i;
 909   int j;
 910   int m;
 911   int c;
 912   int display;
 913   int cnt;
 914
 915   cnt = n - (n % 16);
 916   display = 1;
 917
 918   for (i = 0; i < n; i += 16) {
 919     if (n > 16 && i > 0) {
 920       display = (i >= cnt) ? 1 : 0;
 921     }
 922     if (display) {
 923       fprintf(fp, "%08x:", i);
 924     }
 925     m = JAS_MIN(n - i, 16);
 926     for (j = 0; j < m; ++j) {
 927       if ((c = jas_stream_getc(stream)) == EOF) {
 928         abort();
 929         return -1;
 930       }
 931       buf[j] = c;
 932     }
 933     if (display) {
 934       for (j = 0; j < m; ++j) {
 935         fprintf(fp, " %02x", buf[j]);
 936       }
 937       fputc(' ', fp);
 938       for (; j < 16; ++j) {
 939         fprintf(fp, "   ");
 940       }
 941       for (j = 0; j < m; ++j) {
 942         if (isprint(buf[j])) {
 943           fputc(buf[j], fp);
 944         } else {
 945           fputc(' ', fp);
 946         }
 947       }
 948       fprintf(fp, "\n");
 949     }
 950
 951
 952   }
 953   return 0;
 954 }
 955
 956 long jas_stream_length(jas_stream_t *stream)
 957 {
 958   long oldpos;
 959   long pos;
 960   if ((oldpos = jas_stream_tell(stream)) < 0) {
 961     return -1;
 962   }
 963   if (jas_stream_seek(stream, 0, SEEK_END) < 0) {
 964     return -1;
 965   }
 966   if ((pos = jas_stream_tell(stream)) < 0) {
 967     return -1;
 968   }
 969   if (jas_stream_seek(stream, oldpos, SEEK_SET) < 0) {
 970     return -1;
 971   }
 972   return pos;
 973 }
 974
 975 /******************************************************************************\
 976 * Memory stream object.
 977 \******************************************************************************/
 978
 979 static int mem_read(jas_stream_obj_t *obj, char *buf, int cnt)
 980 {
 981   int n;
 982   jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj;
 983   n = m->len_ - m->pos_;
 984   cnt = JAS_MIN(n, cnt);
 985   memcpy(buf, &m->buf_[m->pos_], cnt);
 986   m->pos_ += cnt;
 987   return cnt;
 988 }
 989
 990 static int mem_resize(jas_stream_memobj_t *m, int bufsize)
 991 {
 992   unsigned char *buf;
 993
 994   assert(m->buf_);
 995   if (!(buf = jas_realloc(m->buf_, bufsize * sizeof(unsigned char)))) {
 996     return -1;
 997   }
 998   m->buf_ = buf;
 999   m->bufsize_ = bufsize;
1000   return 0;
1001 }
1002
1003 static int mem_write(jas_stream_obj_t *obj, char *buf, int cnt)
1004 {
1005   int n;
1006   int ret;
1007   jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj;
1008   long newbufsize;
1009   long newpos;
1010
1011   newpos = m->pos_ + cnt;
1012   if (newpos > m->bufsize_ && m->growable_) {
1013     newbufsize = m->bufsize_;
1014     while (newbufsize < newpos) {
1015       newbufsize <<= 1;
1016       assert(newbufsize >= 0);
1017     }
1018     if (mem_resize(m, newbufsize)) {
1019       return -1;
1020     }
1021   }
1022   if (m->pos_ > m->len_) {
1023     /* The current position is beyond the end of the file, so
1024       pad the file to the current position with zeros. */
1025     n = JAS_MIN(m->pos_, m->bufsize_) - m->len_;
1026     if (n > 0) {
1027       memset(&m->buf_[m->len_], 0, n);
1028       m->len_ += n;
1029     }
1030     if (m->pos_ != m->len_) {
1031       /* The buffer is not big enough. */
1032       return 0;
1033     }
1034   }
1035   n = m->bufsize_ - m->pos_;
1036   ret = JAS_MIN(n, cnt);
1037   if (ret > 0) {
1038     memcpy(&m->buf_[m->pos_], buf, ret);
1039     m->pos_ += ret;
1040   }
1041   if (m->pos_ > m->len_) {
1042     m->len_ = m->pos_;
1043   }
1044 assert(ret == cnt);
1045   return ret;
1046 }
1047
1048 static long mem_seek(jas_stream_obj_t *obj, long offset, int origin)
1049 {
1050   jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj;
1051   long newpos;
1052
1053   switch (origin) {
1054   case SEEK_SET:
1055     newpos = offset;
1056     break;
1057   case SEEK_END:
1058     newpos = m->len_ - offset;
1059     break;
1060   case SEEK_CUR:
1061     newpos = m->pos_ + offset;
1062     break;
1063   default:
1064     abort();
1065     break;
1066   }
1067   if (newpos < 0) {
1068     return -1;
1069   }
1070   m->pos_ = newpos;
1071
1072   return m->pos_;
1073 }
1074
1075 static int mem_close(jas_stream_obj_t *obj)
1076 {
1077   jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj;
1078   if (m->myalloc_ && m->buf_) {
1079     jas_free(m->buf_);
1080     m->buf_ = 0;
1081   }
1082   jas_free(obj);
1083   return 0;
1084 }
1085
1086 /******************************************************************************\
1087 * File stream object.
1088 \******************************************************************************/
1089
1090 static int file_read(jas_stream_obj_t *obj, char *buf, int cnt)
1091 {
1092   jas_stream_fileobj_t *fileobj = JAS_CAST(jas_stream_fileobj_t *, obj);
1093   return read(fileobj->fd, buf, cnt);
1094 }
1095
1096 static int file_write(jas_stream_obj_t *obj, char *buf, int cnt)
1097 {
1098   jas_stream_fileobj_t *fileobj = JAS_CAST(jas_stream_fileobj_t *, obj);
1099   return write(fileobj->fd, buf, cnt);
1100 }
1101
1102 static long file_seek(jas_stream_obj_t *obj, long offset, int origin)
1103 {
1104   jas_stream_fileobj_t *fileobj = JAS_CAST(jas_stream_fileobj_t *, obj);
1105   return lseek(fileobj->fd, offset, origin);
1106 }
1107
1108 static int file_close(jas_stream_obj_t *obj)
1109 {
1110   jas_stream_fileobj_t *fileobj = JAS_CAST(jas_stream_fileobj_t *, obj);
1111   int ret;
1112   ret = close(fileobj->fd);
1113   if (fileobj->flags & JAS_STREAM_FILEOBJ_DELONCLOSE) {
1114     unlink(fileobj->pathname);
1115   }
1116   jas_free(fileobj);
1117   return ret;
1118 }
1119
1120 /******************************************************************************\
1121 * Stdio file stream object.
1122 \******************************************************************************/
1123
1124 static int sfile_read(jas_stream_obj_t *obj, char *buf, int cnt)
1125 {
1126   FILE *fp;
1127   fp = JAS_CAST(FILE *, obj);
1128   return fread(buf, 1, cnt, fp);
1129 }
1130
1131 static int sfile_write(jas_stream_obj_t *obj, char *buf, int cnt)
1132 {
1133   FILE *fp;
1134   fp = JAS_CAST(FILE *, obj);
1135   return fwrite(buf, 1, cnt, fp);
1136 }
1137
1138 static long sfile_seek(jas_stream_obj_t *obj, long offset, int origin)
1139 {
1140   FILE *fp;
1141   fp = JAS_CAST(FILE *, obj);
1142   return fseek(fp, offset, origin);
1143 }
1144
1145 static int sfile_close(jas_stream_obj_t *obj)
1146 {
1147   FILE *fp;
1148   fp = JAS_CAST(FILE *, obj);
1149   return fclose(fp);
1150 }