hwpfilter/source/hiodev.cxx

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