Subversion Repositories spk

Rev

Rev 1 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 cycrow 1 
/* 7zStream.c -- 7z Stream functions
2 
2008-11-23 : Igor Pavlov : Public domain */
3 
 
4 
#include <string.h>
5 
 
6 
#include "Types.h"
7 
 
8 
SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType)
9 
{
10 
  while (size != 0)
11 
  {
12 
    size_t processed = size;
13 
    RINOK(stream->Read(stream, buf, &processed));
14 
    if (processed == 0)
15 
      return errorType;
16 
    buf = (void *)((Byte *)buf + processed);
17 
    size -= processed;
18 
  }
19 
  return SZ_OK;
20 
}
21 
 
22 
SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size)
23 
{
24 
  return SeqInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
25 
}
26 
 
27 
SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf)
28 
{
29 
  size_t processed = 1;
30 
  RINOK(stream->Read(stream, buf, &processed));
31 
  return (processed == 1) ? SZ_OK : SZ_ERROR_INPUT_EOF;
32 
}
33 
 
34 
SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset)
35 
{
36 
  Int64 t = offset;
37 
  return stream->Seek(stream, &t, SZ_SEEK_SET);
38 
}
39 
 
40 
SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size)
41 
{
42 
  void *lookBuf;
43 
  if (*size == 0)
44 
    return SZ_OK;
45 
  RINOK(stream->Look(stream, &lookBuf, size));
46 
  memcpy(buf, lookBuf, *size);
47 
  return stream->Skip(stream, *size);
48 
}
49 
 
50 
SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType)
51 
{
52 
  while (size != 0)
53 
  {
54 
    size_t processed = size;
55 
    RINOK(stream->Read(stream, buf, &processed));
56 
    if (processed == 0)
57 
      return errorType;
58 
    buf = (void *)((Byte *)buf + processed);
59 
    size -= processed;
60 
  }
61 
  return SZ_OK;
62 
}
63 
 
64 
SRes LookInStream_Read(ILookInStream *stream, void *buf, size_t size)
65 
{
66 
  return LookInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
67 
}
68 
 
69 
static SRes LookToRead_Look_Lookahead(void *pp, void **buf, size_t *size)
70 
{
71 
  SRes res = SZ_OK;
72 
  CLookToRead *p = (CLookToRead *)pp;
73 
  size_t size2 = p->size - p->pos;
74 
  if (size2 == 0 && *size > 0)
75 
  {
76 
    p->pos = 0;
77 
    size2 = LookToRead_BUF_SIZE;
78 
    res = p->realStream->Read(p->realStream, p->buf, &size2);
79 
    p->size = size2;
80 
  }
81 
  if (size2 < *size)
82 
    *size = size2;
83 
  *buf = p->buf + p->pos;
84 
  return res;
85 
}
86 
 
87 
static SRes LookToRead_Look_Exact(void *pp, void **buf, size_t *size)
88 
{
89 
  SRes res = SZ_OK;
90 
  CLookToRead *p = (CLookToRead *)pp;
91 
  size_t size2 = p->size - p->pos;
92 
  if (size2 == 0 && *size > 0)
93 
  {
94 
    p->pos = 0;
95 
    if (*size > LookToRead_BUF_SIZE)
96 
      *size = LookToRead_BUF_SIZE;
97 
    res = p->realStream->Read(p->realStream, p->buf, size);
98 
    size2 = p->size = *size;
99 
  }
100 
  if (size2 < *size)
101 
    *size = size2;
102 
  *buf = p->buf + p->pos;
103 
  return res;
104 
}
105 
 
106 
static SRes LookToRead_Skip(void *pp, size_t offset)
107 
{
108 
  CLookToRead *p = (CLookToRead *)pp;
109 
  p->pos += offset;
110 
  return SZ_OK;
111 
}
112 
 
113 
static SRes LookToRead_Read(void *pp, void *buf, size_t *size)
114 
{
115 
  CLookToRead *p = (CLookToRead *)pp;
116 
  size_t rem = p->size - p->pos;
117 
  if (rem == 0)
118 
    return p->realStream->Read(p->realStream, buf, size);
119 
  if (rem > *size)
120 
    rem = *size;
121 
  memcpy(buf, p->buf + p->pos, rem);
122 
  p->pos += rem;
123 
  *size = rem;
124 
  return SZ_OK;
125 
}
126 
 
127 
static SRes LookToRead_Seek(void *pp, Int64 *pos, ESzSeek origin)
128 
{
129 
  CLookToRead *p = (CLookToRead *)pp;
130 
  p->pos = p->size = 0;
131 
  return p->realStream->Seek(p->realStream, pos, origin);
132 
}
133 
 
134 
void LookToRead_CreateVTable(CLookToRead *p, int lookahead)
135 
{
136 
  p->s.Look = lookahead ?
137 
      LookToRead_Look_Lookahead :
138 
      LookToRead_Look_Exact;
139 
  p->s.Skip = LookToRead_Skip;
140 
  p->s.Read = LookToRead_Read;
141 
  p->s.Seek = LookToRead_Seek;
142 
}
143 
 
144 
void LookToRead_Init(CLookToRead *p)
145 
{
146 
  p->pos = p->size = 0;
147 
}
148 
 
149 
static SRes SecToLook_Read(void *pp, void *buf, size_t *size)
150 
{
151 
  CSecToLook *p = (CSecToLook *)pp;
152 
  return LookInStream_LookRead(p->realStream, buf, size);
153 
}
154 
 
155 
void SecToLook_CreateVTable(CSecToLook *p)
156 
{
157 
  p->s.Read = SecToLook_Read;
158 
}
159 
 
160 
static SRes SecToRead_Read(void *pp, void *buf, size_t *size)
161 
{
162 
  CSecToRead *p = (CSecToRead *)pp;
163 
  return p->realStream->Read(p->realStream, buf, size);
164 
}
165 
 
166 
void SecToRead_CreateVTable(CSecToRead *p)
167 
{
168 
  p->s.Read = SecToRead_Read;
169 
}