rosapps/smartpdf/fitz/stream/stm_read.c

   1 /*
   2  * Input streams.
   3  */
   4
   5 #include "fitz-base.h"
   6 #include "fitz-stream.h"
   7
   8 int
   9 fz_makedata(fz_stream *stm)
  10 {
  11         fz_buffer *buf = stm->buffer;
  12         fz_error *error;
  13         fz_error *reason;
  14         int produced;
  15         int n;
  16
  17         if (stm->dead)
  18                 return -1;
  19
  20         if (stm->mode != FZ_SREAD)
  21                 return -1;
  22
  23         if (buf->eof)
  24                 return 0;
  25
  26         error = fz_rewindbuffer(buf);
  27         if (error)
  28                 goto cleanup;
  29
  30         if (buf->ep - buf->wp == 0)
  31         {
  32                 error = fz_growbuffer(buf);
  33                 if (error)
  34                         goto cleanup;
  35         }
  36
  37         switch (stm->kind)
  38         {
  39
  40         case FZ_SFILE:
  41                 n = read(stm->file, buf->wp, buf->ep - buf->wp);
  42                 if (n == -1)
  43                 {
  44                         stm->error = fz_throw("ioerror: read: %s", strerror(errno));
  45                         stm->dead = 1;
  46                         return -1;
  47                 }
  48                 if (n == 0)
  49                         buf->eof = 1;
  50                 buf->wp += n;
  51                 return n;
  52
  53         case FZ_SFILTER:
  54                 produced = 0;
  55
  56                 while (1)
  57                 {
  58                         reason = fz_process(stm->filter, stm->chain->buffer, buf);
  59
  60                         if (stm->filter->produced)
  61                                 produced = 1;
  62
  63                         if (reason == fz_ioneedin)
  64                         {
  65                                 if (fz_makedata(stm->chain) < 0)
  66                                 {
  67                                         stm->dead = 1;
  68                                         return -1;
  69                                 }
  70                         }
  71
  72                         else if (reason == fz_ioneedout)
  73                         {
  74                                 if (produced)
  75                                         return 0;
  76
  77                                 if (buf->rp > buf->bp)
  78                                 {
  79                                         error = fz_rewindbuffer(buf);
  80                                         if (error)
  81                                                 goto cleanup;
  82                                 }
  83                                 else
  84                                 {
  85                                         error = fz_growbuffer(buf);
  86                                         if (error)
  87                                                 goto cleanup;
  88                                 }
  89                         }
  90
  91                         else if (reason == fz_iodone)
  92                         {
  93                                 return 0;
  94                         }
  95
  96                         else
  97                         {
  98                                 error = reason;
  99                                 goto cleanup;
 100                         }
 101                 }
 102
 103         case FZ_SBUFFER:
 104                 return 0;
 105         }
 106
 107         return -1;
 108
 109 cleanup:
 110         stm->error = error;
 111         stm->dead = 1;
 112         return -1;
 113 }
 114
 115 int fz_rtell(fz_stream *stm)
 116 {
 117         fz_buffer *buf = stm->buffer;
 118         int t;
 119
 120         if (stm->dead)
 121                 return -1;
 122
 123         if (stm->mode != FZ_SREAD)
 124                 return -1;
 125
 126         switch (stm->kind)
 127         {
 128         case FZ_SFILE:
 129                 t = lseek(stm->file, 0, 1);
 130                 if (t < 0)
 131                 {
 132                         stm->dead = 1;
 133                         return -1;
 134                 }
 135                 return t - (buf->wp - buf->rp);
 136
 137         case FZ_SFILTER:
 138                 return stm->filter->count - (buf->wp - buf->rp);
 139
 140         case FZ_SBUFFER:
 141                 return buf->rp - buf->bp;
 142         }
 143
 144         return -1;
 145 }
 146
 147 int fz_rseek(fz_stream *stm, int offset, int whence)
 148 {
 149         fz_buffer *buf = stm->buffer;
 150         int t, c;
 151
 152         if (stm->dead)
 153                 return -1;
 154
 155         if (stm->mode != FZ_SREAD)
 156                 return -1;
 157
 158         if (whence == 1)
 159         {
 160                 int cur = fz_rtell(stm);
 161                 if (cur < 0)
 162                         return -1;
 163                 offset = cur + offset;
 164                 whence = 0;
 165         }
 166
 167         buf->eof = 0;
 168
 169         switch (stm->kind)
 170         {
 171         case FZ_SFILE:
 172                 t = lseek(stm->file, offset, whence);
 173                 if (t < 0)
 174                 {
 175                         stm->error = fz_throw("ioerror: lseek: %s", strerror(errno));
 176                         stm->dead = 1;
 177                         return -1;
 178                 }
 179
 180                 buf->rp = buf->bp;
 181                 buf->wp = buf->bp;
 182
 183                 return t;
 184
 185         case FZ_SFILTER:
 186                 if (whence == 0)
 187                 {
 188                         if (offset < fz_tell(stm))
 189                         {
 190                                 stm->error = fz_throw("ioerror: cannot seek back in filter");
 191                                 stm->dead = 1;
 192                                 return -1;
 193                         }
 194                         while (fz_tell(stm) < offset)
 195                         {
 196                                 c = fz_readbyte(stm);
 197                                 if (c == EOF)
 198                                         break;
 199                         }
 200                         return fz_tell(stm);
 201                 }
 202                 else
 203                 {
 204                         stm->dead = 1;
 205                         return -1;
 206                 }
 207
 208         case FZ_SBUFFER:
 209                 if (whence == 0)
 210                         buf->rp = CLAMP(buf->bp + offset, buf->bp, buf->ep);
 211                 else
 212                         buf->rp = CLAMP(buf->ep + offset, buf->bp, buf->ep);
 213                 return buf->rp - buf->bp;
 214         }
 215
 216         return -1;
 217 }
 218
 219 int fz_readbytex(fz_stream *stm)
 220 {
 221         fz_buffer *buf = stm->buffer;
 222         if (buf->rp == buf->wp)
 223         {
 224                 if (buf->eof) return EOF;
 225                 if (fz_makedata(stm) < 0) return EOF;
 226         }
 227         if (buf->rp < buf->wp)
 228                 return *buf->rp++;
 229         return EOF;
 230 }
 231
 232 int fz_peekbytex(fz_stream *stm)
 233 {
 234         fz_buffer *buf = stm->buffer;
 235         if (buf->rp == buf->wp)
 236         {
 237                 if (buf->eof) return EOF;
 238                 if (fz_makedata(stm) < 0) return EOF;
 239         }
 240         if (buf->rp < buf->wp)
 241                 return *buf->rp;
 242         return EOF;
 243 }
 244
 245 int fz_read(fz_stream *stm, unsigned char *mem, int n)
 246 {
 247         fz_buffer *buf = stm->buffer;
 248         int i = 0;
 249
 250         while (i < n)
 251         {
 252                 while (buf->rp < buf->wp && i < n)
 253                         mem[i++] = *buf->rp++;
 254                 if (buf->rp == buf->wp)
 255                 {
 256                         if (buf->eof) return i;
 257                         if (fz_makedata(stm) < 0) return -1;
 258                 }
 259         }
 260
 261         return i;
 262 }
 263