SliTaz Repositories

     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/grub4dos/stuff/lzma.diff	Mon May 23 15:51:14 2011 +0200
     1.3 @@ -0,0 +1,1761 @@
     1.4 +From http://code.google.com/p/grub4dos-chenall/issues/detail?id=6
     1.5 +
     1.6 +diff -Naur ../grub4dos-chenall-r63/stage2/common.c ./stage2/common.c
     1.7 +--- grub4dos-chenall-r63/stage2/common.c	2010-11-19 12:41:03.196955000 +0700
     1.8 ++++ grub4dos/stage2/common.c	2010-11-23 21:28:26.509102100 +0700
     1.9 +@@ -143,6 +143,7 @@
    1.10 +   [ERR_WRITE_GZIP_FILE] = "Attempt to write a gzip file",
    1.11 +   [ERR_FUNC_CALL] = "Invalid function call",
    1.12 + //  [ERR_WRITE_TO_NON_MEM_DRIVE] = "Only RAM drives can be written when running in a script",
    1.13 ++  [ERR_NOT_ENOUGH_MEMORY] = "Not enough memory",
    1.14 + 
    1.15 + };
    1.16 + 
    1.17 +diff -Naur ../grub4dos-chenall-r63/stage2/dec_lzma.c ./stage2/dec_lzma.c
    1.18 +--- grub4dos-chenall-r63/stage2/dec_lzma.c	1970-01-01 07:00:00.000000000 +0700
    1.19 ++++ grub4dos/stage2/dec_lzma.c	2010-11-28 22:12:06.452791800 +0700
    1.20 +@@ -0,0 +1,1384 @@
    1.21 ++/*
    1.22 ++ *  GRUB4DOS  --  GRand Unified Bootloader
    1.23 ++ *  Copyright (C) 1999  Free Software Foundation, Inc.
    1.24 ++ *
    1.25 ++ *  This program is free software; you can redistribute it and/or modify
    1.26 ++ *  it under the terms of the GNU General Public License as published by
    1.27 ++ *  the Free Software Foundation; either version 2 of the License, or
    1.28 ++ *  (at your option) any later version.
    1.29 ++ *
    1.30 ++ *  This program is distributed in the hope that it will be useful,
    1.31 ++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    1.32 ++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    1.33 ++ *  GNU General Public License for more details.
    1.34 ++ *
    1.35 ++ *  You should have received a copy of the GNU General Public License
    1.36 ++ *  along with this program; if not, write to the Free Software
    1.37 ++ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    1.38 ++ */
    1.39 ++
    1.40 ++/*
    1.41 ++ *  Most of this file is derives from LZMA SDK 9.12 beta 
    1.42 ++ *  files Types.h, LzmaDec.h, LzmaDec.c by Igor Pavlov
    1.43 ++ *  It has been modified for used in GRUB4DOS.
    1.44 ++ */
    1.45 ++
    1.46 ++#ifndef NO_DECOMPRESSION
    1.47 ++
    1.48 ++#include "shared.h"
    1.49 ++#include "decomp.h"
    1.50 ++
    1.51 ++/* Types.h -- Basic types
    1.52 ++2010-03-11 : Igor Pavlov : Public domain */
    1.53 ++
    1.54 ++#define SZ_OK 0
    1.55 ++
    1.56 ++#define SZ_ERROR_DATA 1
    1.57 ++#define SZ_ERROR_MEM 2
    1.58 ++#define SZ_ERROR_CRC 3
    1.59 ++#define SZ_ERROR_UNSUPPORTED 4
    1.60 ++#define SZ_ERROR_PARAM 5
    1.61 ++#define SZ_ERROR_INPUT_EOF 6
    1.62 ++#define SZ_ERROR_OUTPUT_EOF 7
    1.63 ++#define SZ_ERROR_READ 8
    1.64 ++#define SZ_ERROR_WRITE 9
    1.65 ++#define SZ_ERROR_PROGRESS 10
    1.66 ++#define SZ_ERROR_FAIL 11
    1.67 ++#define SZ_ERROR_THREAD 12
    1.68 ++
    1.69 ++#define SZ_ERROR_ARCHIVE 16
    1.70 ++#define SZ_ERROR_NO_ARCHIVE 17
    1.71 ++
    1.72 ++typedef int SRes;
    1.73 ++typedef int WRes;
    1.74 ++
    1.75 ++#ifndef RINOK
    1.76 ++#define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; }
    1.77 ++#endif
    1.78 ++
    1.79 ++typedef unsigned char Byte;
    1.80 ++typedef short Int16;
    1.81 ++typedef unsigned short UInt16;
    1.82 ++
    1.83 ++typedef int Int32;
    1.84 ++typedef unsigned int UInt32;
    1.85 ++
    1.86 ++typedef long long int Int64;
    1.87 ++typedef unsigned long long int UInt64;
    1.88 ++
    1.89 ++typedef UInt32 SizeT;
    1.90 ++typedef int ptrdiff_t;
    1.91 ++
    1.92 ++typedef int Bool;
    1.93 ++#define True 1
    1.94 ++#define False 0
    1.95 ++
    1.96 ++#define MY_STD_CALL
    1.97 ++#define MY_CDECL
    1.98 ++#define MY_FAST_CALL
    1.99 ++
   1.100 ++typedef struct
   1.101 ++{
   1.102 ++  void *(*Alloc)(void *p, SizeT size);
   1.103 ++  void (*Free)(void *p, void *address); /* address can be 0 */
   1.104 ++} ISzAlloc;
   1.105 ++
   1.106 ++#define IAlloc_Alloc(p, size) (p)->Alloc((p), size)
   1.107 ++#define IAlloc_Free(p, a) (p)->Free((p), a)
   1.108 ++
   1.109 ++/* -------------------------------------------------------------------------- */
   1.110 ++
   1.111 ++/* LzmaDec.h -- LZMA Decoder
   1.112 ++2009-02-07 : Igor Pavlov : Public domain */
   1.113 ++
   1.114 ++/* #define _LZMA_PROB32 */
   1.115 ++/* _LZMA_PROB32 can increase the speed on some CPUs,
   1.116 ++   but memory usage for CLzmaDec::probs will be doubled in that case */
   1.117 ++
   1.118 ++#ifdef _LZMA_PROB32
   1.119 ++#define UIntLzmaProb UInt32
   1.120 ++#else
   1.121 ++#define UIntLzmaProb UInt16
   1.122 ++#endif
   1.123 ++
   1.124 ++
   1.125 ++/* ---------- LZMA Properties ---------- */
   1.126 ++
   1.127 ++#define LZMA_PROPS_SIZE 5
   1.128 ++
   1.129 ++typedef struct _CLzmaProps
   1.130 ++{
   1.131 ++  unsigned lc, lp, pb;
   1.132 ++  UInt32 dicSize;
   1.133 ++} CLzmaProps;
   1.134 ++
   1.135 ++/* LzmaProps_Decode - decodes properties
   1.136 ++Returns:
   1.137 ++  SZ_OK
   1.138 ++  SZ_ERROR_UNSUPPORTED - Unsupported properties
   1.139 ++*/
   1.140 ++
   1.141 ++SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);
   1.142 ++
   1.143 ++
   1.144 ++/* ---------- LZMA Decoder state ---------- */
   1.145 ++
   1.146 ++/* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case.
   1.147 ++   Num bits = log2((2^11 / 31) ^ 22) + 26 < 134 + 26 = 160; */
   1.148 ++
   1.149 ++#define LZMA_REQUIRED_INPUT_MAX 20
   1.150 ++
   1.151 ++typedef struct
   1.152 ++{
   1.153 ++  CLzmaProps prop;
   1.154 ++  UIntLzmaProb *probs;
   1.155 ++  const Byte *buf;
   1.156 ++  UInt32 range, code;
   1.157 ++  Byte   *dic; 
   1.158 ++  UInt32 dicPos;
   1.159 ++  UInt32 dicBufSize;
   1.160 ++  Byte   *inp;
   1.161 ++  UInt32 inpPos, inpSize;
   1.162 ++  UInt32 inpBufSize;
   1.163 ++  UInt32 processedPos;
   1.164 ++  UInt32 checkDicSize;
   1.165 ++  unsigned state;
   1.166 ++  UInt32 reps[4];
   1.167 ++  unsigned remainLen;
   1.168 ++  int needFlush;
   1.169 ++  int needInitState;
   1.170 ++  UInt32 numProbs;
   1.171 ++  unsigned tempBufSize;
   1.172 ++  Byte tempBuf[LZMA_REQUIRED_INPUT_MAX];
   1.173 ++  UInt64 inpFilePos;
   1.174 ++  UInt64 dicFilePos;
   1.175 ++  struct {
   1.176 ++      UInt64 fmax, fpos;
   1.177 ++  } filec, fileu;
   1.178 ++} CLzmaDec;
   1.179 ++
   1.180 ++#define LzmaDec_Construct(p) { (p)->dic = 0; (p)->probs = 0; }
   1.181 ++
   1.182 ++void LzmaDec_Init(CLzmaDec *p);
   1.183 ++
   1.184 ++/* There are two types of LZMA streams:
   1.185 ++     0) Stream with end mark. That end mark adds about 6 bytes to compressed size.
   1.186 ++     1) Stream without end mark. You must know exact uncompressed size to decompress such stream. */
   1.187 ++
   1.188 ++typedef enum
   1.189 ++{
   1.190 ++  LZMA_FINISH_ANY,   /* finish at any point */
   1.191 ++  LZMA_FINISH_END    /* block must be finished at the end */
   1.192 ++} ELzmaFinishMode;
   1.193 ++
   1.194 ++/* ELzmaFinishMode has meaning only if the decoding reaches output limit !!!
   1.195 ++
   1.196 ++   You must use LZMA_FINISH_END, when you know that current output buffer
   1.197 ++   covers last bytes of block. In other cases you must use LZMA_FINISH_ANY.
   1.198 ++
   1.199 ++   If LZMA decoder sees end marker before reaching output limit, it returns SZ_OK,
   1.200 ++   and output value of destLen will be less than output buffer size limit.
   1.201 ++   You can check status result also.
   1.202 ++
   1.203 ++   You can use multiple checks to test data integrity after full decompression:
   1.204 ++     1) Check Result and "status" variable.
   1.205 ++     2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize.
   1.206 ++     3) Check that output(srcLen) = compressedSize, if you know real compressedSize.
   1.207 ++        You must use correct finish mode in that case. */
   1.208 ++
   1.209 ++typedef enum
   1.210 ++{
   1.211 ++  LZMA_STATUS_NOT_SPECIFIED,               /* use main error code instead */
   1.212 ++  LZMA_STATUS_FINISHED_WITH_MARK,          /* stream was finished with end mark. */
   1.213 ++  LZMA_STATUS_NOT_FINISHED,                /* stream was not finished */
   1.214 ++  LZMA_STATUS_NEEDS_MORE_INPUT,            /* you must provide more input bytes */
   1.215 ++  LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK  /* there is probability that stream was finished without end mark */
   1.216 ++} ELzmaStatus;
   1.217 ++
   1.218 ++/* ELzmaStatus is used only as output value for function call */
   1.219 ++
   1.220 ++
   1.221 ++/* ---------- Interfaces ---------- */
   1.222 ++
   1.223 ++/* There are 3 levels of interfaces:
   1.224 ++     1) Dictionary Interface
   1.225 ++     2) Buffer Interface
   1.226 ++     3) One Call Interface
   1.227 ++   You can select any of these interfaces, but don't mix functions from different
   1.228 ++   groups for same object. */
   1.229 ++
   1.230 ++
   1.231 ++/* There are two variants to allocate state for Dictionary Interface:
   1.232 ++     1) LzmaDec_Allocate / LzmaDec_Free
   1.233 ++     2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs
   1.234 ++   You can use variant 2, if you set dictionary buffer manually.
   1.235 ++   For Buffer Interface you must always use variant 1.
   1.236 ++
   1.237 ++LzmaDec_Allocate* can return:
   1.238 ++  SZ_OK
   1.239 ++  SZ_ERROR_MEM         - Memory allocation error
   1.240 ++  SZ_ERROR_UNSUPPORTED - Unsupported properties
   1.241 ++*/
   1.242 ++   
   1.243 ++SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc);
   1.244 ++void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc);
   1.245 ++
   1.246 ++SRes LzmaDec_Allocate(CLzmaDec *state, const Byte *prop, unsigned propsSize, ISzAlloc *alloc);
   1.247 ++void LzmaDec_Free(CLzmaDec *state, ISzAlloc *alloc);
   1.248 ++
   1.249 ++/* ---------- Dictionary Interface ---------- */
   1.250 ++
   1.251 ++/* You can use it, if you want to eliminate the overhead for data copying from
   1.252 ++   dictionary to some other external buffer.
   1.253 ++   You must work with CLzmaDec variables directly in this interface.
   1.254 ++
   1.255 ++   STEPS:
   1.256 ++     LzmaDec_Constr()
   1.257 ++     LzmaDec_Allocate()
   1.258 ++     for (each new stream)
   1.259 ++     {
   1.260 ++       LzmaDec_Init()
   1.261 ++       while (it needs more decompression)
   1.262 ++       {
   1.263 ++         LzmaDec_DecodeToDic()
   1.264 ++         use data from CLzmaDec::dic and update CLzmaDec::dicPos
   1.265 ++       }
   1.266 ++     }
   1.267 ++     LzmaDec_Free()
   1.268 ++*/
   1.269 ++
   1.270 ++/* LzmaDec_DecodeToDic
   1.271 ++   
   1.272 ++   The decoding to internal dictionary buffer (CLzmaDec::dic).
   1.273 ++   You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!
   1.274 ++
   1.275 ++finishMode:
   1.276 ++  It has meaning only if the decoding reaches output limit (dicLimit).
   1.277 ++  LZMA_FINISH_ANY - Decode just dicLimit bytes.
   1.278 ++  LZMA_FINISH_END - Stream must be finished after dicLimit.
   1.279 ++
   1.280 ++Returns:
   1.281 ++  SZ_OK
   1.282 ++    status:
   1.283 ++      LZMA_STATUS_FINISHED_WITH_MARK
   1.284 ++      LZMA_STATUS_NOT_FINISHED
   1.285 ++      LZMA_STATUS_NEEDS_MORE_INPUT
   1.286 ++      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
   1.287 ++  SZ_ERROR_DATA - Data error
   1.288 ++*/
   1.289 ++
   1.290 ++SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,
   1.291 ++    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
   1.292 ++
   1.293 ++
   1.294 ++/* ---------- Buffer Interface ---------- */
   1.295 ++
   1.296 ++/* It's zlib-like interface.
   1.297 ++   See LzmaDec_DecodeToDic description for information about STEPS and return results,
   1.298 ++   but you must use LzmaDec_DecodeToBuf instead of LzmaDec_DecodeToDic and you don't need
   1.299 ++   to work with CLzmaDec variables manually.
   1.300 ++
   1.301 ++finishMode:
   1.302 ++  It has meaning only if the decoding reaches output limit (*destLen).
   1.303 ++  LZMA_FINISH_ANY - Decode just destLen bytes.
   1.304 ++  LZMA_FINISH_END - Stream must be finished after (*destLen).
   1.305 ++*/
   1.306 ++
   1.307 ++SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
   1.308 ++    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
   1.309 ++
   1.310 ++
   1.311 ++/* ---------- One Call Interface ---------- */
   1.312 ++
   1.313 ++/* LzmaDecode
   1.314 ++
   1.315 ++finishMode:
   1.316 ++  It has meaning only if the decoding reaches output limit (*destLen).
   1.317 ++  LZMA_FINISH_ANY - Decode just destLen bytes.
   1.318 ++  LZMA_FINISH_END - Stream must be finished after (*destLen).
   1.319 ++
   1.320 ++Returns:
   1.321 ++  SZ_OK
   1.322 ++    status:
   1.323 ++      LZMA_STATUS_FINISHED_WITH_MARK
   1.324 ++      LZMA_STATUS_NOT_FINISHED
   1.325 ++      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
   1.326 ++  SZ_ERROR_DATA - Data error
   1.327 ++  SZ_ERROR_MEM  - Memory allocation error
   1.328 ++  SZ_ERROR_UNSUPPORTED - Unsupported properties
   1.329 ++  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
   1.330 ++*/
   1.331 ++
   1.332 ++SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
   1.333 ++    const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
   1.334 ++    ELzmaStatus *status, ISzAlloc *alloc);
   1.335 ++
   1.336 ++/* -------------------------------------------------------------------------- */
   1.337 ++
   1.338 ++/* LzmaDec.c -- LZMA Decoder
   1.339 ++2009-09-20 : Igor Pavlov : Public domain */
   1.340 ++
   1.341 ++//#include "LzmaDec.h"
   1.342 ++
   1.343 ++//#include <string.h>
   1.344 ++
   1.345 ++#define kNumTopBits 24
   1.346 ++#define kTopValue ((UInt32)1 << kNumTopBits)
   1.347 ++
   1.348 ++#define kNumBitModelTotalBits 11
   1.349 ++#define kBitModelTotal (1 << kNumBitModelTotalBits)
   1.350 ++#define kNumMoveBits 5
   1.351 ++
   1.352 ++#define RC_INIT_SIZE 5
   1.353 ++
   1.354 ++#define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }
   1.355 ++
   1.356 ++#define TEST_BIT_0(p) ({ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * ttt; (code < bound);})
   1.357 ++#define UPDATE_0(p) range = bound; *(p) = (UIntLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
   1.358 ++#define UPDATE_1(p) range -= bound; code -= bound; *(p) = (UIntLzmaProb)(ttt - (ttt >> kNumMoveBits));
   1.359 ++#define GET_BIT2(p, i, A0, A1) if(TEST_BIT_0(p)) \
   1.360 ++  { UPDATE_0(p); i = (i + i); A0; } else \
   1.361 ++  { UPDATE_1(p); i = (i + i) + 1; A1; }
   1.362 ++#define GET_BIT(p, i) GET_BIT2(p, i, ; , ;)
   1.363 ++
   1.364 ++#define TREE_GET_BIT(probs, i) { GET_BIT((probs + i), i); }
   1.365 ++#define TREE_DECODE(probs, limit, i) \
   1.366 ++  { i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; }
   1.367 ++
   1.368 ++/* #define _LZMA_SIZE_OPT */
   1.369 ++
   1.370 ++#ifdef _LZMA_SIZE_OPT
   1.371 ++#define TREE_6_DECODE(probs, i) TREE_DECODE(probs, (1 << 6), i)
   1.372 ++#else
   1.373 ++#define TREE_6_DECODE(probs, i) \
   1.374 ++  { i = 1; \
   1.375 ++  TREE_GET_BIT(probs, i); \
   1.376 ++  TREE_GET_BIT(probs, i); \
   1.377 ++  TREE_GET_BIT(probs, i); \
   1.378 ++  TREE_GET_BIT(probs, i); \
   1.379 ++  TREE_GET_BIT(probs, i); \
   1.380 ++  TREE_GET_BIT(probs, i); \
   1.381 ++  i -= 0x40; }
   1.382 ++#endif
   1.383 ++
   1.384 ++#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); }
   1.385 ++
   1.386 ++#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
   1.387 ++#define UPDATE_0_CHECK range = bound;
   1.388 ++#define UPDATE_1_CHECK range -= bound; code -= bound;
   1.389 ++#define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \
   1.390 ++  { UPDATE_0_CHECK; i = (i + i); A0; } else \
   1.391 ++  { UPDATE_1_CHECK; i = (i + i) + 1; A1; }
   1.392 ++#define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;)
   1.393 ++#define TREE_DECODE_CHECK(probs, limit, i) \
   1.394 ++  { i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; }
   1.395 ++
   1.396 ++
   1.397 ++#define kNumPosBitsMax 4
   1.398 ++#define kNumPosStatesMax (1 << kNumPosBitsMax)
   1.399 ++
   1.400 ++#define kLenNumLowBits 3
   1.401 ++#define kLenNumLowSymbols (1 << kLenNumLowBits)
   1.402 ++#define kLenNumMidBits 3
   1.403 ++#define kLenNumMidSymbols (1 << kLenNumMidBits)
   1.404 ++#define kLenNumHighBits 8
   1.405 ++#define kLenNumHighSymbols (1 << kLenNumHighBits)
   1.406 ++
   1.407 ++#define LenChoice 0
   1.408 ++#define LenChoice2 (LenChoice + 1)
   1.409 ++#define LenLow (LenChoice2 + 1)
   1.410 ++#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
   1.411 ++#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
   1.412 ++#define kNumLenProbs (LenHigh + kLenNumHighSymbols)
   1.413 ++
   1.414 ++
   1.415 ++#define kNumStates 12
   1.416 ++#define kNumLitStates 7
   1.417 ++
   1.418 ++#define kStartPosModelIndex 4
   1.419 ++#define kEndPosModelIndex 14
   1.420 ++#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
   1.421 ++
   1.422 ++#define kNumPosSlotBits 6
   1.423 ++#define kNumLenToPosStates 4
   1.424 ++
   1.425 ++#define kNumAlignBits 4
   1.426 ++#define kAlignTableSize (1 << kNumAlignBits)
   1.427 ++
   1.428 ++#define kMatchMinLen 2
   1.429 ++#define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols + kLenNumMidSymbols + kLenNumHighSymbols)
   1.430 ++
   1.431 ++#define IsMatch 0
   1.432 ++#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
   1.433 ++#define IsRepG0 (IsRep + kNumStates)
   1.434 ++#define IsRepG1 (IsRepG0 + kNumStates)
   1.435 ++#define IsRepG2 (IsRepG1 + kNumStates)
   1.436 ++#define IsRep0Long (IsRepG2 + kNumStates)
   1.437 ++#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
   1.438 ++#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
   1.439 ++#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
   1.440 ++#define LenCoder (Align + kAlignTableSize)
   1.441 ++#define RepLenCoder (LenCoder + kNumLenProbs)
   1.442 ++#define Literal (RepLenCoder + kNumLenProbs)
   1.443 ++
   1.444 ++#define LZMA_BASE_SIZE 1846
   1.445 ++#define LZMA_LIT_SIZE 768
   1.446 ++
   1.447 ++#define LzmaProps_GetNumProbs(p) ((UInt32)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))
   1.448 ++
   1.449 ++#if Literal != LZMA_BASE_SIZE
   1.450 ++StopCompilingDueBUG
   1.451 ++#endif
   1.452 ++
   1.453 ++#define LZMA_DIC_MIN (1 << 12)
   1.454 ++
   1.455 ++/* First LZMA-symbol is always decoded.
   1.456 ++And it decodes new LZMA-symbols while (buf < bufLimit), but "buf" is without last normalization
   1.457 ++Out:
   1.458 ++  Result:
   1.459 ++    SZ_OK - OK
   1.460 ++    SZ_ERROR_DATA - Error
   1.461 ++  p->remainLen:
   1.462 ++    < kMatchSpecLenStart : normal remain
   1.463 ++    = kMatchSpecLenStart : finished
   1.464 ++    = kMatchSpecLenStart + 1 : Flush marker
   1.465 ++    = kMatchSpecLenStart + 2 : State Init Marker
   1.466 ++*/
   1.467 ++
   1.468 ++static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
   1.469 ++{
   1.470 ++  UIntLzmaProb *probs = p->probs;
   1.471 ++
   1.472 ++  unsigned state = p->state;
   1.473 ++  UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];
   1.474 ++  unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
   1.475 ++  unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1;
   1.476 ++  unsigned lc = p->prop.lc;
   1.477 ++
   1.478 ++  Byte *dic = p->dic;
   1.479 ++  SizeT dicBufSize = p->dicBufSize;
   1.480 ++  SizeT dicPos = p->dicPos;
   1.481 ++  
   1.482 ++  UInt32 processedPos = p->processedPos;
   1.483 ++  UInt32 checkDicSize = p->checkDicSize;
   1.484 ++  unsigned len = 0;
   1.485 ++
   1.486 ++  const Byte *buf = p->buf;
   1.487 ++  UInt32 range = p->range;
   1.488 ++  UInt32 code = p->code;
   1.489 ++
   1.490 ++  do
   1.491 ++  {
   1.492 ++    UIntLzmaProb *prob;
   1.493 ++    UInt32 bound;
   1.494 ++    unsigned ttt;
   1.495 ++    unsigned posState = processedPos & pbMask;
   1.496 ++
   1.497 ++    prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
   1.498 ++    if(TEST_BIT_0(prob))
   1.499 ++    {
   1.500 ++      unsigned symbol;
   1.501 ++      UPDATE_0(prob);
   1.502 ++      prob = probs + Literal;
   1.503 ++      if (checkDicSize != 0 || processedPos != 0)
   1.504 ++        prob += (LZMA_LIT_SIZE * (((processedPos & lpMask) << lc) +
   1.505 ++        (dic[(dicPos == 0 ? dicBufSize : dicPos) - 1] >> (8 - lc))));
   1.506 ++
   1.507 ++      if (state < kNumLitStates)
   1.508 ++      {
   1.509 ++        state -= (state < 4) ? state : 3;
   1.510 ++        symbol = 1;
   1.511 ++        do { GET_BIT(prob + symbol, symbol) } while (symbol < 0x100);
   1.512 ++      }
   1.513 ++      else
   1.514 ++      {
   1.515 ++        unsigned matchByte = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
   1.516 ++        unsigned offs = 0x100;
   1.517 ++        state -= (state < 10) ? 3 : 6;
   1.518 ++        symbol = 1;
   1.519 ++        do
   1.520 ++        {
   1.521 ++          unsigned bit;
   1.522 ++          UIntLzmaProb *probLit;
   1.523 ++          matchByte <<= 1;
   1.524 ++          bit = (matchByte & offs);
   1.525 ++          probLit = prob + offs + bit + symbol;
   1.526 ++          GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit)
   1.527 ++        }
   1.528 ++        while (symbol < 0x100);
   1.529 ++      }
   1.530 ++      dic[dicPos++] = (Byte)symbol;
   1.531 ++      processedPos++;
   1.532 ++      continue;
   1.533 ++    }
   1.534 ++    else
   1.535 ++    {
   1.536 ++      UPDATE_1(prob);
   1.537 ++      prob = probs + IsRep + state;
   1.538 ++      if(TEST_BIT_0(prob))
   1.539 ++      {
   1.540 ++        UPDATE_0(prob);
   1.541 ++        state += kNumStates;
   1.542 ++        prob = probs + LenCoder;
   1.543 ++      }
   1.544 ++      else
   1.545 ++      {
   1.546 ++        UPDATE_1(prob);
   1.547 ++        if (checkDicSize == 0 && processedPos == 0)
   1.548 ++          return SZ_ERROR_DATA;
   1.549 ++        prob = probs + IsRepG0 + state;
   1.550 ++        if(TEST_BIT_0(prob))
   1.551 ++        {
   1.552 ++          UPDATE_0(prob);
   1.553 ++          prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;
   1.554 ++          if(TEST_BIT_0(prob))
   1.555 ++          {
   1.556 ++            UPDATE_0(prob);
   1.557 ++            dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
   1.558 ++            dicPos++;
   1.559 ++            processedPos++;
   1.560 ++            state = state < kNumLitStates ? 9 : 11;
   1.561 ++            continue;
   1.562 ++          }
   1.563 ++          UPDATE_1(prob);
   1.564 ++        }
   1.565 ++        else
   1.566 ++        {
   1.567 ++          UInt32 distance;
   1.568 ++          UPDATE_1(prob);
   1.569 ++          prob = probs + IsRepG1 + state;
   1.570 ++          if(TEST_BIT_0(prob))
   1.571 ++          {
   1.572 ++            UPDATE_0(prob);
   1.573 ++            distance = rep1;
   1.574 ++          }
   1.575 ++          else
   1.576 ++          {
   1.577 ++            UPDATE_1(prob);
   1.578 ++            prob = probs + IsRepG2 + state;
   1.579 ++            if(TEST_BIT_0(prob))
   1.580 ++            {
   1.581 ++              UPDATE_0(prob);
   1.582 ++              distance = rep2;
   1.583 ++            }
   1.584 ++            else
   1.585 ++            {
   1.586 ++              UPDATE_1(prob);
   1.587 ++              distance = rep3;
   1.588 ++              rep3 = rep2;
   1.589 ++            }
   1.590 ++            rep2 = rep1;
   1.591 ++          }
   1.592 ++          rep1 = rep0;
   1.593 ++          rep0 = distance;
   1.594 ++        }
   1.595 ++        state = state < kNumLitStates ? 8 : 11;
   1.596 ++        prob = probs + RepLenCoder;
   1.597 ++      }
   1.598 ++      {
   1.599 ++        unsigned limit, offset;
   1.600 ++        UIntLzmaProb *probLen = prob + LenChoice;
   1.601 ++        if(TEST_BIT_0(probLen))
   1.602 ++        {
   1.603 ++          UPDATE_0(probLen);
   1.604 ++          probLen = prob + LenLow + (posState << kLenNumLowBits);
   1.605 ++          offset = 0;
   1.606 ++          limit = (1 << kLenNumLowBits);
   1.607 ++        }
   1.608 ++        else
   1.609 ++        {
   1.610 ++          UPDATE_1(probLen);
   1.611 ++          probLen = prob + LenChoice2;
   1.612 ++          if(TEST_BIT_0(probLen))
   1.613 ++          {
   1.614 ++            UPDATE_0(probLen);
   1.615 ++            probLen = prob + LenMid + (posState << kLenNumMidBits);
   1.616 ++            offset = kLenNumLowSymbols;
   1.617 ++            limit = (1 << kLenNumMidBits);
   1.618 ++          }
   1.619 ++          else
   1.620 ++          {
   1.621 ++            UPDATE_1(probLen);
   1.622 ++            probLen = prob + LenHigh;
   1.623 ++            offset = kLenNumLowSymbols + kLenNumMidSymbols;
   1.624 ++            limit = (1 << kLenNumHighBits);
   1.625 ++          }
   1.626 ++        }
   1.627 ++        TREE_DECODE(probLen, limit, len);
   1.628 ++        len += offset;
   1.629 ++      }
   1.630 ++
   1.631 ++      if (state >= kNumStates)
   1.632 ++      {
   1.633 ++        UInt32 distance;
   1.634 ++        prob = probs + PosSlot +
   1.635 ++            ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
   1.636 ++        TREE_6_DECODE(prob, distance);
   1.637 ++        if (distance >= kStartPosModelIndex)
   1.638 ++        {
   1.639 ++          unsigned posSlot = (unsigned)distance;
   1.640 ++          int numDirectBits = (int)(((distance >> 1) - 1));
   1.641 ++          distance = (2 | (distance & 1));
   1.642 ++          if (posSlot < kEndPosModelIndex)
   1.643 ++          {
   1.644 ++            distance <<= numDirectBits;
   1.645 ++            prob = probs + SpecPos + distance - posSlot - 1;
   1.646 ++            {
   1.647 ++              UInt32 mask = 1;
   1.648 ++              unsigned i = 1;
   1.649 ++              do
   1.650 ++              {
   1.651 ++                GET_BIT2(prob + i, i, ; , distance |= mask);
   1.652 ++                mask <<= 1;
   1.653 ++              }
   1.654 ++              while (--numDirectBits != 0);
   1.655 ++            }
   1.656 ++          }
   1.657 ++          else
   1.658 ++          {
   1.659 ++            numDirectBits -= kNumAlignBits;
   1.660 ++            do
   1.661 ++            {
   1.662 ++              NORMALIZE
   1.663 ++              range >>= 1;
   1.664 ++              
   1.665 ++              {
   1.666 ++                UInt32 t;
   1.667 ++                code -= range;
   1.668 ++                t = (0 - ((UInt32)code >> 31)); /* (UInt32)((Int32)code >> 31) */
   1.669 ++                distance = (distance << 1) + (t + 1);
   1.670 ++                code += range & t;
   1.671 ++              }
   1.672 ++              /*
   1.673 ++              distance <<= 1;
   1.674 ++              if (code >= range)
   1.675 ++              {
   1.676 ++                code -= range;
   1.677 ++                distance |= 1;
   1.678 ++              }
   1.679 ++              */
   1.680 ++            }
   1.681 ++            while (--numDirectBits != 0);
   1.682 ++            prob = probs + Align;
   1.683 ++            distance <<= kNumAlignBits;
   1.684 ++            {
   1.685 ++              unsigned i = 1;
   1.686 ++              GET_BIT2(prob + i, i, ; , distance |= 1);
   1.687 ++              GET_BIT2(prob + i, i, ; , distance |= 2);
   1.688 ++              GET_BIT2(prob + i, i, ; , distance |= 4);
   1.689 ++              GET_BIT2(prob + i, i, ; , distance |= 8);
   1.690 ++            }
   1.691 ++            if (distance == (UInt32)0xFFFFFFFF)
   1.692 ++            {
   1.693 ++              len += kMatchSpecLenStart;
   1.694 ++              state -= kNumStates;
   1.695 ++              break;
   1.696 ++            }
   1.697 ++          }
   1.698 ++        }
   1.699 ++        rep3 = rep2;
   1.700 ++        rep2 = rep1;
   1.701 ++        rep1 = rep0;
   1.702 ++        rep0 = distance + 1;
   1.703 ++        if (checkDicSize == 0)
   1.704 ++        {
   1.705 ++          if (distance >= processedPos)
   1.706 ++            return SZ_ERROR_DATA;
   1.707 ++        }
   1.708 ++        else if (distance >= checkDicSize)
   1.709 ++          return SZ_ERROR_DATA;
   1.710 ++        state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
   1.711 ++      }
   1.712 ++
   1.713 ++      len += kMatchMinLen;
   1.714 ++
   1.715 ++      if (limit == dicPos)
   1.716 ++        return SZ_ERROR_DATA;
   1.717 ++      {
   1.718 ++        SizeT rem = limit - dicPos;
   1.719 ++        unsigned curLen = ((rem < len) ? (unsigned)rem : len);
   1.720 ++        SizeT pos = (dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0);
   1.721 ++
   1.722 ++        processedPos += curLen;
   1.723 ++
   1.724 ++        len -= curLen;
   1.725 ++        if (pos + curLen <= dicBufSize)
   1.726 ++        {
   1.727 ++          Byte *dest = dic + dicPos;
   1.728 ++          ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
   1.729 ++          const Byte *lim = dest + curLen;
   1.730 ++          dicPos += curLen;
   1.731 ++          do
   1.732 ++            *(dest) = (Byte)(*(dest + src));
   1.733 ++          while (++dest != lim);
   1.734 ++        }
   1.735 ++        else
   1.736 ++        {
   1.737 ++          do
   1.738 ++          {
   1.739 ++            dic[dicPos++] = dic[pos];
   1.740 ++            if (++pos == dicBufSize)
   1.741 ++              pos = 0;
   1.742 ++          }
   1.743 ++          while (--curLen != 0);
   1.744 ++        }
   1.745 ++      }
   1.746 ++    }
   1.747 ++  }
   1.748 ++  while (dicPos < limit && buf < bufLimit);
   1.749 ++  NORMALIZE;
   1.750 ++  p->buf = buf;
   1.751 ++  p->range = range;
   1.752 ++  p->code = code;
   1.753 ++  p->remainLen = len;
   1.754 ++  p->dicPos = dicPos;
   1.755 ++  p->processedPos = processedPos;
   1.756 ++  p->reps[0] = rep0;
   1.757 ++  p->reps[1] = rep1;
   1.758 ++  p->reps[2] = rep2;
   1.759 ++  p->reps[3] = rep3;
   1.760 ++  p->state = state;
   1.761 ++
   1.762 ++  return SZ_OK;
   1.763 ++}
   1.764 ++
   1.765 ++static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
   1.766 ++{
   1.767 ++  if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart)
   1.768 ++  {
   1.769 ++    Byte *dic = p->dic;
   1.770 ++    SizeT dicPos = p->dicPos;
   1.771 ++    SizeT dicBufSize = p->dicBufSize;
   1.772 ++    unsigned len = p->remainLen;
   1.773 ++    UInt32 rep0 = p->reps[0];
   1.774 ++    if (limit - dicPos < len)
   1.775 ++      len = (unsigned)(limit - dicPos);
   1.776 ++
   1.777 ++    if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)
   1.778 ++      p->checkDicSize = p->prop.dicSize;
   1.779 ++
   1.780 ++    p->processedPos += len;
   1.781 ++    p->remainLen -= len;
   1.782 ++    while (len-- != 0)
   1.783 ++    {
   1.784 ++      dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
   1.785 ++      dicPos++;
   1.786 ++    }
   1.787 ++    p->dicPos = dicPos;
   1.788 ++  }
   1.789 ++}
   1.790 ++
   1.791 ++static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
   1.792 ++{
   1.793 ++  do
   1.794 ++  {
   1.795 ++    SizeT limit2 = limit;
   1.796 ++    if (p->checkDicSize == 0)
   1.797 ++    {
   1.798 ++      UInt32 rem = p->prop.dicSize - p->processedPos;
   1.799 ++      if (limit - p->dicPos > rem)
   1.800 ++        limit2 = p->dicPos + rem;
   1.801 ++    }
   1.802 ++    RINOK(LzmaDec_DecodeReal(p, limit2, bufLimit));
   1.803 ++    if (p->processedPos >= p->prop.dicSize)
   1.804 ++      p->checkDicSize = p->prop.dicSize;
   1.805 ++    LzmaDec_WriteRem(p, limit);
   1.806 ++  }
   1.807 ++  while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);
   1.808 ++
   1.809 ++  if (p->remainLen > kMatchSpecLenStart)
   1.810 ++  {
   1.811 ++    p->remainLen = kMatchSpecLenStart;
   1.812 ++  }
   1.813 ++  return 0;
   1.814 ++}
   1.815 ++
   1.816 ++typedef enum
   1.817 ++{
   1.818 ++  DUMMY_ERROR, /* unexpected end of input stream */
   1.819 ++  DUMMY_LIT,
   1.820 ++  DUMMY_MATCH,
   1.821 ++  DUMMY_REP
   1.822 ++} ELzmaDummy;
   1.823 ++
   1.824 ++static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize)
   1.825 ++{
   1.826 ++  UInt32 range = p->range;
   1.827 ++  UInt32 code = p->code;
   1.828 ++  const Byte *bufLimit = buf + inSize;
   1.829 ++  UIntLzmaProb *probs = p->probs;
   1.830 ++  unsigned state = p->state;
   1.831 ++  ELzmaDummy res;
   1.832 ++
   1.833 ++  {
   1.834 ++    UIntLzmaProb *prob;
   1.835 ++    UInt32 bound;
   1.836 ++    unsigned ttt;
   1.837 ++    unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1);
   1.838 ++
   1.839 ++    prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
   1.840 ++    IF_BIT_0_CHECK(prob)
   1.841 ++    {
   1.842 ++      UPDATE_0_CHECK
   1.843 ++
   1.844 ++      /* if (bufLimit - buf >= 7) return DUMMY_LIT; */
   1.845 ++
   1.846 ++      prob = probs + Literal;
   1.847 ++      if (p->checkDicSize != 0 || p->processedPos != 0)
   1.848 ++        prob += (LZMA_LIT_SIZE *
   1.849 ++          ((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) +
   1.850 ++          (p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));
   1.851 ++
   1.852 ++      if (state < kNumLitStates)
   1.853 ++      {
   1.854 ++        unsigned symbol = 1;
   1.855 ++        do { GET_BIT_CHECK(prob + symbol, symbol) } while (symbol < 0x100);
   1.856 ++      }
   1.857 ++      else
   1.858 ++      {
   1.859 ++        unsigned matchByte = p->dic[p->dicPos - p->reps[0] +
   1.860 ++            ((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)];
   1.861 ++        unsigned offs = 0x100;
   1.862 ++        unsigned symbol = 1;
   1.863 ++        do
   1.864 ++        {
   1.865 ++          unsigned bit;
   1.866 ++          UIntLzmaProb *probLit;
   1.867 ++          matchByte <<= 1;
   1.868 ++          bit = (matchByte & offs);
   1.869 ++          probLit = prob + offs + bit + symbol;
   1.870 ++          GET_BIT2_CHECK(probLit, symbol, offs &= ~bit, offs &= bit)
   1.871 ++        }
   1.872 ++        while (symbol < 0x100);
   1.873 ++      }
   1.874 ++      res = DUMMY_LIT;
   1.875 ++    }
   1.876 ++    else
   1.877 ++    {
   1.878 ++      unsigned len;
   1.879 ++      UPDATE_1_CHECK;
   1.880 ++
   1.881 ++      prob = probs + IsRep + state;
   1.882 ++      IF_BIT_0_CHECK(prob)
   1.883 ++      {
   1.884 ++        UPDATE_0_CHECK;
   1.885 ++        state = 0;
   1.886 ++        prob = probs + LenCoder;
   1.887 ++        res = DUMMY_MATCH;
   1.888 ++      }
   1.889 ++      else
   1.890 ++      {
   1.891 ++        UPDATE_1_CHECK;
   1.892 ++        res = DUMMY_REP;
   1.893 ++        prob = probs + IsRepG0 + state;
   1.894 ++        IF_BIT_0_CHECK(prob)
   1.895 ++        {
   1.896 ++          UPDATE_0_CHECK;
   1.897 ++          prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;
   1.898 ++          IF_BIT_0_CHECK(prob)
   1.899 ++          {
   1.900 ++            UPDATE_0_CHECK;
   1.901 ++            NORMALIZE_CHECK;
   1.902 ++            return DUMMY_REP;
   1.903 ++          }
   1.904 ++          else
   1.905 ++          {
   1.906 ++            UPDATE_1_CHECK;
   1.907 ++          }
   1.908 ++        }
   1.909 ++        else
   1.910 ++        {
   1.911 ++          UPDATE_1_CHECK;
   1.912 ++          prob = probs + IsRepG1 + state;
   1.913 ++          IF_BIT_0_CHECK(prob)
   1.914 ++          {
   1.915 ++            UPDATE_0_CHECK;
   1.916 ++          }
   1.917 ++          else
   1.918 ++          {
   1.919 ++            UPDATE_1_CHECK;
   1.920 ++            prob = probs + IsRepG2 + state;
   1.921 ++            IF_BIT_0_CHECK(prob)
   1.922 ++            {
   1.923 ++              UPDATE_0_CHECK;
   1.924 ++            }
   1.925 ++            else
   1.926 ++            {
   1.927 ++              UPDATE_1_CHECK;
   1.928 ++            }
   1.929 ++          }
   1.930 ++        }
   1.931 ++        state = kNumStates;
   1.932 ++        prob = probs + RepLenCoder;
   1.933 ++      }
   1.934 ++      {
   1.935 ++        unsigned limit, offset;
   1.936 ++        UIntLzmaProb *probLen = prob + LenChoice;
   1.937 ++        IF_BIT_0_CHECK(probLen)
   1.938 ++        {
   1.939 ++          UPDATE_0_CHECK;
   1.940 ++          probLen = prob + LenLow + (posState << kLenNumLowBits);
   1.941 ++          offset = 0;
   1.942 ++          limit = 1 << kLenNumLowBits;
   1.943 ++        }
   1.944 ++        else
   1.945 ++        {
   1.946 ++          UPDATE_1_CHECK;
   1.947 ++          probLen = prob + LenChoice2;
   1.948 ++          IF_BIT_0_CHECK(probLen)
   1.949 ++          {
   1.950 ++            UPDATE_0_CHECK;
   1.951 ++            probLen = prob + LenMid + (posState << kLenNumMidBits);
   1.952 ++            offset = kLenNumLowSymbols;
   1.953 ++            limit = 1 << kLenNumMidBits;
   1.954 ++          }
   1.955 ++          else
   1.956 ++          {
   1.957 ++            UPDATE_1_CHECK;
   1.958 ++            probLen = prob + LenHigh;
   1.959 ++            offset = kLenNumLowSymbols + kLenNumMidSymbols;
   1.960 ++            limit = 1 << kLenNumHighBits;
   1.961 ++          }
   1.962 ++        }
   1.963 ++        TREE_DECODE_CHECK(probLen, limit, len);
   1.964 ++        len += offset;
   1.965 ++      }
   1.966 ++
   1.967 ++      if (state < 4)
   1.968 ++      {
   1.969 ++        unsigned posSlot;
   1.970 ++        prob = probs + PosSlot +
   1.971 ++            ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<
   1.972 ++            kNumPosSlotBits);
   1.973 ++        TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot);
   1.974 ++        if (posSlot >= kStartPosModelIndex)
   1.975 ++        {
   1.976 ++          int numDirectBits = ((posSlot >> 1) - 1);
   1.977 ++
   1.978 ++          /* if (bufLimit - buf >= 8) return DUMMY_MATCH; */
   1.979 ++
   1.980 ++          if (posSlot < kEndPosModelIndex)
   1.981 ++          {
   1.982 ++            prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits) - posSlot - 1;
   1.983 ++          }
   1.984 ++          else
   1.985 ++          {
   1.986 ++            numDirectBits -= kNumAlignBits;
   1.987 ++            do
   1.988 ++            {
   1.989 ++              NORMALIZE_CHECK
   1.990 ++              range >>= 1;
   1.991 ++              code -= range & (((code - range) >> 31) - 1);
   1.992 ++              /* if (code >= range) code -= range; */
   1.993 ++            }
   1.994 ++            while (--numDirectBits != 0);
   1.995 ++            prob = probs + Align;
   1.996 ++            numDirectBits = kNumAlignBits;
   1.997 ++          }
   1.998 ++          {
   1.999 ++            unsigned i = 1;
  1.1000 ++            do
  1.1001 ++            {
  1.1002 ++              GET_BIT_CHECK(prob + i, i);
  1.1003 ++            }
  1.1004 ++            while (--numDirectBits != 0);
  1.1005 ++          }
  1.1006 ++        }
  1.1007 ++      }
  1.1008 ++    }
  1.1009 ++  }
  1.1010 ++  NORMALIZE_CHECK;
  1.1011 ++  return res;
  1.1012 ++}
  1.1013 ++
  1.1014 ++
  1.1015 ++static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data)
  1.1016 ++{
  1.1017 ++  p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]);
  1.1018 ++  p->range = 0xFFFFFFFF;
  1.1019 ++  p->needFlush = 0;
  1.1020 ++}
  1.1021 ++
  1.1022 ++void LzmaDec_Init(CLzmaDec *p)
  1.1023 ++{
  1.1024 ++  p->dicFilePos = 0;
  1.1025 ++  p->dicPos = 0;
  1.1026 ++  p->needFlush = 1;
  1.1027 ++  p->remainLen = 0;
  1.1028 ++  p->tempBufSize = 0;
  1.1029 ++  p->processedPos = 0;
  1.1030 ++  p->checkDicSize = 0;
  1.1031 ++  p->needInitState = 1;
  1.1032 ++  p->needInitState = 1;
  1.1033 ++}
  1.1034 ++
  1.1035 ++static void LzmaDec_InitStateReal(CLzmaDec *p)
  1.1036 ++{
  1.1037 ++  UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp));
  1.1038 ++  UInt32 i;
  1.1039 ++  UIntLzmaProb *probs = p->probs;
  1.1040 ++  for (i = 0; i < numProbs; i++)
  1.1041 ++    probs[i] = kBitModelTotal >> 1;
  1.1042 ++  p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;
  1.1043 ++  p->state = 0;
  1.1044 ++  p->needInitState = 0;
  1.1045 ++}
  1.1046 ++
  1.1047 ++SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,
  1.1048 ++    ELzmaFinishMode finishMode, ELzmaStatus *status)
  1.1049 ++{
  1.1050 ++  SizeT inSize = *srcLen;
  1.1051 ++  (*srcLen) = 0;
  1.1052 ++  LzmaDec_WriteRem(p, dicLimit);
  1.1053 ++  
  1.1054 ++  *status = LZMA_STATUS_NOT_SPECIFIED;
  1.1055 ++
  1.1056 ++  while (p->remainLen != kMatchSpecLenStart)
  1.1057 ++  {
  1.1058 ++      int checkEndMarkNow;
  1.1059 ++
  1.1060 ++      if (p->needFlush != 0)
  1.1061 ++      {
  1.1062 ++        for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--)
  1.1063 ++          p->tempBuf[p->tempBufSize++] = *src++;
  1.1064 ++        if (p->tempBufSize < RC_INIT_SIZE)
  1.1065 ++        {
  1.1066 ++          *status = LZMA_STATUS_NEEDS_MORE_INPUT;
  1.1067 ++          return SZ_OK;
  1.1068 ++        }
  1.1069 ++        if (p->tempBuf[0] != 0)
  1.1070 ++          return SZ_ERROR_DATA;
  1.1071 ++
  1.1072 ++        LzmaDec_InitRc(p, p->tempBuf);
  1.1073 ++        p->tempBufSize = 0;
  1.1074 ++      }
  1.1075 ++
  1.1076 ++      checkEndMarkNow = 0;
  1.1077 ++      if (p->dicPos >= dicLimit)
  1.1078 ++      {
  1.1079 ++        if (p->remainLen == 0 && p->code == 0)
  1.1080 ++        {
  1.1081 ++          *status = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK;
  1.1082 ++          return SZ_OK;
  1.1083 ++        }
  1.1084 ++        if (finishMode == LZMA_FINISH_ANY)
  1.1085 ++        {
  1.1086 ++          *status = LZMA_STATUS_NOT_FINISHED;
  1.1087 ++          return SZ_OK;
  1.1088 ++        }
  1.1089 ++        if (p->remainLen != 0)
  1.1090 ++        {
  1.1091 ++          *status = LZMA_STATUS_NOT_FINISHED;
  1.1092 ++          return SZ_ERROR_DATA;
  1.1093 ++        }
  1.1094 ++        checkEndMarkNow = 1;
  1.1095 ++      }
  1.1096 ++
  1.1097 ++      if (p->needInitState)
  1.1098 ++        LzmaDec_InitStateReal(p);
  1.1099 ++  
  1.1100 ++      if (p->tempBufSize == 0)
  1.1101 ++      {
  1.1102 ++        SizeT processed;
  1.1103 ++        const Byte *bufLimit;
  1.1104 ++        if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
  1.1105 ++        {
  1.1106 ++          int dummyRes = LzmaDec_TryDummy(p, src, inSize);
  1.1107 ++          if (dummyRes == DUMMY_ERROR)
  1.1108 ++          {
  1.1109 ++            memcpy(p->tempBuf, src, inSize);
  1.1110 ++            p->tempBufSize = (unsigned)inSize;
  1.1111 ++            (*srcLen) += inSize;
  1.1112 ++            *status = LZMA_STATUS_NEEDS_MORE_INPUT;
  1.1113 ++            return SZ_OK;
  1.1114 ++          }
  1.1115 ++          if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
  1.1116 ++          {
  1.1117 ++            *status = LZMA_STATUS_NOT_FINISHED;
  1.1118 ++            return SZ_ERROR_DATA;
  1.1119 ++          }
  1.1120 ++          bufLimit = src;
  1.1121 ++        }
  1.1122 ++        else
  1.1123 ++          bufLimit = src + inSize - LZMA_REQUIRED_INPUT_MAX;
  1.1124 ++        p->buf = src;
  1.1125 ++        if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0)
  1.1126 ++          return SZ_ERROR_DATA;
  1.1127 ++        processed = (SizeT)(p->buf - src);
  1.1128 ++        (*srcLen) += processed;
  1.1129 ++        src += processed;
  1.1130 ++        inSize -= processed;
  1.1131 ++      }
  1.1132 ++      else
  1.1133 ++      {
  1.1134 ++        unsigned rem = p->tempBufSize, lookAhead = 0;
  1.1135 ++        while (rem < LZMA_REQUIRED_INPUT_MAX && lookAhead < inSize)
  1.1136 ++          p->tempBuf[rem++] = src[lookAhead++];
  1.1137 ++        p->tempBufSize = rem;
  1.1138 ++        if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
  1.1139 ++        {
  1.1140 ++          int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, rem);
  1.1141 ++          if (dummyRes == DUMMY_ERROR)
  1.1142 ++          {
  1.1143 ++            (*srcLen) += lookAhead;
  1.1144 ++            *status = LZMA_STATUS_NEEDS_MORE_INPUT;
  1.1145 ++            return SZ_OK;
  1.1146 ++          }
  1.1147 ++          if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
  1.1148 ++          {
  1.1149 ++            *status = LZMA_STATUS_NOT_FINISHED;
  1.1150 ++            return SZ_ERROR_DATA;
  1.1151 ++          }
  1.1152 ++        }
  1.1153 ++        p->buf = p->tempBuf;
  1.1154 ++        if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)
  1.1155 ++          return SZ_ERROR_DATA;
  1.1156 ++        lookAhead -= (rem - (unsigned)(p->buf - p->tempBuf));
  1.1157 ++        (*srcLen) += lookAhead;
  1.1158 ++        src += lookAhead;
  1.1159 ++        inSize -= lookAhead;
  1.1160 ++        p->tempBufSize = 0;
  1.1161 ++      }
  1.1162 ++  }
  1.1163 ++  if (p->code == 0)
  1.1164 ++    *status = LZMA_STATUS_FINISHED_WITH_MARK;
  1.1165 ++  return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA;
  1.1166 ++}
  1.1167 ++
  1.1168 ++/* -------------------------------------------------------------------------- */
  1.1169 ++
  1.1170 ++#define ReadUnalignedUInt32(p) ((UInt32)((Byte*)(p))[0] | ((UInt32)((Byte*)(p))[1]<<8) | ((UInt32)((Byte*)(p))[2]<<16) | ((UInt32)((Byte*)(p))[3]<<24))
  1.1171 ++#define ReadUnalignedUInt64(p) (ReadUnalignedUInt32(p) | ((UInt64)ReadUnalignedUInt32((Byte*)(p)+4)<<32))
  1.1172 ++
  1.1173 ++CLzmaDec lzmadec;
  1.1174 ++
  1.1175 ++static unsigned long malloc_top = 0;
  1.1176 ++static void *grub_malloc(unsigned long size)
  1.1177 ++{
  1.1178 ++       if (!malloc_top)
  1.1179 ++               malloc_top = RAW_ADDR ((saved_mem_upper << 10) + 0x100000);
  1.1180 ++       malloc_top = (malloc_top - size) & ~3;
  1.1181 ++       return (void *) malloc_top;
  1.1182 ++}
  1.1183 ++#define grub_free(x)
  1.1184 ++
  1.1185 ++int
  1.1186 ++dec_lzma_open (void)
  1.1187 ++// return 1=success or 0=failure
  1.1188 ++{
  1.1189 ++    unsigned char header[13];
  1.1190 ++    unsigned char d;
  1.1191 ++
  1.1192 ++    if (no_decompression) return 0;
  1.1193 ++
  1.1194 ++    // Now it does not support openning more than 1 file at a time. 
  1.1195 ++    // Make sure previously allocated memory blocks is freed. 
  1.1196 ++    // Don't need this line if grub_close is called for every openned file before grub_open is called for next file.
  1.1197 ++    dec_lzma_close();
  1.1198 ++
  1.1199 ++    filepos = 0;
  1.1200 ++    if (grub_read ((char *)header, 13, 0xedde0d90) == 13) 
  1.1201 ++    {
  1.1202 ++	// check header
  1.1203 ++	lzmadec.prop.dicSize = ReadUnalignedUInt32(header+1);
  1.1204 ++	if (lzmadec.prop.dicSize < LZMA_DIC_MIN)
  1.1205 ++	    lzmadec.prop.dicSize = LZMA_DIC_MIN;
  1.1206 ++	d = header[0];
  1.1207 ++	if (d < 9*5*5)
  1.1208 ++	{
  1.1209 ++	    // valid LZMA file
  1.1210 ++	    lzmadec.prop.lc = d % 9; d /= 9;
  1.1211 ++	    lzmadec.prop.lp = d % 5;
  1.1212 ++	    lzmadec.prop.pb = d / 5;
  1.1213 ++	    lzmadec.fileu.fmax = ReadUnalignedUInt64(header+5);
  1.1214 ++	    lzmadec.fileu.fpos = 0;
  1.1215 ++	    lzmadec.dicBufSize = lzmadec.prop.dicSize;
  1.1216 ++	    lzmadec.dic = (Byte*) grub_malloc(lzmadec.dicBufSize);
  1.1217 ++	    //grub_printf("LZMA allocate memory\n");
  1.1218 ++	    if (lzmadec.dic)
  1.1219 ++	    {
  1.1220 ++		lzmadec.numProbs = LzmaProps_GetNumProbs(&lzmadec.prop);
  1.1221 ++		lzmadec.probs = (UIntLzmaProb *) grub_malloc(lzmadec.numProbs * sizeof(UIntLzmaProb));
  1.1222 ++		if (lzmadec.probs)
  1.1223 ++		{
  1.1224 ++		    lzmadec.inpBufSize = 0x8000;
  1.1225 ++		    lzmadec.inp = (Byte*) grub_malloc(lzmadec.inpBufSize);
  1.1226 ++		    if (lzmadec.inp)
  1.1227 ++		    {
  1.1228 ++			lzmadec.inpFilePos = 0;
  1.1229 ++			lzmadec.inpPos = 0;
  1.1230 ++			lzmadec.inpSize = 0;
  1.1231 ++			LzmaDec_Init(&lzmadec);
  1.1232 ++			decomp_type = 1;
  1.1233 ++			compressed_file = 1;
  1.1234 ++			lzmadec.filec.fmax = filemax; filemax = lzmadec.fileu.fmax;
  1.1235 ++			lzmadec.filec.fpos = filepos; filepos = lzmadec.fileu.fpos;
  1.1236 ++			// success
  1.1237 ++			//grub_printf("LZMA open success\n");
  1.1238 ++			errnum = 0;
  1.1239 ++			return 1;
  1.1240 ++		    }
  1.1241 ++		    else
  1.1242 ++		    {
  1.1243 ++			errnum = ERR_NOT_ENOUGH_MEMORY;
  1.1244 ++		    }
  1.1245 ++		    grub_free(lzmadec.probs); lzmadec.probs = 0;
  1.1246 ++		}
  1.1247 ++		else
  1.1248 ++		{
  1.1249 ++		    errnum = ERR_NOT_ENOUGH_MEMORY;
  1.1250 ++		}
  1.1251 ++		grub_free(lzmadec.dic); lzmadec.dic = 0;
  1.1252 ++	    }
  1.1253 ++	    else
  1.1254 ++	    {
  1.1255 ++		errnum = ERR_NOT_ENOUGH_MEMORY;
  1.1256 ++	    }
  1.1257 ++	}
  1.1258 ++	else
  1.1259 ++	{
  1.1260 ++	    //grub_printf("LZMA allocate memory\n");
  1.1261 ++	    errnum = ERR_BAD_GZIP_HEADER;
  1.1262 ++	}
  1.1263 ++    }
  1.1264 ++    else
  1.1265 ++    {
  1.1266 ++	//grub_printf("LZMA error reading header\n");
  1.1267 ++	errnum = ERR_BAD_GZIP_HEADER;
  1.1268 ++    }
  1.1269 ++    //grub_printf("LZMA open fail\n");
  1.1270 ++    filepos = 0;
  1.1271 ++    return 0;
  1.1272 ++}
  1.1273 ++
  1.1274 ++void
  1.1275 ++dec_lzma_close (void)
  1.1276 ++{
  1.1277 ++    if (lzmadec.inp  ) { grub_free(lzmadec.inp  ); lzmadec.inp   = 0; }
  1.1278 ++    if (lzmadec.dic  ) { grub_free(lzmadec.dic  ); lzmadec.dic   = 0; }
  1.1279 ++    if (lzmadec.probs) { grub_free(lzmadec.probs); lzmadec.probs = 0; }
  1.1280 ++}
  1.1281 ++
  1.1282 ++unsigned long
  1.1283 ++dec_lzma_read (char *buf, unsigned long len, unsigned long write)
  1.1284 ++{
  1.1285 ++    UInt64 outTx, outSkip;
  1.1286 ++    //grub_printf("LZMA read buf=%ld len=%ld dic=%d inp=%d\n",buf,len,lzmadec.dic,lzmadec.inp);
  1.1287 ++
  1.1288 ++    compressed_file = 0;
  1.1289 ++    lzmadec.fileu.fmax = filemax; filemax = lzmadec.filec.fmax;
  1.1290 ++    lzmadec.fileu.fpos = filepos; filepos = lzmadec.filec.fpos;
  1.1291 ++    /* Now filepos, filemax is of compressed file 
  1.1292 ++     * fileu.fpos, fileu.fmax is of uncompressed data
  1.1293 ++     * filec is not used
  1.1294 ++     */
  1.1295 ++
  1.1296 ++    /*
  1.1297 ++     * When dicPos>0,
  1.1298 ++     *   dic[0 ... dicPos-1] contains 
  1.1299 ++     *   uncompressed_data [dicFilePos ... dicFilePos+dicPos-1].
  1.1300 ++     * When dicFilePos>0,
  1.1301 ++     *   dic[dicPos ... dicBufSize-1] contains 
  1.1302 ++     *   uncompressed_data [dicFilePos-dicBufSize+dicFilePos ... dicFilePos-1]
  1.1303 ++     */
  1.1304 ++    /* do we reset decompression to the beginning of the file? */
  1.1305 ++    if (lzmadec.dicFilePos && (lzmadec.fileu.fpos < lzmadec.dicFilePos-lzmadec.dicBufSize+lzmadec.dicFilePos))
  1.1306 ++    {
  1.1307 ++	LzmaDec_Init(&lzmadec);
  1.1308 ++	filepos = 13;
  1.1309 ++	lzmadec.inpPos = lzmadec.inpSize = 0;
  1.1310 ++    }
  1.1311 ++
  1.1312 ++    outTx = 0;
  1.1313 ++    outSkip = lzmadec.fileu.fpos - lzmadec.dicFilePos;
  1.1314 ++    //grub_printf("fileu.fpos=%ld dicFilePos=%ld\n",lzmadec.fileu.fpos,lzmadec.dicFilePos);
  1.1315 ++
  1.1316 ++    /* Copy uncompressed data from upper part of dic. dic[dicPos]...dic[dicBufSize-1] */
  1.1317 ++    if (lzmadec.dicFilePos > lzmadec.fileu.fpos)
  1.1318 ++    {
  1.1319 ++	UInt32 outTxCur = lzmadec.dicFilePos - lzmadec.fileu.fpos;
  1.1320 ++	if (outTxCur > len) outTxCur = len;
  1.1321 ++	if (buf)
  1.1322 ++	{
  1.1323 ++	    grub_memmove(buf, lzmadec.dic+outSkip+lzmadec.dicBufSize, outTxCur); 
  1.1324 ++	    buf += outTxCur; 
  1.1325 ++	}
  1.1326 ++	outSkip = 0;
  1.1327 ++	outTx += outTxCur; 
  1.1328 ++	lzmadec.fileu.fpos += outTxCur; 
  1.1329 ++	len -= outTxCur; 
  1.1330 ++    }
  1.1331 ++
  1.1332 ++    while (len!=0)
  1.1333 ++    {
  1.1334 ++	SizeT inSizeCur, dicLimit;
  1.1335 ++	UInt32 dicPos;
  1.1336 ++	ELzmaStatus status;
  1.1337 ++	SRes res;
  1.1338 ++
  1.1339 ++	/* Copy uncompressed data from lower part of dic. dic[0]...dic[dicPos-1] */
  1.1340 ++	//grub_printf("Loop len=%ld outSkip=%ld dicPos=%d\n",len,outSkip,lzmadec.dicPos);
  1.1341 ++	if (outSkip < lzmadec.dicPos)
  1.1342 ++	{
  1.1343 ++	    UInt32 outTxCur = lzmadec.dicPos - outSkip; 
  1.1344 ++	    //grub_printf("Copy %d byte ",outTxCur);
  1.1345 ++	    if (buf)
  1.1346 ++	    {
  1.1347 ++		grub_memmove(buf, lzmadec.dic+outSkip, outTxCur); 
  1.1348 ++		buf += outTxCur; 
  1.1349 ++	    }
  1.1350 ++	    outSkip = lzmadec.dicPos;
  1.1351 ++	    outTx += outTxCur; 
  1.1352 ++	    lzmadec.fileu.fpos += outTxCur; 
  1.1353 ++	    len -= outTxCur; 
  1.1354 ++	    //grub_printf(" remaining len=%ld\n",len);
  1.1355 ++	    if (len==0) break;
  1.1356 ++	}
  1.1357 ++	/* All existing wanted data from dic have been copied. We will add more data to dic. */
  1.1358 ++	/* Read more input if there is no unprocessed input left. */
  1.1359 ++	if (lzmadec.inpPos == lzmadec.inpSize)
  1.1360 ++	{
  1.1361 ++	    UInt32 inTxCur = (filemax-filepos<lzmadec.inpBufSize)?filemax-filepos:lzmadec.inpBufSize;
  1.1362 ++	    lzmadec.inpFilePos = filepos;
  1.1363 ++	    lzmadec.inpPos = 0;
  1.1364 ++	    //grub_printf("read inp %d ",inTxCur);
  1.1365 ++	    lzmadec.inpSize = grub_read(lzmadec.inp, inTxCur, 0xedde0d90);
  1.1366 ++	    //grub_printf("->%d\n",lzmadec.inpSize);
  1.1367 ++	}
  1.1368 ++	inSizeCur = lzmadec.inpSize - lzmadec.inpPos;
  1.1369 ++
  1.1370 ++	/* Prepare output dicPos, dicLimit. */
  1.1371 ++	if (lzmadec.dicPos == lzmadec.dicBufSize)
  1.1372 ++	{
  1.1373 ++	    lzmadec.dicPos = 0;
  1.1374 ++	    outSkip -= lzmadec.dicBufSize;
  1.1375 ++	}
  1.1376 ++	dicPos = lzmadec.dicPos;
  1.1377 ++	dicLimit = (lzmadec.dicBufSize-dicPos < len)? lzmadec.dicBufSize: dicPos+len;
  1.1378 ++
  1.1379 ++	/* Do decompression. */
  1.1380 ++	//grub_printf("DecodeToDic dicPos=%d limit=%d inPos=%d inSize=%d ",dicPos,dicLimit,lzmadec.inpPos,inSizeCur);
  1.1381 ++	status = LZMA_STATUS_NOT_SPECIFIED;
  1.1382 ++	res = LzmaDec_DecodeToDic(&lzmadec, dicLimit, lzmadec.inp+lzmadec.inpPos, &inSizeCur, LZMA_FINISH_ANY, &status);
  1.1383 ++	//grub_printf("->%d\n",inSizeCur);
  1.1384 ++	lzmadec.inpPos += inSizeCur;
  1.1385 ++	if (inSizeCur==0 && lzmadec.dicPos==dicPos)
  1.1386 ++	{
  1.1387 ++	    /* Error */
  1.1388 ++	    //grub_printf("No more input and output\n");
  1.1389 ++	    break;
  1.1390 ++	}
  1.1391 ++    }
  1.1392 ++    compressed_file = 1;
  1.1393 ++    lzmadec.filec.fmax = filemax; filemax = lzmadec.fileu.fmax;
  1.1394 ++    lzmadec.filec.fpos = filepos; filepos = lzmadec.fileu.fpos;
  1.1395 ++    /* Now filepos, file max is of uncompressed data
  1.1396 ++     * filec.fpos, filwc.fmax is of compressed file
  1.1397 ++     * fileu is not used
  1.1398 ++     */
  1.1399 ++
  1.1400 ++    //grub_printf("LZMA read end %ld\n",outTx);
  1.1401 ++    return outTx;
  1.1402 ++}
  1.1403 ++
  1.1404 ++#endif /* ! NO_DECOMPRESSION */
  1.1405 +diff -Naur ../grub4dos-chenall-r63/stage2/decomp.h ./stage2/decomp.h
  1.1406 +--- grub4dos-chenall-r63/stage2/decomp.h	1970-01-01 07:00:00.000000000 +0700
  1.1407 ++++ grub4dos/stage2/decomp.h	2010-11-28 13:51:54.687217000 +0700
  1.1408 +@@ -0,0 +1,36 @@
  1.1409 ++/* decomp.h - abstract decompression interface */
  1.1410 ++/*
  1.1411 ++ *  GRUB  --  GRand Unified Bootloader
  1.1412 ++ *  Copyright (C) 1999,2000,2001,2004  Free Software Foundation, Inc.
  1.1413 ++ *
  1.1414 ++ *  This program is free software; you can redistribute it and/or modify
  1.1415 ++ *  it under the terms of the GNU General Public License as published by
  1.1416 ++ *  the Free Software Foundation; either version 2 of the License, or
  1.1417 ++ *  (at your option) any later version.
  1.1418 ++ *
  1.1419 ++ *  This program is distributed in the hope that it will be useful,
  1.1420 ++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  1.1421 ++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1.1422 ++ *  GNU General Public License for more details.
  1.1423 ++ *
  1.1424 ++ *  You should have received a copy of the GNU General Public License
  1.1425 ++ *  along with this program; if not, write to the Free Software
  1.1426 ++ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1.1427 ++ */
  1.1428 ++
  1.1429 ++#ifndef ASM_FILE
  1.1430 ++
  1.1431 ++struct decomp_entry
  1.1432 ++{
  1.1433 ++  char *name;
  1.1434 ++  int (*open_func) (void);
  1.1435 ++  void (*close_func) (void);
  1.1436 ++  unsigned long (*read_func) (char *buf, unsigned long len, unsigned long write);
  1.1437 ++};
  1.1438 ++
  1.1439 ++#define NUM_DECOM 2
  1.1440 ++
  1.1441 ++extern struct decomp_entry decomp_table[NUM_DECOM];
  1.1442 ++extern int decomp_type;
  1.1443 ++
  1.1444 ++#endif
  1.1445 +\ No newline at end of file
  1.1446 +diff -Naur ../grub4dos-chenall-r63/stage2/disk_io.c ./stage2/disk_io.c
  1.1447 +--- grub4dos-chenall-r63/stage2/disk_io.c	2010-08-12 14:22:47.111207000 +0700
  1.1448 ++++ grub4dos/stage2/disk_io.c	2010-11-28 20:26:39.089887300 +0700
  1.1449 +@@ -21,6 +21,7 @@
  1.1450 + 
  1.1451 + #include <shared.h>
  1.1452 + #include <filesys.h>
  1.1453 ++#include <decomp.h>
  1.1454 + #include <iso9660.h>
  1.1455 + 
  1.1456 + #ifdef SUPPORT_NETBOOT
  1.1457 +@@ -1872,7 +1873,16 @@
  1.1458 + #ifdef NO_DECOMPRESSION
  1.1459 +       return 1;
  1.1460 + #else
  1.1461 +-      return gunzip_test_header ();
  1.1462 ++      if (no_decompression)
  1.1463 ++	return 1;
  1.1464 ++      int i;
  1.1465 ++      i = strlen(open_filename);
  1.1466 ++      if (i>=5 && strcmp(open_filename+i-5,".lzma")==0)
  1.1467 ++        dec_lzma_open ();
  1.1468 ++      else
  1.1469 ++        gunzip_test_header ();
  1.1470 ++      errnum = 0;
  1.1471 ++      return 1;
  1.1472 + #endif
  1.1473 +     }
  1.1474 + 
  1.1475 +@@ -1903,7 +1903,7 @@
  1.1476 +   {
  1.1477 +     if (write == 0x900ddeed)
  1.1478 + 	return !(errnum = ERR_WRITE_GZIP_FILE);
  1.1479 +-    return gunzip_read (buf, len);
  1.1480 ++    return decomp_table[decomp_type].read_func (buf, len, write);
  1.1481 +   }
  1.1482 + #endif /* NO_DECOMPRESSION */
  1.1483 + 
  1.1484 +@@ -1978,6 +1982,12 @@
  1.1485 + void
  1.1486 + grub_close (void)
  1.1487 + {
  1.1488 ++#ifndef NO_DECOMPRESSION
  1.1489 ++  if (compressed_file)
  1.1490 ++      decomp_table[decomp_type].close_func ();
  1.1491 ++  compressed_file = 0;
  1.1492 ++#endif /* NO_DECOMPRESSION */
  1.1493 ++
  1.1494 + #ifndef NO_BLOCK_FILES
  1.1495 +   if (block_file)
  1.1496 +     return;
  1.1497 +diff -Naur ../grub4dos-chenall-r63/stage2/gunzip.c ./stage2/gunzip.c
  1.1498 +--- grub4dos-chenall-r63/stage2/gunzip.c	2010-07-26 19:35:48.440546000 +0700
  1.1499 ++++ grub4dos/stage2/gunzip.c	2010-11-28 14:20:56.983870700 +0700
  1.1500 +@@ -129,6 +129,8 @@
  1.1501 + 
  1.1502 + #include "filesys.h"
  1.1503 + 
  1.1504 ++#include "decomp.h"
  1.1505 ++
  1.1506 + /* so we can disable decompression  */
  1.1507 + #ifdef GRUB_UTIL
  1.1508 + int no_decompression = 0;
  1.1509 +@@ -137,6 +139,15 @@
  1.1510 + /* used to tell if "read" should be redirected to "gunzip_read" */
  1.1511 + int compressed_file;
  1.1512 + 
  1.1513 ++/* identify active decompressor */
  1.1514 ++int decomp_type;
  1.1515 ++
  1.1516 ++struct decomp_entry decomp_table[NUM_DECOM] =
  1.1517 ++{
  1.1518 ++	{"gz",gunzip_test_header,gunzip_close,gunzip_read},
  1.1519 ++	{"lzma",dec_lzma_open,dec_lzma_close,dec_lzma_read}
  1.1520 ++};
  1.1521 ++
  1.1522 + /* internal variables only */
  1.1523 + static unsigned long long gzip_data_offset;
  1.1524 + static unsigned long long gzip_filepos;
  1.1525 +@@ -227,6 +238,7 @@
  1.1526 + /* Little-Endian defines for the 2-byte magic number for gzip files */
  1.1527 + #define GZIP_HDR_LE      0x8B1F
  1.1528 + #define OLD_GZIP_HDR_LE  0x9E1F
  1.1529 ++#define LZMA_HDR_LE      0x005D
  1.1530 + 
  1.1531 + /* Compression methods (see algorithm.doc) */
  1.1532 + #define STORED      0
  1.1533 +@@ -281,10 +292,18 @@
  1.1534 +   if (no_decompression
  1.1535 +       || grub_read ((char *)buf, 10, 0xedde0d90) != 10
  1.1536 +       || ((*((unsigned short *) buf) != GZIP_HDR_LE)
  1.1537 +-	  && (*((unsigned short *) buf) != OLD_GZIP_HDR_LE)))
  1.1538 ++	  && (*((unsigned short *) buf) != OLD_GZIP_HDR_LE)
  1.1539 ++	  && (*((unsigned short *) buf) != LZMA_HDR_LE)))
  1.1540 +     {
  1.1541 +       filepos = 0;
  1.1542 +       return ! errnum;
  1.1543 ++    }
  1.1544 ++
  1.1545 ++  if (*((unsigned short *) buf) == LZMA_HDR_LE)
  1.1546 ++    {
  1.1547 ++      filepos = 0;
  1.1548 ++      dec_lzma_open();
  1.1549 ++      return 1;
  1.1550 +     }
  1.1551 + 
  1.1552 +   /*
  1.1553 +@@ -323,6 +334,7 @@
  1.1554 + 
  1.1555 +   initialize_tables ();
  1.1556 + 
  1.1557 ++  decomp_type = 0;
  1.1558 +   compressed_file = 1;
  1.1559 +   gunzip_swap_values ();
  1.1560 +   /*
  1.1561 +@@ -334,6 +346,11 @@
  1.1562 +   return 1;
  1.1563 + }
  1.1564 + 
  1.1565 ++void 
  1.1566 ++gunzip_close (void)
  1.1567 ++{
  1.1568 ++}
  1.1569 ++
  1.1570 + 
  1.1571 + /* Huffman code lookup table entry--this entry is four bytes for machines
  1.1572 +    that have 16-bit pointers (e.g. PC's in the small or medium model).
  1.1573 +@@ -1190,7 +1226,7 @@
  1.1574 + 
  1.1575 + 
  1.1576 + unsigned long
  1.1577 +-gunzip_read (char *buf, unsigned long len)
  1.1578 ++gunzip_read (char *buf, unsigned long len, unsigned long write)
  1.1579 + {
  1.1580 +   unsigned long ret = 0;
  1.1581 + 
  1.1582 +diff -Naur ../grub4dos-chenall-r63/stage2/Makefile.am ./stage2/Makefile.am
  1.1583 +--- grub4dos-chenall-r63/stage2/Makefile.am	2010-08-12 14:22:47.111207000 +0700
  1.1584 ++++ grub4dos/stage2/Makefile.am	2010-11-28 16:35:18.724975900 +0700
  1.1585 +@@ -16,6 +16,7 @@
  1.1586 + # The library for /sbin/grub.
  1.1587 + noinst_LIBRARIES = libgrub.a
  1.1588 + libgrub_a_SOURCES = boot.c builtins.c char_io.c cmdline.c common.c \
  1.1589 ++	dec_lzma.c \
  1.1590 + 	disk_io.c fsys_ext2fs.c fsys_fat.c fsys_ntfs.c fsys_ffs.c fsys_iso9660.c \
  1.1591 + 	fsys_jfs.c fsys_minix.c fsys_reiserfs.c fsys_ufs2.c \
  1.1592 + 	fsys_vstafs.c fsys_xfs.c fsys_pxe.c gunzip.c md5.c serial.c stage2.c \
  1.1593 +@@ -100,7 +101,7 @@
  1.1594 + 
  1.1595 + # For stage2 target.
  1.1596 + pre_stage2_exec_SOURCES = asm.S bios.c boot.c builtins.c char_io.c \
  1.1597 +-	cmdline.c common.c console.c disk_io.c fsys_ext2fs.c \
  1.1598 ++	cmdline.c common.c console.c dec_lzma.c disk_io.c fsys_ext2fs.c \
  1.1599 + 	fsys_fat.c fsys_ntfs.c fsys_ffs.c fsys_iso9660.c fsys_jfs.c fsys_minix.c \
  1.1600 + 	fsys_reiserfs.c fsys_ufs2.c fsys_vstafs.c fsys_xfs.c fsys_pxe.c gunzip.c \
  1.1601 + 	hercules.c md5.c serial.c smp-imps.c stage2.c terminfo.c tparm.c graphics.c
  1.1602 +diff -Naur ../grub4dos-chenall-r63/stage2/Makefile.in ./stage2/Makefile.in
  1.1603 +--- grub4dos-chenall-r63/stage2/Makefile.in	2010-08-12 14:22:47.111207000 +0700
  1.1604 ++++ grub4dos/stage2/Makefile.in	2010-11-28 16:38:22.871508400 +0700
  1.1605 +@@ -104,10 +104,11 @@
  1.1606 + am_libgrub_a_OBJECTS = libgrub_a-boot.$(OBJEXT) \
  1.1607 + 	libgrub_a-builtins.$(OBJEXT) libgrub_a-char_io.$(OBJEXT) \
  1.1608 + 	libgrub_a-cmdline.$(OBJEXT) libgrub_a-common.$(OBJEXT) \
  1.1609 +-	libgrub_a-disk_io.$(OBJEXT) libgrub_a-fsys_ext2fs.$(OBJEXT) \
  1.1610 +-	libgrub_a-fsys_fat.$(OBJEXT) libgrub_a-fsys_ntfs.$(OBJEXT) \
  1.1611 +-	libgrub_a-fsys_ffs.$(OBJEXT) libgrub_a-fsys_iso9660.$(OBJEXT) \
  1.1612 +-	libgrub_a-fsys_jfs.$(OBJEXT) libgrub_a-fsys_minix.$(OBJEXT) \
  1.1613 ++	libgrub_a-dec_lzma.$(OBJEXT) libgrub_a-disk_io.$(OBJEXT) \
  1.1614 ++	libgrub_a-fsys_ext2fs.$(OBJEXT) libgrub_a-fsys_fat.$(OBJEXT) \
  1.1615 ++	libgrub_a-fsys_ntfs.$(OBJEXT) libgrub_a-fsys_ffs.$(OBJEXT) \
  1.1616 ++	libgrub_a-fsys_iso9660.$(OBJEXT) libgrub_a-fsys_jfs.$(OBJEXT) \
  1.1617 ++	libgrub_a-fsys_minix.$(OBJEXT) \
  1.1618 + 	libgrub_a-fsys_reiserfs.$(OBJEXT) \
  1.1619 + 	libgrub_a-fsys_ufs2.$(OBJEXT) libgrub_a-fsys_vstafs.$(OBJEXT) \
  1.1620 + 	libgrub_a-fsys_xfs.$(OBJEXT) libgrub_a-fsys_pxe.$(OBJEXT) \
  1.1621 +@@ -131,6 +132,7 @@
  1.1622 + 	diskless_exec-char_io.$(OBJEXT) \
  1.1623 + 	diskless_exec-cmdline.$(OBJEXT) diskless_exec-common.$(OBJEXT) \
  1.1624 + 	diskless_exec-console.$(OBJEXT) \
  1.1625 ++	diskless_exec-dec_lzma.$(OBJEXT) \
  1.1626 + 	diskless_exec-disk_io.$(OBJEXT) \
  1.1627 + 	diskless_exec-fsys_ext2fs.$(OBJEXT) \
  1.1628 + 	diskless_exec-fsys_fat.$(OBJEXT) \
  1.1629 +@@ -247,6 +249,7 @@
  1.1630 + 	pre_stage2_exec-cmdline.$(OBJEXT) \
  1.1631 + 	pre_stage2_exec-common.$(OBJEXT) \
  1.1632 + 	pre_stage2_exec-console.$(OBJEXT) \
  1.1633 ++	pre_stage2_exec-dec_lzma.$(OBJEXT) \
  1.1634 + 	pre_stage2_exec-disk_io.$(OBJEXT) \
  1.1635 + 	pre_stage2_exec-fsys_ext2fs.$(OBJEXT) \
  1.1636 + 	pre_stage2_exec-fsys_fat.$(OBJEXT) \
  1.1637 +@@ -512,6 +513,7 @@
  1.1638 + # The library for /sbin/grub.
  1.1639 + noinst_LIBRARIES = libgrub.a
  1.1640 + libgrub_a_SOURCES = boot.c builtins.c char_io.c cmdline.c common.c \
  1.1641 ++	dec_lzma.c \
  1.1642 + 	disk_io.c fsys_ext2fs.c fsys_fat.c fsys_ntfs.c fsys_ffs.c fsys_iso9660.c \
  1.1643 + 	fsys_jfs.c fsys_minix.c fsys_reiserfs.c fsys_ufs2.c \
  1.1644 + 	fsys_vstafs.c fsys_xfs.c fsys_pxe.c gunzip.c md5.c serial.c stage2.c \
  1.1645 +@@ -559,7 +563,7 @@
  1.1646 + 
  1.1647 + # For stage2 target.
  1.1648 + pre_stage2_exec_SOURCES = asm.S bios.c boot.c builtins.c char_io.c \
  1.1649 +-	cmdline.c common.c console.c disk_io.c fsys_ext2fs.c \
  1.1650 ++	cmdline.c common.c console.c dec_lzma.c disk_io.c fsys_ext2fs.c \
  1.1651 + 	fsys_fat.c fsys_ntfs.c fsys_ffs.c fsys_iso9660.c fsys_jfs.c fsys_minix.c \
  1.1652 + 	fsys_reiserfs.c fsys_ufs2.c fsys_vstafs.c fsys_xfs.c fsys_pxe.c gunzip.c \
  1.1653 + 	hercules.c md5.c serial.c smp-imps.c stage2.c terminfo.c tparm.c graphics.c
  1.1654 +@@ -878,6 +882,7 @@
  1.1655 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/diskless_exec-cmdline.Po@am__quote@
  1.1656 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/diskless_exec-common.Po@am__quote@
  1.1657 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/diskless_exec-console.Po@am__quote@
  1.1658 ++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/diskless_exec-dec_lzma.Po@am__quote@
  1.1659 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/diskless_exec-disk_io.Po@am__quote@
  1.1660 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/diskless_exec-fsys_ext2fs.Po@am__quote@
  1.1661 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/diskless_exec-fsys_fat.Po@am__quote@
  1.1662 +@@ -935,6 +940,7 @@
  1.1663 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libgrub_a-char_io.Po@am__quote@
  1.1664 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libgrub_a-cmdline.Po@am__quote@
  1.1665 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libgrub_a-common.Po@am__quote@
  1.1666 ++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libgrub_a-dec_lzma.Po@am__quote@
  1.1667 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libgrub_a-disk_io.Po@am__quote@
  1.1668 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libgrub_a-fsys_ext2fs.Po@am__quote@
  1.1669 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libgrub_a-fsys_fat.Po@am__quote@
  1.1670 +@@ -974,6 +980,7 @@
  1.1671 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pre_stage2_exec-cmdline.Po@am__quote@
  1.1672 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pre_stage2_exec-common.Po@am__quote@
  1.1673 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pre_stage2_exec-console.Po@am__quote@
  1.1674 ++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pre_stage2_exec-dec_lzma.Po@am__quote@
  1.1675 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pre_stage2_exec-disk_io.Po@am__quote@
  1.1676 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pre_stage2_exec-fsys_ext2fs.Po@am__quote@
  1.1677 + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pre_stage2_exec-fsys_fat.Po@am__quote@
  1.1678 +@@ -1315,6 +1322,20 @@
  1.1679 + @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
  1.1680 + @am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libgrub_a_CFLAGS) $(CFLAGS) -c -o libgrub_a-common.obj `if test -f 'common.c'; then $(CYGPATH_W) 'common.c'; else $(CYGPATH_W) '$(srcdir)/common.c'; fi`
  1.1681 + 
  1.1682 ++libgrub_a-dec_lzma.o: dec_lzma.c
  1.1683 ++@am__fastdepCC_TRUE@	if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libgrub_a_CFLAGS) $(CFLAGS) -MT libgrub_a-dec_lzma.o -MD -MP -MF "$(DEPDIR)/libgrub_a-dec_lzma.Tpo" -c -o libgrub_a-dec_lzma.o `test -f 'dec_lzma.c' || echo '$(srcdir)/'`dec_lzma.c; \
  1.1684 ++@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/libgrub_a-dec_lzma.Tpo" "$(DEPDIR)/libgrub_a-dec_lzma.Po"; else rm -f "$(DEPDIR)/libgrub_a-dec_lzma.Tpo"; exit 1; fi
  1.1685 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='dec_lzma.c' object='libgrub_a-dec_lzma.o' libtool=no @AMDEPBACKSLASH@
  1.1686 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
  1.1687 ++@am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libgrub_a_CFLAGS) $(CFLAGS) -c -o libgrub_a-dec_lzma.o `test -f 'dec_lzma.c' || echo '$(srcdir)/'`dec_lzma.c
  1.1688 ++
  1.1689 ++libgrub_a-dec_lzma.obj: dec_lzma.c
  1.1690 ++@am__fastdepCC_TRUE@	if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libgrub_a_CFLAGS) $(CFLAGS) -MT libgrub_a-dec_lzma.obj -MD -MP -MF "$(DEPDIR)/libgrub_a-dec_lzma.Tpo" -c -o libgrub_a-dec_lzma.obj `if test -f 'dec_lzma.c'; then $(CYGPATH_W) 'dec_lzma.c'; else $(CYGPATH_W) '$(srcdir)/dec_lzma.c'; fi`; \
  1.1691 ++@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/libgrub_a-dec_lzma.Tpo" "$(DEPDIR)/libgrub_a-dec_lzma.Po"; else rm -f "$(DEPDIR)/libgrub_a-dec_lzma.Tpo"; exit 1; fi
  1.1692 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='dec_lzma.c' object='libgrub_a-dec_lzma.obj' libtool=no @AMDEPBACKSLASH@
  1.1693 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
  1.1694 ++@am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libgrub_a_CFLAGS) $(CFLAGS) -c -o libgrub_a-dec_lzma.obj `if test -f 'dec_lzma.c'; then $(CYGPATH_W) 'dec_lzma.c'; else $(CYGPATH_W) '$(srcdir)/dec_lzma.c'; fi`
  1.1695 ++
  1.1696 + libgrub_a-disk_io.o: disk_io.c
  1.1697 + @am__fastdepCC_TRUE@	if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libgrub_a_CFLAGS) $(CFLAGS) -MT libgrub_a-disk_io.o -MD -MP -MF "$(DEPDIR)/libgrub_a-disk_io.Tpo" -c -o libgrub_a-disk_io.o `test -f 'disk_io.c' || echo '$(srcdir)/'`disk_io.c; \
  1.1698 + @am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/libgrub_a-disk_io.Tpo" "$(DEPDIR)/libgrub_a-disk_io.Po"; else rm -f "$(DEPDIR)/libgrub_a-disk_io.Tpo"; exit 1; fi
  1.1699 +@@ -1693,6 +1714,20 @@
  1.1700 + @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
  1.1701 + @am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(diskless_exec_CFLAGS) $(CFLAGS) -c -o diskless_exec-console.obj `if test -f 'console.c'; then $(CYGPATH_W) 'console.c'; else $(CYGPATH_W) '$(srcdir)/console.c'; fi`
  1.1702 + 
  1.1703 ++diskless_exec-dec_lzma.o: dec_lzma.c
  1.1704 ++@am__fastdepCC_TRUE@	if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(diskless_exec_CFLAGS) $(CFLAGS) -MT diskless_exec-dec_lzma.o -MD -MP -MF "$(DEPDIR)/diskless_exec-dec_lzma.Tpo" -c -o diskless_exec-dec_lzma.o `test -f 'dec_lzma.c' || echo '$(srcdir)/'`dec_lzma.c; \
  1.1705 ++@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/diskless_exec-dec_lzma.Tpo" "$(DEPDIR)/diskless_exec-dec_lzma.Po"; else rm -f "$(DEPDIR)/diskless_exec-dec_lzma.Tpo"; exit 1; fi
  1.1706 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='dec_lzma.c' object='diskless_exec-dec_lzma.o' libtool=no @AMDEPBACKSLASH@
  1.1707 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
  1.1708 ++@am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(diskless_exec_CFLAGS) $(CFLAGS) -c -o diskless_exec-dec_lzma.o `test -f 'dec_lzma.c' || echo '$(srcdir)/'`dec_lzma.c
  1.1709 ++
  1.1710 ++diskless_exec-dec_lzma.obj: dec_lzma.c
  1.1711 ++@am__fastdepCC_TRUE@	if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(diskless_exec_CFLAGS) $(CFLAGS) -MT diskless_exec-dec_lzma.obj -MD -MP -MF "$(DEPDIR)/diskless_exec-dec_lzma.Tpo" -c -o diskless_exec-dec_lzma.obj `if test -f 'dec_lzma.c'; then $(CYGPATH_W) 'dec_lzma.c'; else $(CYGPATH_W) '$(srcdir)/dec_lzma.c'; fi`; \
  1.1712 ++@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/diskless_exec-dec_lzma.Tpo" "$(DEPDIR)/diskless_exec-dec_lzma.Po"; else rm -f "$(DEPDIR)/diskless_exec-dec_lzma.Tpo"; exit 1; fi
  1.1713 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='dec_lzma.c' object='diskless_exec-dec_lzma.obj' libtool=no @AMDEPBACKSLASH@
  1.1714 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
  1.1715 ++@am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(diskless_exec_CFLAGS) $(CFLAGS) -c -o diskless_exec-dec_lzma.obj `if test -f 'dec_lzma.c'; then $(CYGPATH_W) 'dec_lzma.c'; else $(CYGPATH_W) '$(srcdir)/dec_lzma.c'; fi`
  1.1716 ++
  1.1717 + diskless_exec-disk_io.o: disk_io.c
  1.1718 + @am__fastdepCC_TRUE@	if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(diskless_exec_CFLAGS) $(CFLAGS) -MT diskless_exec-disk_io.o -MD -MP -MF "$(DEPDIR)/diskless_exec-disk_io.Tpo" -c -o diskless_exec-disk_io.o `test -f 'disk_io.c' || echo '$(srcdir)/'`disk_io.c; \
  1.1719 + @am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/diskless_exec-disk_io.Tpo" "$(DEPDIR)/diskless_exec-disk_io.Po"; else rm -f "$(DEPDIR)/diskless_exec-disk_io.Tpo"; exit 1; fi
  1.1720 +@@ -2687,6 +2722,20 @@
  1.1721 + @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
  1.1722 + @am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(pre_stage2_exec_CFLAGS) $(CFLAGS) -c -o pre_stage2_exec-console.obj `if test -f 'console.c'; then $(CYGPATH_W) 'console.c'; else $(CYGPATH_W) '$(srcdir)/console.c'; fi`
  1.1723 + 
  1.1724 ++pre_stage2_exec-dec_lzma.o: dec_lzma.c
  1.1725 ++@am__fastdepCC_TRUE@	if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(pre_stage2_exec_CFLAGS) $(CFLAGS) -MT pre_stage2_exec-dec_lzma.o -MD -MP -MF "$(DEPDIR)/pre_stage2_exec-dec_lzma.Tpo" -c -o pre_stage2_exec-dec_lzma.o `test -f 'dec_lzma.c' || echo '$(srcdir)/'`dec_lzma.c; \
  1.1726 ++@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/pre_stage2_exec-dec_lzma.Tpo" "$(DEPDIR)/pre_stage2_exec-dec_lzma.Po"; else rm -f "$(DEPDIR)/pre_stage2_exec-dec_lzma.Tpo"; exit 1; fi
  1.1727 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='dec_lzma.c' object='pre_stage2_exec-dec_lzma.o' libtool=no @AMDEPBACKSLASH@
  1.1728 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
  1.1729 ++@am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(pre_stage2_exec_CFLAGS) $(CFLAGS) -c -o pre_stage2_exec-dec_lzma.o `test -f 'dec_lzma.c' || echo '$(srcdir)/'`dec_lzma.c
  1.1730 ++
  1.1731 ++pre_stage2_exec-dec_lzma.obj: dec_lzma.c
  1.1732 ++@am__fastdepCC_TRUE@	if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(pre_stage2_exec_CFLAGS) $(CFLAGS) -MT pre_stage2_exec-dec_lzma.obj -MD -MP -MF "$(DEPDIR)/pre_stage2_exec-dec_lzma.Tpo" -c -o pre_stage2_exec-dec_lzma.obj `if test -f 'dec_lzma.c'; then $(CYGPATH_W) 'dec_lzma.c'; else $(CYGPATH_W) '$(srcdir)/dec_lzma.c'; fi`; \
  1.1733 ++@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/pre_stage2_exec-dec_lzma.Tpo" "$(DEPDIR)/pre_stage2_exec-dec_lzma.Po"; else rm -f "$(DEPDIR)/pre_stage2_exec-dec_lzma.Tpo"; exit 1; fi
  1.1734 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='dec_lzma.c' object='pre_stage2_exec-dec_lzma.obj' libtool=no @AMDEPBACKSLASH@
  1.1735 ++@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
  1.1736 ++@am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(pre_stage2_exec_CFLAGS) $(CFLAGS) -c -o pre_stage2_exec-dec_lzma.obj `if test -f 'dec_lzma.c'; then $(CYGPATH_W) 'dec_lzma.c'; else $(CYGPATH_W) '$(srcdir)/dec_lzma.c'; fi`
  1.1737 ++
  1.1738 + pre_stage2_exec-disk_io.o: disk_io.c
  1.1739 + @am__fastdepCC_TRUE@	if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(pre_stage2_exec_CFLAGS) $(CFLAGS) -MT pre_stage2_exec-disk_io.o -MD -MP -MF "$(DEPDIR)/pre_stage2_exec-disk_io.Tpo" -c -o pre_stage2_exec-disk_io.o `test -f 'disk_io.c' || echo '$(srcdir)/'`disk_io.c; \
  1.1740 + @am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/pre_stage2_exec-disk_io.Tpo" "$(DEPDIR)/pre_stage2_exec-disk_io.Po"; else rm -f "$(DEPDIR)/pre_stage2_exec-disk_io.Tpo"; exit 1; fi
  1.1741 +diff -Naur ../grub4dos-chenall-r63/stage2/shared.h ./stage2/shared.h
  1.1742 +--- grub4dos-chenall-r63/stage2/shared.h	2010-11-17 15:33:51.826683000 +0700
  1.1743 ++++ grub4dos/stage2/shared.h	2010-11-27 01:16:46.996893700 +0700
  1.1744 +@@ -640,6 +640,7 @@
  1.1745 +   ERR_WRITE_GZIP_FILE,
  1.1746 +   ERR_FUNC_CALL,
  1.1747 + //  ERR_WRITE_TO_NON_MEM_DRIVE,
  1.1748 ++  ERR_NOT_ENOUGH_MEMORY,
  1.1749 + 
  1.1750 +   MAX_ERR_NUM
  1.1751 + } grub_error_t;
  1.1752 +@@ -1185,7 +1186,11 @@
  1.1753 + #ifndef NO_DECOMPRESSION
  1.1754 + /* Compression support. */
  1.1755 + int gunzip_test_header (void);
  1.1756 +-unsigned long gunzip_read (char *buf, unsigned long len);
  1.1757 ++void gunzip_close (void);
  1.1758 ++unsigned long gunzip_read (char *buf, unsigned long len, unsigned long write);
  1.1759 ++int dec_lzma_open (void);
  1.1760 ++void dec_lzma_close (void);
  1.1761 ++unsigned long dec_lzma_read (char *buf, unsigned long len, unsigned long write);
  1.1762 + #endif /* NO_DECOMPRESSION */
  1.1763 + 
  1.1764 + int rawread (unsigned long drive, unsigned long sector, unsigned long byte_offset, unsigned long byte_len, char *buf, unsigned long write);