开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
explode.cpp
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：15k
源码类别：

其他游戏

开发平台：

Visual C++

explode.cpp：源码内容
  2. #include <windows.h>
  3. #include <assert.h>
  4. #include <string.h>
  6. #include "mpq.h"
  7. #include "explode.h"
  9. /* Tables */
  10. static unsigned char pkzip_dist_bits[] = {
  11. 0x02, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  12. 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  13. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  14. 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
  15. };
  17. static unsigned char pkzip_dist_code[] = {
  18. 0x03, 0x0D, 0x05, 0x19, 0x09, 0x11, 0x01, 0x3E, 0x1E, 0x2E, 0x0E, 0x36, 0x16, 0x26, 0x06, 0x3A,
  19. 0x1A, 0x2A, 0x0A, 0x32, 0x12, 0x22, 0x42, 0x02, 0x7C, 0x3C, 0x5C, 0x1C, 0x6C, 0x2C, 0x4C, 0x0C,
  20. 0x74, 0x34, 0x54, 0x14, 0x64, 0x24, 0x44, 0x04, 0x78, 0x38, 0x58, 0x18, 0x68, 0x28, 0x48, 0x08,
  21. 0xF0, 0x70, 0xB0, 0x30, 0xD0, 0x50, 0x90, 0x10, 0xE0, 0x60, 0xA0, 0x20, 0xC0, 0x40, 0x80, 0x00
  22. };
  24. static unsigned char pkzip_clen_bits[] = {
  25. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
  26. };
  28. static unsigned short pkzip_len_base[] = {
  29. 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
  30. 0x0008, 0x000A, 0x000E, 0x0016, 0x0026, 0x0046, 0x0086, 0x0106
  31. };
  33. static unsigned char pkzip_slen_bits[] = {
  34. 0x03, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07
  35. };
  37. static unsigned char pkzip_len_code[] = {
  38. 0x05, 0x03, 0x01, 0x06, 0x0A, 0x02, 0x0C, 0x14, 0x04, 0x18, 0x08, 0x30, 0x10, 0x20, 0x40, 0x00
  39. };
  41. static unsigned char pkzip_bits_asc[] = {
  42. 0x0B, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x08, 0x07, 0x0C, 0x0C, 0x07, 0x0C, 0x0C,
  43. 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,
  44. 0x04, 0x0A, 0x08, 0x0C, 0x0A, 0x0C, 0x0A, 0x08, 0x07, 0x07, 0x08, 0x09, 0x07, 0x06, 0x07, 0x08,
  45. 0x07, 0x06, 0x07, 0x07, 0x07, 0x07, 0x08, 0x07, 0x07, 0x08, 0x08, 0x0C, 0x0B, 0x07, 0x09, 0x0B,
  46. 0x0C, 0x06, 0x07, 0x06, 0x06, 0x05, 0x07, 0x08, 0x08, 0x06, 0x0B, 0x09, 0x06, 0x07, 0x06, 0x06,
  47. 0x07, 0x0B, 0x06, 0x06, 0x06, 0x07, 0x09, 0x08, 0x09, 0x09, 0x0B, 0x08, 0x0B, 0x09, 0x0C, 0x08,
  48. 0x0C, 0x05, 0x06, 0x06, 0x06, 0x05, 0x06, 0x06, 0x06, 0x05, 0x0B, 0x07, 0x05, 0x06, 0x05, 0x05,
  49. 0x06, 0x0A, 0x05, 0x05, 0x05, 0x05, 0x08, 0x07, 0x08, 0x08, 0x0A, 0x0B, 0x0B, 0x0C, 0x0C, 0x0C,
  50. 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,
  51. 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,
  52. 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,
  53. 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,
  54. 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,
  55. 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,
  56. 0x0D, 0x0C, 0x0D, 0x0D, 0x0D, 0x0C, 0x0D, 0x0D, 0x0D, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D, 0x0C, 0x0D,
  57. 0x0D, 0x0D, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D
  58. };
  60. static unsigned short pkzip_code_asc[] = {
  61. 0x0490, 0x0FE0, 0x07E0, 0x0BE0, 0x03E0, 0x0DE0, 0x05E0, 0x09E0,
  62. 0x01E0, 0x00B8, 0x0062, 0x0EE0, 0x06E0, 0x0022, 0x0AE0, 0x02E0,
  63. 0x0CE0, 0x04E0, 0x08E0, 0x00E0, 0x0F60, 0x0760, 0x0B60, 0x0360,
  64. 0x0D60, 0x0560, 0x1240, 0x0960, 0x0160, 0x0E60, 0x0660, 0x0A60,
  65. 0x000F, 0x0250, 0x0038, 0x0260, 0x0050, 0x0C60, 0x0390, 0x00D8,
  66. 0x0042, 0x0002, 0x0058, 0x01B0, 0x007C, 0x0029, 0x003C, 0x0098,
  67. 0x005C, 0x0009, 0x001C, 0x006C, 0x002C, 0x004C, 0x0018, 0x000C,
  68. 0x0074, 0x00E8, 0x0068, 0x0460, 0x0090, 0x0034, 0x00B0, 0x0710,
  69. 0x0860, 0x0031, 0x0054, 0x0011, 0x0021, 0x0017, 0x0014, 0x00A8,
  70. 0x0028, 0x0001, 0x0310, 0x0130, 0x003E, 0x0064, 0x001E, 0x002E,
  71. 0x0024, 0x0510, 0x000E, 0x0036, 0x0016, 0x0044, 0x0030, 0x00C8,
  72. 0x01D0, 0x00D0, 0x0110, 0x0048, 0x0610, 0x0150, 0x0060, 0x0088,
  73. 0x0FA0, 0x0007, 0x0026, 0x0006, 0x003A, 0x001B, 0x001A, 0x002A,
  74. 0x000A, 0x000B, 0x0210, 0x0004, 0x0013, 0x0032, 0x0003, 0x001D,
  75. 0x0012, 0x0190, 0x000D, 0x0015, 0x0005, 0x0019, 0x0008, 0x0078,
  76. 0x00F0, 0x0070, 0x0290, 0x0410, 0x0010, 0x07A0, 0x0BA0, 0x03A0,
  77. 0x0240, 0x1C40, 0x0C40, 0x1440, 0x0440, 0x1840, 0x0840, 0x1040,
  78. 0x0040, 0x1F80, 0x0F80, 0x1780, 0x0780, 0x1B80, 0x0B80, 0x1380,
  79. 0x0380, 0x1D80, 0x0D80, 0x1580, 0x0580, 0x1980, 0x0980, 0x1180,
  80. 0x0180, 0x1E80, 0x0E80, 0x1680, 0x0680, 0x1A80, 0x0A80, 0x1280,
  81. 0x0280, 0x1C80, 0x0C80, 0x1480, 0x0480, 0x1880, 0x0880, 0x1080,
  82. 0x0080, 0x1F00, 0x0F00, 0x1700, 0x0700, 0x1B00, 0x0B00, 0x1300,
  83. 0x0DA0, 0x05A0, 0x09A0, 0x01A0, 0x0EA0, 0x06A0, 0x0AA0, 0x02A0,
  84. 0x0CA0, 0x04A0, 0x08A0, 0x00A0, 0x0F20, 0x0720, 0x0B20, 0x0320,
  85. 0x0D20, 0x0520, 0x0920, 0x0120, 0x0E20, 0x0620, 0x0A20, 0x0220,
  86. 0x0C20, 0x0420, 0x0820, 0x0020, 0x0FC0, 0x07C0, 0x0BC0, 0x03C0,
  87. 0x0DC0, 0x05C0, 0x09C0, 0x01C0, 0x0EC0, 0x06C0, 0x0AC0, 0x02C0,
  88. 0x0CC0, 0x04C0, 0x08C0, 0x00C0, 0x0F40, 0x0740, 0x0B40, 0x0340,
  89. 0x0300, 0x0D40, 0x1D00, 0x0D00, 0x1500, 0x0540, 0x0500, 0x1900,
  90. 0x0900, 0x0940, 0x1100, 0x0100, 0x1E00, 0x0E00, 0x0140, 0x1600,
  91. 0x0600, 0x1A00, 0x0E40, 0x0640, 0x0A40, 0x0A00, 0x1200, 0x0200,
  92. 0x1C00, 0x0C00, 0x1400, 0x0400, 0x1800, 0x0800, 0x1000, 0x0000  
  93. };
  95. /* Local variables */
  96. static char copyright[] = "PKWARE Data Compression Library for Win32rn"
  97.                           "Copyright 1989-1995 PKWARE Inc.  All Rights Reservedrn"
  98.                           "Patent No. 5,051,745rn"
  99.                           "PKWARE Data Compression Library Reg. U.S. Pat. and Tm. Off.rn"
  100.                           "Version 1.11rn";
  102. /* Local functions */
  103. static void libmpq_pkzip_gen_decode_tabs(long count, unsigned char *bits, unsigned char *code, unsigned char *buf2) {
  104. long i;
  106. for (i = count-1; i >= 0; i--) { /* EBX - count */
  107. unsigned long idx1 = code[i];
  108. unsigned long idx2 = 1 << bits[i];
  109. do {
  110. buf2[idx1] = (unsigned char)i;
  111. idx1      += idx2;
  112. } while (idx1 < 0x100);
  113. }
  114. }
  116. static void libmpq_pkzip_gen_asc_tabs(pkzip_data_cmp *mpq_pkzip) {
  117. unsigned short *code_asc = &pkzip_code_asc[0xFF];
  118. unsigned long acc, add;
  119. unsigned short count;
  121. for (count = 0x00FF; code_asc >= pkzip_code_asc; code_asc--, count--) {
  122. unsigned char *bits_asc = mpq_pkzip->bits_asc + count;
  123. unsigned char bits_tmp = *bits_asc;
  125. if (bits_tmp <= 8) {
  126. add = (1 << bits_tmp);
  127. acc = *code_asc;
  128. do {
  129. mpq_pkzip->offs_2c34[acc] = (unsigned char)count;
  130. acc += add;
  131. } while (acc < 0x100);
  132. } else {
  133. if ((acc = (*code_asc & 0xFF)) != 0) {
  134. mpq_pkzip->offs_2c34[acc] = 0xFF;
  135. if (*code_asc & 0x3F) {
  136. bits_tmp -= 4;
  137. *bits_asc = bits_tmp;
  138. add = (1 << bits_tmp);
  139. acc = *code_asc >> 4;
  140. do {
  141. mpq_pkzip->offs_2d34[acc] = (unsigned char)count;
  142. acc += add;
  143. } while (acc < 0x100);
  144. } else {
  145. bits_tmp -= 6;
  146. *bits_asc = bits_tmp;
  147. add = (1 << bits_tmp);
  148. acc = *code_asc >> 6;
  149. do {
  150. mpq_pkzip->offs_2e34[acc] = (unsigned char)count;
  151. acc += add;
  152. } while (acc < 0x80);
  153. }
  154. } else {
  155. bits_tmp -= 8;
  156. *bits_asc = bits_tmp;
  157. add = (1 << bits_tmp);
  158. acc = *code_asc >> 8;
  159. do {
  160. mpq_pkzip->offs_2eb4[acc] = (unsigned char)count;
  161. acc += add;
  162. } while (acc < 0x100);
  163. }
  164. }
  165. }
  166. }
  168. /*
  169.  *  Skips given number of bits in bit buffer. Result is stored in mpq_pkzip->bit_buf
  170.  *  If no data in input buffer, returns true
  171.  */
  172. static int libmpq_pkzip_skip_bits(pkzip_data_cmp *mpq_pkzip, unsigned long bits) {
  173. /* If number of bits required is less than number of (bits in the buffer) ? */
  174. if (bits <= mpq_pkzip->extra_bits) {
  175. mpq_pkzip->extra_bits -= bits;
  176. mpq_pkzip->bit_buf >>= bits;
  177. return 0;
  178. }
  180. /* Load input buffer if necessary */
  181. mpq_pkzip->bit_buf >>= mpq_pkzip->extra_bits;
  182. if (mpq_pkzip->in_pos == mpq_pkzip->in_bytes) {
  183. mpq_pkzip->in_pos = sizeof(mpq_pkzip->in_buf);
  184. if ((mpq_pkzip->in_bytes = mpq_pkzip->read_buf((char *)mpq_pkzip->in_buf, &mpq_pkzip->in_pos, mpq_pkzip->param)) == 0) {
  185. return 1;
  186. }
  187. mpq_pkzip->in_pos = 0;
  188. }
  190. /* Update bit buffer */
  191. mpq_pkzip->bit_buf |= (mpq_pkzip->in_buf[mpq_pkzip->in_pos++] << 8);
  192. mpq_pkzip->bit_buf >>= (bits - mpq_pkzip->extra_bits);
  193. mpq_pkzip->extra_bits = (mpq_pkzip->extra_bits - bits) + 8;
  194. return 0;
  195. }
  197. /*
  198.  *  Decompress the imploded data using coded literals.
  199.  *  Returns: 0x000 - 0x0FF : One byte from compressed file.
  200.  *           0x100 - 0x305 : Copy previous block (0x100 = 1 byte)
  201.  *           0x306         : Out of buffer (?)
  202.  */
  203. static unsigned long libmpq_pkzip_explode_lit(pkzip_data_cmp *mpq_pkzip) {
  204. unsigned long bits; /* Number of bits to skip */
  205. unsigned long value; /* Position in buffers */
  207. /* Test the current bit in byte buffer. If is not set, simply return the next byte. */
  208. if (mpq_pkzip->bit_buf & 1) {
  210. /* Skip current bit in the buffer. */
  211. if (libmpq_pkzip_skip_bits(mpq_pkzip, 1)) {
  212. return 0x306;
  213. }
  215. /* The next bits are position in buffers. */
  216. value = mpq_pkzip->pos2[(mpq_pkzip->bit_buf & 0xFF)];
  218. /* Get number of bits to skip */
  219. if (libmpq_pkzip_skip_bits(mpq_pkzip, mpq_pkzip->slen_bits[value])) {
  220. return 0x306;
  221. }
  222. if ((bits = mpq_pkzip->clen_bits[value]) != 0) {
  223. unsigned long val2 = mpq_pkzip->bit_buf & ((1 << bits) - 1);
  224. if (libmpq_pkzip_skip_bits(mpq_pkzip, bits)) {
  225. if ((value + val2) != 0x10E) {
  226. return 0x306;
  227. }
  228. }
  229. value = mpq_pkzip->len_base[value] + val2;
  230. }
  231. return value + 0x100; /* Return number of bytes to repeat */
  232. }
  234. /* Skip one bit */
  235. if (libmpq_pkzip_skip_bits(mpq_pkzip, 1)) {
  236. return 0x306;
  237. }
  239. /* If the binary compression type, read 8 bits and return them as one byte. */
  240. if (mpq_pkzip->cmp_type == LIBMPQ_PKZIP_CMP_BINARY) {
  241. value = mpq_pkzip->bit_buf & 0xFF;
  242. if (libmpq_pkzip_skip_bits(mpq_pkzip, 8)) {
  243. return 0x306;
  244. }
  245. return value;
  246. }
  248. /* When ASCII compression ... */
  249. if (mpq_pkzip->bit_buf & 0xFF) {
  250. value = mpq_pkzip->offs_2c34[mpq_pkzip->bit_buf & 0xFF];
  251. if (value == 0xFF) {
  252. if (mpq_pkzip->bit_buf & 0x3F) {
  253. if (libmpq_pkzip_skip_bits(mpq_pkzip, 4)) {
  254. return 0x306;
  255. }
  256. value = mpq_pkzip->offs_2d34[mpq_pkzip->bit_buf & 0xFF];
  257. } else {
  258. if (libmpq_pkzip_skip_bits(mpq_pkzip, 6)) {
  259. return 0x306;
  260. }
  261. value = mpq_pkzip->offs_2e34[mpq_pkzip->bit_buf & 0x7F];
  262. }
  263. }
  264. } else {
  265. if (libmpq_pkzip_skip_bits(mpq_pkzip, 8)) {
  266. return 0x306;
  267. }
  268. value = mpq_pkzip->offs_2eb4[mpq_pkzip->bit_buf & 0xFF];
  269. }
  270. return libmpq_pkzip_skip_bits(mpq_pkzip, mpq_pkzip->bits_asc[value]) ? 0x306 : value;
  271. }
  273. /*
  274.  *  Retrieves the number of bytes to move back.
  275.  */
  276. static unsigned long libmpq_pkzip_explode_dist(pkzip_data_cmp *mpq_pkzip, unsigned long length) {
  277. unsigned long pos  = mpq_pkzip->pos1[(mpq_pkzip->bit_buf & 0xFF)];
  278. unsigned long skip = mpq_pkzip->dist_bits[pos]; /* Number of bits to skip */
  280. /* Skip the appropriate number of bits */
  281. if (libmpq_pkzip_skip_bits(mpq_pkzip, skip) == 1) {
  282. return 0;
  283. }
  284. if (length == 2) {
  285. pos = (pos << 2) | (mpq_pkzip->bit_buf & 0x03);
  286. if (libmpq_pkzip_skip_bits(mpq_pkzip, 2) == 1) {
  287. return 0;
  288. }
  289. } else {
  290. pos = (pos << mpq_pkzip->dsize_bits) | (mpq_pkzip->bit_buf & mpq_pkzip->dsize_mask);
  292. /* Skip the bits */
  293. if (libmpq_pkzip_skip_bits(mpq_pkzip, mpq_pkzip->dsize_bits) == 1) {
  294. return 0;
  295. }
  296. }
  297. return pos + 1;
  298. }
  300. static unsigned long libmpq_pkzip_expand(pkzip_data_cmp *mpq_pkzip) {
  301. unsigned int copy_bytes; /* Number of bytes to copy */
  302. unsigned long one_byte; /* One byte from compressed file */
  303. unsigned long result;
  305. mpq_pkzip->out_pos = 0x1000; /* Initialize output buffer position */
  307. /* If end of data or error, terminate decompress */
  308. while ((result = one_byte = libmpq_pkzip_explode_lit(mpq_pkzip)) < 0x305) {
  310. /* If one byte is greater than 0x100, means "Repeat n - 0xFE bytes" */
  311. if (one_byte >= 0x100) {
  312. unsigned char *source; /* ECX */
  313. unsigned char *target; /* EDX */
  314. unsigned long copy_length = one_byte - 0xFE;
  315. unsigned long move_back;
  317. /* Get length of data to copy */
  318. if ((move_back = libmpq_pkzip_explode_dist(mpq_pkzip, copy_length)) == 0) {
  319. result = 0x306;
  320. break;
  321. }
  323. /* Target and source pointer */
  324. target = &mpq_pkzip->out_buf[mpq_pkzip->out_pos];
  325. source = target - move_back;
  326. mpq_pkzip->out_pos += copy_length;
  327. while (copy_length-- > 0) {
  328. *target++ = *source++;
  329. }
  330. } else {
  331. mpq_pkzip->out_buf[mpq_pkzip->out_pos++] = (unsigned char)one_byte;
  332. }
  334. /*
  335.  * If number of extracted bytes has reached 1/2 of output buffer,
  336.  * flush output buffer.
  337.  */
  338. if (mpq_pkzip->out_pos >= 0x2000) {
  340. /* Copy decompressed data into user buffer. */
  341. copy_bytes = 0x1000;
  342. mpq_pkzip->write_buf((char *)&mpq_pkzip->out_buf[0x1000], &copy_bytes, mpq_pkzip->param);
  344. /* If there are some data left, keep them alive */
  345. memcpy(mpq_pkzip->out_buf, &mpq_pkzip->out_buf[0x1000], mpq_pkzip->out_pos - 0x1000);
  346. mpq_pkzip->out_pos -= 0x1000;
  347. }
  348. }
  349. copy_bytes = mpq_pkzip->out_pos - 0x1000;
  350. mpq_pkzip->write_buf((char *)&mpq_pkzip->out_buf[0x1000], &copy_bytes, mpq_pkzip->param);
  351. return result;
  352. }
  354. /*
  355.  * Main exploding function.
  356.  */
  357. unsigned int libmpq_pkzip_explode(
  358. unsigned int (*read_buf)(char *buf, unsigned  int *size, void *param),
  359. void (*write_buf)(char *buf, unsigned  int *size, void *param),
  360. char *work_buf,
  361. void *param) {
  363. pkzip_data_cmp *mpq_pkzip = (pkzip_data_cmp *)work_buf;
  365. /* Set the whole work buffer to zeros */
  366. memset(mpq_pkzip, 0, sizeof(pkzip_data_cmp));
  368. /* Initialize work struct and load compressed data */
  369. mpq_pkzip->read_buf   = read_buf;
  370. mpq_pkzip->write_buf  = write_buf;
  371. mpq_pkzip->param      = param;
  372. mpq_pkzip->in_pos     = sizeof(mpq_pkzip->in_buf);
  373. mpq_pkzip->in_bytes   = mpq_pkzip->read_buf((char *)mpq_pkzip->in_buf, &mpq_pkzip->in_pos, mpq_pkzip->param);
  374. if (mpq_pkzip->in_bytes <= 4) {
  375. return LIBMPQ_PKZIP_CMP_BAD_DATA;
  376. }
  377. mpq_pkzip->cmp_type   = mpq_pkzip->in_buf[0]; /* Get the compression type */
  378. mpq_pkzip->dsize_bits = mpq_pkzip->in_buf[1]; /* Get the dictionary size */
  379. mpq_pkzip->bit_buf    = mpq_pkzip->in_buf[2]; /* Initialize 16-bit bit buffer */
  380. mpq_pkzip->extra_bits = 0; /* Extra (over 8) bits */
  381. mpq_pkzip->in_pos     = 3; /* Position in input buffer */
  383. /* Test for the valid dictionary size */
  384. if (4 > mpq_pkzip->dsize_bits || mpq_pkzip->dsize_bits > 6) {
  385. return LIBMPQ_PKZIP_CMP_INV_DICTSIZE;
  386. }
  387. mpq_pkzip->dsize_mask = 0xFFFF >> (0x10 - mpq_pkzip->dsize_bits); /* Shifted by 'sar' instruction */
  388. if (mpq_pkzip->cmp_type != LIBMPQ_PKZIP_CMP_BINARY) {
  389. if (mpq_pkzip->cmp_type != LIBMPQ_PKZIP_CMP_ASCII) {
  390. return LIBMPQ_PKZIP_CMP_INV_MODE;
  391. }
  392. memcpy(mpq_pkzip->bits_asc, pkzip_bits_asc, sizeof(mpq_pkzip->bits_asc));
  393. libmpq_pkzip_gen_asc_tabs(mpq_pkzip);
  394. }
  395. memcpy(mpq_pkzip->slen_bits, pkzip_slen_bits, sizeof(mpq_pkzip->slen_bits));
  396. libmpq_pkzip_gen_decode_tabs(0x10, mpq_pkzip->slen_bits, pkzip_len_code, mpq_pkzip->pos2);
  397. memcpy(mpq_pkzip->clen_bits, pkzip_clen_bits, sizeof(mpq_pkzip->clen_bits));
  398. memcpy(mpq_pkzip->len_base, pkzip_len_base, sizeof(mpq_pkzip->len_base));
  399. memcpy(mpq_pkzip->dist_bits, pkzip_dist_bits, sizeof(mpq_pkzip->dist_bits));
  400. libmpq_pkzip_gen_decode_tabs(0x40, mpq_pkzip->dist_bits, pkzip_dist_code, mpq_pkzip->pos1);
  401. if (libmpq_pkzip_expand(mpq_pkzip) != 0x306) {
  402. return LIBMPQ_PKZIP_CMP_NO_ERROR;
  403. }
  404. return LIBMPQ_PKZIP_CMP_ABORT;
  405. }