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