#ifndef UnzInfH
#define UnzInfH
/*

Copyright (c) 1990-2007 Info-ZIP.  All rights reserved.

See the accompanying file LICENSE, version 2007-Mar-4 or later
(the contents of which are also included in zip.h) for terms of use.
If, for some reason, all these files are missing, the Info-ZIP license
also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html

parts Copyright (C) 1997 Mike White, Eric W. Engler
 ************************************************************************
Copyright (C) 2009, 2010  by Russell J. Peters, Roger Aelbrecht

This file is part of TZipMaster Version 1.9.

TZipMaster is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

TZipMaster is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with TZipMaster.  If not, see <http://www.gnu.org/licenses/>.

contact: problems@delphizip.org (include ZipMaster in the subject).
updates: http://www.delphizip.org
DelphiZip maillist subscribe at http://www.freelists.org/list/delphizip
 *********************************************************************** */
#include "dzoper.h"
#include "unzsup.h"
#include "crypt.h"

#define INBUFSIZ  0x8000L // larger buffers for real OSes

// #ifndef WSIZE                   /* default is 32K */
#    define UWSIZE   65536L       // 64K for Inflate64
#  define wsize UWSIZE           /* wsize is a constant */

#define OUTBUFSIZ   0x8000      // EWE: 32K (for unshrink.c)
typedef int shrint;

extern const ush mask_bits[];

/* Huffman code lookup table entry--this entry is four bytes for machines
 * that have 16-bit pointers (e.g. PC's in the small or medium model).
 * Valid extra bits are 0..13.  e == 15 is EOB (end of block), e == 16
 * means that v is a literal, 16 < e < 32 means that v is a pointer to
 * the next table, which codes e - 16 bits, and lastly e == 99 indicates
 * an unused code.  If a code with e == 99 is looked up, this implies an
 * error in the data. */

#pragma pack(push, 4)

struct huft
{
	uch e; /* number of extra bits or operation */
	uch b;
	/* number of bits in this code or subcode */
	union
	{
		ush n; /* literal, length base, or distance base */
		struct huft *t; /* pointer to next level of table */
	}

	v;
};
#pragma pack(pop)

#pragma pack(push, 1)
typedef struct local_file_header
{ /* LOCAL */
	uch version_needed_to_extract[2];
	ush general_purpose_bit_flag;
	ush compression_method;
	ush last_mod_file_time;
	ush last_mod_file_date;
	ulg crc32;
	ZInt64 csize;
	ZInt64 ucsize;
	ush filename_length;
	ush extra_field_length;
}local_file_hdr;
#pragma pack(pop)

#define CRCVAL_INITIAL  0L

class UnzInf : public UnzSup
{
private:
	UnzInf(void);
	UnzInf(const UnzInf&);
	UnzInf& operator = (const UnzInf&);

protected:
	int fP_flag; /* -P: give password on command line (ARGH!) */
	int fnopwd; /* crypt static */
	const char *fkey; /* crypt static: decryption password or NULL */
	DZStrA fpwdarg;
	uch Slide[UWSIZE]; /* explode(), inflate(), unreduce() */

	unsigned fhufts; /* track memory usage */

	struct huft *ffixed_tl; /* inflate static */
	struct huft *ffixed_td; /* inflate static */
	int ffixed_bl; /* inflate static */
	int ffixed_bd; /* inflate static */
	struct huft *ffixed_tl64; /* inflate static */
	struct huft *ffixed_td64; /* inflate static */
	unsigned ffixed_bl64, ffixed_bd64; /* inflate static */
	struct huft *ffixed_tl32; /* inflate static */
	struct huft *ffixed_td32; /* inflate static */
	unsigned ffixed_bl32, ffixed_bd32; /* inflate static */
	const ush *fcplens; /* inflate static */
	const uch *fcplext; /* inflate static */
	const uch *fcpdext; /* inflate static */
	unsigned fwp; /* inflate static: current position in slide */
	ulg fbb; /* inflate static: bit buffer */
	unsigned fbk; /* inflate static: bits in bit buffer */
	local_file_hdr flrec; /* used in unzip.c, extract.c */
	int fPwdReqCount;
	int fnewzip;

	/* used in extract.c, crypt.c, zipinfo.c */
public:
	UnzInf(const DllCommands *C);
	~UnzInf(void);
	int inflate(bool defl64);
	int inflate_free(void);
	int explode(void);

protected:
	int decrypt(ulg crc);

private:
	int inflate_codes(struct huft *tl, struct huft *td, int bl, int bd);
	int huft_build(unsigned *b, unsigned n, unsigned s, const ush * d,
		const uch * e, struct huft **t, int *m);
	int inflate_stored(void);
	int inflate_fixed(void);
	int inflate_dynamic(void);
	int inflate_block(int *e);
	int get_tree(unsigned * l, unsigned n);
	int explode_lit8(struct huft * tb, struct huft * tl, struct huft * td,
		int bb, int bl, int bd);
	int explode_lit4(struct huft * tb, struct huft * tl, struct huft * td,
		int bb, int bl, int bd);
	int explode_nolit8(struct huft * tl, struct huft * td, int bl, int bd);
	int explode_nolit4(struct huft * tl, struct huft * td, int bl, int bd);
	int testkey(const char *h, const char *key, ulg crc);
};

int huft_free(struct huft * t);
#endif