Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <stdio.h>
21 : #include <errno.h>
22 :
23 : #ifdef WIN32
24 : # include <io.h>
25 : #else
26 : # include <unistd.h>
27 : #endif
28 :
29 : #include <osl/diagnose.h>
30 :
31 : #include "hwplib.h"
32 : #include "hgzip.h"
33 : #include "hiodev.h"
34 : #include "hwpfile.h"
35 : #include "hstream.h"
36 :
37 : const int BUFSIZE = 1024;
38 : static uchar rBuf[BUFSIZE];
39 :
40 : // HIODev abstract class
41 4 : HIODev::HIODev()
42 : {
43 4 : init();
44 4 : }
45 :
46 :
47 4 : HIODev::~HIODev()
48 : {
49 4 : }
50 :
51 :
52 4 : void HIODev::init()
53 : {
54 4 : compressed = false;
55 4 : }
56 :
57 :
58 2822 : int HIODev::read1b(void *ptr, int nmemb)
59 : {
60 2822 : uchar *p = (uchar *) ptr;
61 : int ii;
62 :
63 2822 : if (state())
64 0 : return -1;
65 6550 : for (ii = 0; ii < nmemb; ii++)
66 : {
67 3728 : p[ii] = sal::static_int_cast<uchar>(read1b());
68 3728 : if (state())
69 0 : break;
70 : }
71 2822 : return ii;
72 : }
73 :
74 :
75 64 : int HIODev::read2b(void *ptr, int nmemb)
76 : {
77 64 : ushort *p = (ushort *) ptr;
78 : int ii;
79 :
80 64 : if (state())
81 0 : return -1;
82 1118 : for (ii = 0; ii < nmemb; ii++)
83 : {
84 1054 : p[ii] = sal::static_int_cast<uchar>(read2b());
85 1054 : if (state())
86 0 : break;
87 : }
88 64 : return ii;
89 : }
90 :
91 :
92 6 : int HIODev::read4b(void *ptr, int nmemb)
93 : {
94 6 : ulong *p = (ulong *) ptr;
95 : int ii;
96 :
97 6 : if (state())
98 0 : return -1;
99 12 : for (ii = 0; ii < nmemb; ii++)
100 : {
101 6 : p[ii] = read4b();
102 6 : if (state())
103 0 : break;
104 : }
105 6 : return ii;
106 : }
107 :
108 :
109 : // hfileiodev class
110 4 : HStreamIODev::HStreamIODev(HStream * stream):_stream(stream)
111 : {
112 4 : init();
113 4 : }
114 :
115 :
116 12 : HStreamIODev::~HStreamIODev()
117 : {
118 4 : close();
119 8 : }
120 :
121 :
122 4 : void HStreamIODev::init()
123 : {
124 4 : _gzfp = NULL;
125 4 : compressed = false;
126 4 : }
127 :
128 :
129 4 : bool HStreamIODev::open()
130 : {
131 4 : if (!(_stream->available()))
132 0 : return false;
133 4 : return true;
134 : }
135 :
136 :
137 4 : void HStreamIODev::flush(void)
138 : {
139 4 : if (_gzfp)
140 2 : gz_flush(_gzfp, Z_FINISH);
141 4 : }
142 :
143 :
144 4 : void HStreamIODev::close(void)
145 : {
146 : /* 플러시한 후 닫는다. */
147 4 : this->flush();
148 4 : if (_gzfp)
149 2 : gz_close(_gzfp);
150 4 : _gzfp = NULL;
151 4 : }
152 :
153 :
154 7680 : int HStreamIODev::state(void) const
155 : {
156 7680 : return 0;
157 : }
158 :
159 :
160 : /* zlib 관련 부분 */
161 2 : bool HStreamIODev::setCompressed(bool flag)
162 : {
163 2 : compressed = flag;
164 2 : if (flag == true)
165 2 : return 0 != (_gzfp = gz_open(*_stream));
166 0 : else if (_gzfp)
167 : {
168 0 : gz_flush(_gzfp, Z_FINISH);
169 0 : gz_close(_gzfp);
170 0 : _gzfp = 0;
171 : }
172 0 : return true;
173 : }
174 :
175 :
176 : // IO routines
177 :
178 : #define GZREAD(ptr,len) (_gzfp?gz_read(_gzfp,ptr,len):0)
179 :
180 3728 : int HStreamIODev::read1b()
181 : {
182 3728 : int res = (compressed) ? GZREAD(rBuf, 1) : _stream->readBytes(rBuf, 1);
183 :
184 3728 : if (res <= 0)
185 0 : return -1;
186 : else
187 3728 : return (unsigned char) rBuf[0];
188 : }
189 :
190 :
191 2590 : int HStreamIODev::read2b()
192 : {
193 2590 : int res = (compressed) ? GZREAD(rBuf, 2) : _stream->readBytes(rBuf, 2);
194 :
195 2590 : if (res <= 0)
196 0 : return -1;
197 : else
198 2590 : return ((unsigned char) rBuf[1] << 8 | (unsigned char) rBuf[0]);
199 : }
200 :
201 :
202 10 : int HStreamIODev::read4b()
203 : {
204 10 : int res = (compressed) ? GZREAD(rBuf, 4) : _stream->readBytes(rBuf, 4);
205 :
206 10 : if (res <= 0)
207 0 : return -1;
208 : else
209 20 : return ((unsigned char) rBuf[3] << 24 | (unsigned char) rBuf[2] << 16 |
210 20 : (unsigned char) rBuf[1] << 8 | (unsigned char) rBuf[0]);
211 : }
212 :
213 :
214 1434 : int HStreamIODev::readBlock(void *ptr, int size)
215 : {
216 : int count =
217 1430 : (compressed) ? GZREAD(ptr, size) : _stream->readBytes((byte *) ptr,
218 :
219 2864 : size);
220 :
221 1434 : return count;
222 : }
223 :
224 :
225 0 : int HStreamIODev::skipBlock(int size)
226 : {
227 0 : if (compressed){
228 0 : if( size <= BUFSIZE )
229 0 : return GZREAD(rBuf, size);
230 : else{
231 0 : int remain = size;
232 0 : while(remain){
233 0 : if( remain > BUFSIZE )
234 0 : remain -= GZREAD(rBuf, BUFSIZE);
235 : else{
236 0 : remain -= GZREAD(rBuf, remain);
237 0 : break;
238 : }
239 : }
240 0 : return size - remain;
241 : }
242 : }
243 0 : return _stream->skipBytes(size);
244 : }
245 :
246 :
247 0 : HMemIODev::HMemIODev(char *s, int len)
248 : {
249 0 : init();
250 0 : ptr = (uchar *) s;
251 0 : length = len;
252 0 : }
253 :
254 :
255 0 : HMemIODev::~HMemIODev()
256 : {
257 0 : close();
258 0 : }
259 :
260 :
261 0 : void HMemIODev::init()
262 : {
263 0 : ptr = 0;
264 0 : length = 0;
265 0 : pos = 0;
266 0 : }
267 :
268 :
269 0 : bool HMemIODev::open()
270 : {
271 0 : return true;
272 : }
273 :
274 :
275 0 : void HMemIODev::flush(void)
276 : {
277 0 : }
278 :
279 :
280 0 : void HMemIODev::close(void)
281 : {
282 0 : }
283 :
284 :
285 0 : int HMemIODev::state(void) const
286 : {
287 0 : if (pos <= length)
288 0 : return 0;
289 : else
290 0 : return -1;
291 : }
292 :
293 :
294 0 : bool HMemIODev::setCompressed(bool )
295 : {
296 0 : return false;
297 : }
298 :
299 :
300 0 : int HMemIODev::read1b()
301 : {
302 0 : if (pos <= length)
303 0 : return ptr[pos++];
304 : else
305 0 : return 0;
306 : }
307 :
308 :
309 0 : int HMemIODev::read2b()
310 : {
311 0 : pos += 2;
312 0 : if (pos <= length)
313 0 : return ptr[pos - 1] << 8 | ptr[pos - 2];
314 : else
315 0 : return 0;
316 : }
317 :
318 :
319 0 : int HMemIODev::read4b()
320 : {
321 0 : pos += 4;
322 0 : if (pos <= length)
323 0 : return DWORD(ptr[pos - 1] << 24 | ptr[pos - 2] << 16 |
324 0 : ptr[pos - 3] << 8 | ptr[pos - 4]);
325 : else
326 0 : return 0;
327 : }
328 :
329 :
330 0 : int HMemIODev::readBlock(void *p, int size)
331 : {
332 0 : if (length < pos + size)
333 0 : size = length - pos;
334 0 : memcpy(p, ptr + pos, size);
335 0 : pos += size;
336 0 : return size;
337 : }
338 :
339 :
340 0 : int HMemIODev::skipBlock(int size)
341 : {
342 0 : if (length < pos + size)
343 0 : return 0;
344 0 : pos += size;
345 0 : return size;
346 : }
347 :
348 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
