Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. #include "fitz.h"
  2.  
  3. int
  4. fz_read(fz_stream *stm, unsigned char *buf, int len)
  5. {
  6.         int count, n;
  7.  
  8.         count = MIN(len, stm->wp - stm->rp);
  9.         if (count)
  10.         {
  11.                 memcpy(buf, stm->rp, count);
  12.                 stm->rp += count;
  13.         }
  14.  
  15.         if (count == len || stm->error || stm->eof)
  16.                 return count;
  17.  
  18.         assert(stm->rp == stm->wp);
  19.  
  20.         if (len - count < stm->ep - stm->bp)
  21.         {
  22.                 n = stm->read(stm, stm->bp, stm->ep - stm->bp);
  23.                 if (n < 0)
  24.                 {
  25.                         stm->error = 1;
  26.                         return fz_rethrow(n, "read error");
  27.                 }
  28.                 else if (n == 0)
  29.                 {
  30.                         stm->eof = 1;
  31.                 }
  32.                 else if (n > 0)
  33.                 {
  34.                         stm->rp = stm->bp;
  35.                         stm->wp = stm->bp + n;
  36.                         stm->pos += n;
  37.                 }
  38.  
  39.                 n = MIN(len - count, stm->wp - stm->rp);
  40.                 if (n)
  41.                 {
  42.                         memcpy(buf + count, stm->rp, n);
  43.                         stm->rp += n;
  44.                         count += n;
  45.                 }
  46.         }
  47.         else
  48.         {
  49.                 n = stm->read(stm, buf + count, len - count);
  50.                 if (n < 0)
  51.                 {
  52.                         stm->error = 1;
  53.                         return fz_rethrow(n, "read error");
  54.                 }
  55.                 else if (n == 0)
  56.                 {
  57.                         stm->eof = 1;
  58.                 }
  59.                 else if (n > 0)
  60.                 {
  61.                         stm->pos += n;
  62.                         count += n;
  63.                 }
  64.         }
  65.  
  66.         return count;
  67. }
  68.  
  69. void
  70. fz_fill_buffer(fz_stream *stm)
  71. {
  72.         int n;
  73.  
  74.         assert(stm->rp == stm->wp);
  75.  
  76.         if (stm->error || stm->eof)
  77.                 return;
  78.  
  79.         n = stm->read(stm, stm->bp, stm->ep - stm->bp);
  80.         if (n < 0)
  81.         {
  82.                 stm->error = 1;
  83.                 fz_catch(n, "read error; treating as end of file");
  84.         }
  85.         else if (n == 0)
  86.         {
  87.                 stm->eof = 1;
  88.         }
  89.         else if (n > 0)
  90.         {
  91.                 stm->rp = stm->bp;
  92.                 stm->wp = stm->bp + n;
  93.                 stm->pos += n;
  94.         }
  95. }
  96.  
  97. fz_error
  98. fz_read_all(fz_buffer **bufp, fz_stream *stm, int initial)
  99. {
  100.         fz_buffer *buf;
  101.         int n;
  102.  
  103.         if (initial < 1024)
  104.                 initial = 1024;
  105.  
  106.         buf = fz_new_buffer(initial);
  107.  
  108.         while (1)
  109.         {
  110.                 if (buf->len == buf->cap)
  111.                         fz_grow_buffer(buf);
  112.  
  113.                 if (buf->len / 200 > initial)
  114.                 {
  115.                         fz_drop_buffer(buf);
  116.                         return fz_throw("compression bomb detected");
  117.                 }
  118.  
  119.                 n = fz_read(stm, buf->data + buf->len, buf->cap - buf->len);
  120.                 if (n < 0)
  121.                 {
  122.                         fz_drop_buffer(buf);
  123.                         return fz_rethrow(n, "read error");
  124.                 }
  125.                 if (n == 0)
  126.                         break;
  127.  
  128.                 buf->len += n;
  129.         }
  130.  
  131.         *bufp = buf;
  132.         return fz_okay;
  133. }
  134.  
  135. void
  136. fz_read_line(fz_stream *stm, char *mem, int n)
  137. {
  138.         char *s = mem;
  139.         int c = EOF;
  140.         while (n > 1)
  141.         {
  142.                 c = fz_read_byte(stm);
  143.                 if (c == EOF)
  144.                         break;
  145.                 if (c == '\r') {
  146.                         c = fz_peek_byte(stm);
  147.                         if (c == '\n')
  148.                                 fz_read_byte(stm);
  149.                         break;
  150.                 }
  151.                 if (c == '\n')
  152.                         break;
  153.                 *s++ = c;
  154.                 n--;
  155.         }
  156.         if (n)
  157.                 *s = '\0';
  158. }
  159.  
  160. int
  161. fz_tell(fz_stream *stm)
  162. {
  163.         return stm->pos - (stm->wp - stm->rp);
  164. }
  165.  
  166. void
  167. fz_seek(fz_stream *stm, int offset, int whence)
  168. {
  169.         if (stm->seek)
  170.         {
  171.                 if (whence == 1)
  172.                 {
  173.                         offset = fz_tell(stm) + offset;
  174.                         whence = 0;
  175.                 }
  176.                 if (whence == 0)
  177.                 {
  178.                         unsigned char *p = stm->wp - (stm->pos - offset);
  179.                         if (p >= stm->bp && p <= stm->wp)
  180.                         {
  181.                                 stm->rp = p;
  182.                                 stm->eof = 0;
  183.                                 return;
  184.                         }
  185.                 }
  186.                 stm->seek(stm, offset, whence);
  187.                 stm->eof = 0;
  188.         }
  189.         else if (whence != 2)
  190.         {
  191.                 if (whence == 0)
  192.                         offset -= fz_tell(stm);
  193.                 if (offset < 0)
  194.                         fz_warn("cannot seek backwards");
  195.                 /* dog slow, but rare enough */
  196.                 while (offset-- > 0)
  197.                         fz_read_byte(stm);
  198.         }
  199.         else
  200.                 fz_warn("cannot seek");
  201. }
  202.