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.hxx"
36 :
37 : const int BUFSIZE = 1024;
38 : static uchar rBuf[BUFSIZE];
39 :
40 : // HIODev abstract class
41 2 : HIODev::HIODev()
42 : {
43 2 : init();
44 2 : }
45 :
46 :
47 2 : HIODev::~HIODev()
48 : {
49 2 : }
50 :
51 :
52 2 : void HIODev::init()
53 : {
54 2 : compressed = false;
55 2 : }
56 :
57 :
58 1411 : int HIODev::read1b(void *ptr, int nmemb)
59 : {
60 1411 : uchar *p = static_cast<uchar *>(ptr);
61 : int ii;
62 :
63 1411 : if (state())
64 0 : return -1;
65 3275 : for (ii = 0; ii < nmemb; ii++)
66 : {
67 1864 : if (!read1b(p[ii]))
68 0 : break;
69 1864 : if (state())
70 0 : break;
71 : }
72 1411 : return ii;
73 : }
74 :
75 32 : int HIODev::read2b(void *ptr, int nmemb)
76 : {
77 32 : ushort *p = static_cast<ushort *>(ptr);
78 : int ii;
79 :
80 32 : if (state())
81 0 : return -1;
82 559 : for (ii = 0; ii < nmemb; ii++)
83 : {
84 527 : if (!read2b(p[ii]))
85 0 : break;
86 527 : if (state())
87 0 : break;
88 : }
89 32 : return ii;
90 : }
91 :
92 3 : int HIODev::read4b(void *ptr, int nmemb)
93 : {
94 3 : uint *p = static_cast<uint *>(ptr);
95 : int ii;
96 :
97 3 : if (state())
98 0 : return -1;
99 6 : for (ii = 0; ii < nmemb; ii++)
100 : {
101 3 : if (!read4b(p[ii]))
102 0 : break;
103 3 : if (state())
104 0 : break;
105 : }
106 3 : return ii;
107 : }
108 :
109 :
110 : // hfileiodev class
111 2 : HStreamIODev::HStreamIODev(HStream * stream):_stream(stream)
112 : {
113 2 : init();
114 2 : }
115 :
116 :
117 6 : HStreamIODev::~HStreamIODev()
118 : {
119 2 : close();
120 4 : }
121 :
122 :
123 2 : void HStreamIODev::init()
124 : {
125 2 : _gzfp = NULL;
126 2 : compressed = false;
127 2 : }
128 :
129 :
130 2 : bool HStreamIODev::open()
131 : {
132 2 : if (!(_stream->available()))
133 0 : return false;
134 2 : return true;
135 : }
136 :
137 :
138 2 : void HStreamIODev::flush()
139 : {
140 2 : if (_gzfp)
141 1 : gz_flush(_gzfp, Z_FINISH);
142 2 : }
143 :
144 :
145 2 : void HStreamIODev::close()
146 : {
147 : /* 플러시한 후 닫는다. */
148 2 : this->flush();
149 2 : if (_gzfp)
150 1 : gz_close(_gzfp);
151 2 : _gzfp = NULL;
152 2 : }
153 :
154 :
155 3840 : int HStreamIODev::state() const
156 : {
157 3840 : return 0;
158 : }
159 :
160 :
161 : /* zlib 관련 부분 */
162 1 : bool HStreamIODev::setCompressed(bool flag)
163 : {
164 1 : compressed = flag;
165 1 : if (flag)
166 1 : return 0 != (_gzfp = gz_open(*_stream));
167 0 : else if (_gzfp)
168 : {
169 0 : gz_flush(_gzfp, Z_FINISH);
170 0 : gz_close(_gzfp);
171 0 : _gzfp = 0;
172 : }
173 0 : return true;
174 : }
175 :
176 :
177 : // IO routines
178 :
179 : #define GZREAD(ptr,len) (_gzfp?gz_read(_gzfp,ptr,len):0)
180 :
181 1864 : bool HStreamIODev::read1b(unsigned char &out)
182 : {
183 1864 : int res = (compressed) ? GZREAD(rBuf, 1) : _stream->readBytes(rBuf, 1);
184 :
185 1864 : if (res < 1)
186 0 : return false;
187 :
188 1864 : out = (unsigned char)rBuf[0];
189 1864 : return true;
190 : }
191 :
192 0 : bool HStreamIODev::read1b(char &out)
193 : {
194 : unsigned char tmp8;
195 0 : if (!read1b(tmp8))
196 0 : return false;
197 0 : out = tmp8;
198 0 : return true;
199 : }
200 :
201 1295 : bool HStreamIODev::read2b(unsigned short &out)
202 : {
203 1295 : int res = (compressed) ? GZREAD(rBuf, 2) : _stream->readBytes(rBuf, 2);
204 :
205 1295 : if (res < 2)
206 0 : return false;
207 :
208 1295 : out = ((unsigned char) rBuf[1] << 8 | (unsigned char) rBuf[0]);
209 1295 : return true;
210 : }
211 :
212 5 : bool HStreamIODev::read4b(unsigned int &out)
213 : {
214 5 : int res = (compressed) ? GZREAD(rBuf, 4) : _stream->readBytes(rBuf, 4);
215 :
216 5 : if (res < 4)
217 0 : return false;
218 :
219 10 : out = ((unsigned char) rBuf[3] << 24 | (unsigned char) rBuf[2] << 16 |
220 10 : (unsigned char) rBuf[1] << 8 | (unsigned char) rBuf[0]);
221 5 : return true;
222 : }
223 :
224 0 : bool HStreamIODev::read4b(int &out)
225 : {
226 : unsigned int tmp32;
227 0 : if (!read4b(tmp32))
228 0 : return false;
229 0 : out = tmp32;
230 0 : return true;
231 : }
232 :
233 717 : int HStreamIODev::readBlock(void *ptr, int size)
234 : {
235 : int count =
236 715 : (compressed) ? GZREAD(ptr, size) : _stream->readBytes(static_cast<byte *>(ptr),
237 :
238 1432 : size);
239 :
240 717 : return count;
241 : }
242 :
243 0 : int HStreamIODev::skipBlock(int size)
244 : {
245 0 : if (compressed){
246 0 : if( size <= BUFSIZE )
247 0 : return GZREAD(rBuf, size);
248 : else{
249 0 : int remain = size;
250 0 : while(remain){
251 0 : if( remain > BUFSIZE )
252 0 : remain -= GZREAD(rBuf, BUFSIZE);
253 : else{
254 0 : remain -= GZREAD(rBuf, remain);
255 0 : break;
256 : }
257 : }
258 0 : return size - remain;
259 : }
260 : }
261 0 : return _stream->skipBytes(size);
262 : }
263 :
264 :
265 0 : HMemIODev::HMemIODev(char *s, int len)
266 : {
267 0 : init();
268 0 : ptr = reinterpret_cast<uchar *>(s);
269 0 : length = len;
270 0 : }
271 :
272 :
273 0 : HMemIODev::~HMemIODev()
274 : {
275 0 : close();
276 0 : }
277 :
278 :
279 0 : void HMemIODev::init()
280 : {
281 0 : ptr = 0;
282 0 : length = 0;
283 0 : pos = 0;
284 0 : }
285 :
286 :
287 0 : bool HMemIODev::open()
288 : {
289 0 : return true;
290 : }
291 :
292 :
293 0 : void HMemIODev::flush()
294 : {
295 0 : }
296 :
297 :
298 0 : void HMemIODev::close()
299 : {
300 0 : }
301 :
302 :
303 0 : int HMemIODev::state() const
304 : {
305 0 : if (pos <= length)
306 0 : return 0;
307 : else
308 0 : return -1;
309 : }
310 :
311 :
312 0 : bool HMemIODev::setCompressed(bool )
313 : {
314 0 : return false;
315 : }
316 :
317 0 : bool HMemIODev::read1b(unsigned char &out)
318 : {
319 0 : if (pos <= length)
320 : {
321 0 : out = ptr[pos++];
322 0 : return true;
323 : }
324 0 : return false;
325 : }
326 :
327 0 : bool HMemIODev::read1b(char &out)
328 : {
329 : unsigned char tmp8;
330 0 : if (!read1b(tmp8))
331 0 : return false;
332 0 : out = tmp8;
333 0 : return true;
334 : }
335 :
336 0 : bool HMemIODev::read2b(unsigned short &out)
337 : {
338 0 : pos += 2;
339 0 : if (pos <= length)
340 : {
341 0 : out = ptr[pos - 1] << 8 | ptr[pos - 2];
342 0 : return true;
343 : }
344 0 : return false;
345 : }
346 :
347 0 : bool HMemIODev::read4b(unsigned int &out)
348 : {
349 0 : pos += 4;
350 0 : if (pos <= length)
351 : {
352 0 : out = static_cast<unsigned int>(ptr[pos - 1] << 24 | ptr[pos - 2] << 16 |
353 0 : ptr[pos - 3] << 8 | ptr[pos - 4]);
354 0 : return true;
355 : }
356 0 : return false;
357 : }
358 :
359 0 : bool HMemIODev::read4b(int &out)
360 : {
361 : unsigned int tmp32;
362 0 : if (!read4b(tmp32))
363 0 : return false;
364 0 : out = tmp32;
365 0 : return true;
366 : }
367 :
368 0 : int HMemIODev::readBlock(void *p, int size)
369 : {
370 0 : if (length < pos + size)
371 0 : size = length - pos;
372 0 : memcpy(p, ptr + pos, size);
373 0 : pos += size;
374 0 : return size;
375 : }
376 :
377 0 : int HMemIODev::skipBlock(int size)
378 : {
379 0 : if (length < pos + size)
380 0 : return 0;
381 0 : pos += size;
382 0 : return size;
383 : }
384 :
385 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
