{"id":2175800,"url":"http://patchwork.ozlabs.org/api/1.0/patches/2175800/?format=json","project":{"id":18,"url":"http://patchwork.ozlabs.org/api/1.0/projects/18/?format=json","name":"U-Boot","link_name":"uboot","list_id":"u-boot.lists.denx.de","list_email":"u-boot@lists.denx.de","web_url":null,"scm_url":null,"webscm_url":null},"msgid":"<20251218232255.3934258-6-trini@konsulko.com>","date":"2025-12-18T23:10:17","name":"[RFC,5/9] lzma: Update 9.38 -> 18.06","commit_ref":null,"pull_url":null,"state":"rfc","archived":false,"hash":"75b65d8731c863649b6ba48031113fd0c1ceb457","submitter":{"id":65875,"url":"http://patchwork.ozlabs.org/api/1.0/people/65875/?format=json","name":"Tom Rini","email":"trini@konsulko.com"},"delegate":{"id":3651,"url":"http://patchwork.ozlabs.org/api/1.0/users/3651/?format=json","username":"trini","first_name":"Tom","last_name":"Rini","email":"trini@ti.com"},"mbox":"http://patchwork.ozlabs.org/project/uboot/patch/20251218232255.3934258-6-trini@konsulko.com/mbox/","series":[{"id":485929,"url":"http://patchwork.ozlabs.org/api/1.0/series/485929/?format=json","date":"2025-12-18T23:10:12","name":"Update lzma to current version of LZMA SDK","version":1,"mbox":"http://patchwork.ozlabs.org/series/485929/mbox/"}],"check":"pending","checks":"http://patchwork.ozlabs.org/api/patches/2175800/checks/","tags":{},"headers":{"Return-Path":"","X-Original-To":"incoming@patchwork.ozlabs.org","Delivered-To":"patchwork-incoming@legolas.ozlabs.org","Authentication-Results":["legolas.ozlabs.org;\n\tdkim=pass (1024-bit key;\n unprotected) header.d=konsulko.com header.i=@konsulko.com header.a=rsa-sha256\n header.s=google header.b=ktdlr6Yn;\n\tdkim-atps=neutral","legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=lists.denx.de\n (client-ip=2a01:238:438b:c500:173d:9f52:ddab:ee01; helo=phobos.denx.de;\n envelope-from=u-boot-bounces@lists.denx.de; receiver=patchwork.ozlabs.org)","phobos.denx.de;\n dmarc=pass (p=none dis=none) header.from=konsulko.com","phobos.denx.de;\n spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de","phobos.denx.de;\n\tdkim=pass (1024-bit key;\n unprotected) header.d=konsulko.com header.i=@konsulko.com\n header.b=\"ktdlr6Yn\";\n\tdkim-atps=neutral","phobos.denx.de;\n dmarc=pass (p=none dis=none) header.from=konsulko.com","phobos.denx.de;\n spf=pass smtp.mailfrom=trini@konsulko.com"],"Received":["from phobos.denx.de (phobos.denx.de\n [IPv6:2a01:238:438b:c500:173d:9f52:ddab:ee01])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4dXRYz2KcMz1xty\n\tfor ; Fri, 19 Dec 2025 10:23:51 +1100 (AEDT)","from h2850616.stratoserver.net (localhost [IPv6:::1])\n\tby phobos.denx.de (Postfix) with ESMTP id 9E12C83106;\n\tFri, 19 Dec 2025 00:23:13 +0100 (CET)","by phobos.denx.de (Postfix, from userid 109)\n id 964DE8392C; Fri, 19 Dec 2025 00:23:08 +0100 (CET)","from mail-ot1-x32d.google.com (mail-ot1-x32d.google.com\n [IPv6:2607:f8b0:4864:20::32d])\n (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits))\n (No client certificate requested)\n by phobos.denx.de (Postfix) with ESMTPS id 048CF836A3\n for ; Fri, 19 Dec 2025 00:23:05 +0100 (CET)","by mail-ot1-x32d.google.com with SMTP id\n 46e09a7af769-7c6ce4f65f7so1034907a34.0\n for ; Thu, 18 Dec 2025 15:23:04 -0800 (PST)","from bill-the-cat.. (fixed-189-203-103-235.totalplay.net.\n [189.203.103.235]) by smtp.gmail.com with ESMTPSA id\n 5614622812f47-457b3cc0928sm295333b6e.10.2025.12.18.15.23.02\n (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);\n Thu, 18 Dec 2025 15:23:02 -0800 (PST)"],"X-Spam-Checker-Version":"SpamAssassin 3.4.2 (2018-09-13) on phobos.denx.de","X-Spam-Level":"","X-Spam-Status":"No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED,\n DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_BLOCKED,\n SPF_HELO_NONE,SPF_PASS,T_FILL_THIS_FORM_SHORT autolearn=ham\n autolearn_force=no version=3.4.2","DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=konsulko.com; s=google; t=1766100184; x=1766704984; darn=lists.denx.de;\n h=content-transfer-encoding:mime-version:references:in-reply-to\n :message-id:date:subject:cc:to:from:from:to:cc:subject:date\n :message-id:reply-to;\n bh=+8li59yVfYwSBb25j49kCoJqxVHZdoLmZpYXhIdMLZE=;\n b=ktdlr6YnW3pUvXd0Akf/36+eEpFW1b4W+XJ0bVVd0koNkUzo8rbxiXYJh3RaZUgJhm\n pYYlgmohIHoHDi8J/9TApghMe5UXmPhaO/ypnyi6dhDVYP6bwZNFUzbRHFgoeXuzdr8W\n zQ7upakOlvO3xdLudgQc5qjUoQG2u2Ba/ntgA=","X-Google-DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20230601; t=1766100184; x=1766704984;\n h=content-transfer-encoding:mime-version:references:in-reply-to\n :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from\n :to:cc:subject:date:message-id:reply-to;\n bh=+8li59yVfYwSBb25j49kCoJqxVHZdoLmZpYXhIdMLZE=;\n b=lT1qvpeNbs5KmzOBfjHtv89g7BmvtZ+n68S4WVHzIg+8hEl63nB/pZhFMDENfPsYGw\n BuZ5lhJhLM0Q9ooGQjK43ajqPD9AdUnsaBrcLeqo6p6ISwH3O5pnf+7iqxfgqwGp5hCk\n 8tBLlnxU2vDw7YN1lFSUv3r8sy/yEZ7/DjkIZyY2chIsy0daaUqfz60BneuIGEhuKcLt\n 4hEyArzVkheyRdmNOV8zEPs4NHj6IMZI+VxfUnPsjJ2s80SID24GkMINOsMAMFrYhHJR\n +Gn5kVIFazO95krP0DkcQaPSp5CjzXBTLIQqmzkuC39CepFAV3XGwH0U5uuVjLW4PPPy\n 7bXA==","X-Gm-Message-State":"AOJu0YzDI5/mwzZVHtodSbsEjQ3mQPxDqfTkrefiJTSCbvbubyUtzYRo\n WtAXGvoeoVUm2BkY8cmauUuMAjrG/WmHnkf18PoLUqBMTPfd+ZPaC3wULJBQG0jtNiPoHNVVpwN\n 7+oaUnkk=","X-Gm-Gg":"AY/fxX7Zvfp+NKAhqzISevFnVKBC5TZdyoil2s7i7A8MTSgvOjB+Gac7i82kVoFipRZ\n a9AZiCqA5wTUoX4IQoUwaDMQFY/ByfryyqpVX1gL7DNOztPstyao3NTUCcyGRoKEXn3gDwnnqQ5\n eiqgp/bHMVNU+7dkX+6/MUmXbmEysMJ7kZzX7gopx4NFbkpPsU8+H6prb670qq/pUSwc1zf1zJ9\n qr9dQPNdZK8kjaJplwM3boUCqcmeNdRQQ3h6Mls0l4H+uGrl+ln/OgT3or7XzSc/UFEM8b8esZE\n a84jPeCXiR/DvgzPYqHIDG5dfKsDBStHGtYucMjEid0wKmTxfDv1VTh5lCcHzRPrdX9nIHA2Xj7\n xd9kDmGNtb5vXfyCm+yvqbWRlLIt4nJbEemL9jDyfkaWn6p7NpJpwCXd8mZlhZTPBgfiSVmXOL+\n STVHQbit7rcfpn96qe0ForOvOG1L5F0ZrdulSZThBMHUj7Ii4bnwC8","X-Google-Smtp-Source":"\n AGHT+IHJaqoeomc19ChC8D7V4rMOak2IyOZ9SKc8QEu3SuVdBEiwtEY510pyChnDK+8jPpUBsayHxg==","X-Received":"by 2002:a05:6808:1247:b0:450:c5b6:b7cd with SMTP id\n 5614622812f47-457b1ee8773mr662859b6e.27.1766100183275;\n Thu, 18 Dec 2025 15:23:03 -0800 (PST)","From":"Tom Rini ","To":"u-boot@lists.denx.de","Cc":"Darek ","Subject":"[RFC PATCH 5/9] lzma: Update 9.38 -> 18.06","Date":"Thu, 18 Dec 2025 17:10:17 -0600","Message-ID":"<20251218232255.3934258-6-trini@konsulko.com>","X-Mailer":"git-send-email 2.43.0","In-Reply-To":"<20251218232255.3934258-1-trini@konsulko.com>","References":"<20251218232255.3934258-1-trini@konsulko.com>","MIME-Version":"1.0","Content-Transfer-Encoding":"8bit","X-BeenThere":"u-boot@lists.denx.de","X-Mailman-Version":"2.1.39","Precedence":"list","List-Id":"U-Boot discussion ","List-Unsubscribe":",\n ","List-Archive":"","List-Post":"","List-Help":"","List-Subscribe":",\n ","Errors-To":"u-boot-bounces@lists.denx.de","Sender":"\"U-Boot\" ","X-Virus-Scanned":"clamav-milter 0.103.8 at phobos.denx.de","X-Virus-Status":"Clean"},"content":"These are only upstream changes and nothing local.\n\nSigned-off-by: Tom Rini \n---\n lib/lzma/7zTypes.h | 249 +++++++++++++++----\n lib/lzma/Compiler.h | 9 +-\n lib/lzma/LzmaDec.c | 571 +++++++++++++++++++++++++++----------------\n lib/lzma/LzmaDec.h | 57 +++--\n lib/lzma/LzmaTools.c | 4 +-\n 5 files changed, 605 insertions(+), 285 deletions(-)","diff":"diff --git a/lib/lzma/7zTypes.h b/lib/lzma/7zTypes.h\nindex 953db1afc49e..65b3af63c751 100644\n--- a/lib/lzma/7zTypes.h\n+++ b/lib/lzma/7zTypes.h\n@@ -1,5 +1,5 @@\n /* 7zTypes.h -- Basic types\n-2013-11-12 : Igor Pavlov : Public domain */\n+2018-08-04 : Igor Pavlov : Public domain */\n \n #ifndef __7Z_TYPES_H\n #define __7Z_TYPES_H\n@@ -10,6 +10,18 @@\n \n #include \n \n+#ifndef EXTERN_C_BEGIN\n+#ifdef __cplusplus\n+#define EXTERN_C_BEGIN extern \"C\" {\n+#define EXTERN_C_END }\n+#else\n+#define EXTERN_C_BEGIN\n+#define EXTERN_C_END\n+#endif\n+#endif\n+\n+EXTERN_C_BEGIN\n+\n #define SZ_OK 0\n \n #define SZ_ERROR_DATA 1\n@@ -30,13 +42,23 @@\n \n typedef int SRes;\n \n+\n #ifdef _WIN32\n+\n /* typedef DWORD WRes; */\n typedef unsigned WRes;\n+#define MY_SRes_HRESULT_FROM_WRes(x) HRESULT_FROM_WIN32(x)\n+\n #else\n+\n typedef int WRes;\n+#define MY__FACILITY_WIN32 7\n+#define MY__FACILITY__WRes MY__FACILITY_WIN32\n+#define MY_SRes_HRESULT_FROM_WRes(x) ((HRESULT)(x) <= 0 ? ((HRESULT)(x)) : ((HRESULT) (((x) & 0x0000FFFF) | (MY__FACILITY__WRes << 16) | 0x80000000)))\n+\n #endif\n \n+\n #ifndef RINOK\n #define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; }\n #endif\n@@ -81,10 +103,18 @@ typedef UInt32 SizeT;\n typedef size_t SizeT;\n #endif\n \n-typedef int Bool;\n+typedef int BoolInt;\n+/* typedef BoolInt Bool; */\n #define True 1\n #define False 0\n \n+\n+#ifdef _WIN32\n+#define MY_STD_CALL __stdcall\n+#else\n+#define MY_STD_CALL\n+#endif\n+\n #ifdef _MSC_VER\n \n #if _MSC_VER >= 1300\n@@ -93,47 +123,72 @@ typedef int Bool;\n #define MY_NO_INLINE\n #endif\n \n+#define MY_FORCE_INLINE __forceinline\n+\n #define MY_CDECL __cdecl\n #define MY_FAST_CALL __fastcall\n \n #else\n \n #define MY_NO_INLINE\n+#define MY_FORCE_INLINE\n #define MY_CDECL\n #define MY_FAST_CALL\n \n+/* inline keyword : for C++ / C99 */\n+\n+/* GCC, clang: */\n+/*\n+#if defined (__GNUC__) && (__GNUC__ >= 4)\n+#define MY_FORCE_INLINE __attribute__((always_inline))\n+#define MY_NO_INLINE __attribute__((noinline))\n+#endif\n+*/\n+\n #endif\n \n+\n /* The following interfaces use first parameter as pointer to structure */\n \n-typedef struct\n+typedef struct IByteIn IByteIn;\n+struct IByteIn\n {\n- Byte (*Read)(void *p); /* reads one byte, returns 0 in case of EOF or error */\n-} IByteIn;\n+ Byte (*Read)(const IByteIn *p); /* reads one byte, returns 0 in case of EOF or error */\n+};\n+#define IByteIn_Read(p) (p)->Read(p)\n \n-typedef struct\n+\n+typedef struct IByteOut IByteOut;\n+struct IByteOut\n {\n- void (*Write)(void *p, Byte b);\n-} IByteOut;\n+ void (*Write)(const IByteOut *p, Byte b);\n+};\n+#define IByteOut_Write(p, b) (p)->Write(p, b)\n \n-typedef struct\n+\n+typedef struct ISeqInStream ISeqInStream;\n+struct ISeqInStream\n {\n- SRes (*Read)(void *p, void *buf, size_t *size);\n+ SRes (*Read)(const ISeqInStream *p, void *buf, size_t *size);\n /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.\n (output(*size) < input(*size)) is allowed */\n-} ISeqInStream;\n+};\n+#define ISeqInStream_Read(p, buf, size) (p)->Read(p, buf, size)\n \n /* it can return SZ_ERROR_INPUT_EOF */\n-SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size);\n-SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType);\n-SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf);\n+SRes SeqInStream_Read(const ISeqInStream *stream, void *buf, size_t size);\n+SRes SeqInStream_Read2(const ISeqInStream *stream, void *buf, size_t size, SRes errorType);\n+SRes SeqInStream_ReadByte(const ISeqInStream *stream, Byte *buf);\n \n-typedef struct\n+\n+typedef struct ISeqOutStream ISeqOutStream;\n+struct ISeqOutStream\n {\n- size_t (*Write)(void *p, const void *buf, size_t size);\n+ size_t (*Write)(const ISeqOutStream *p, const void *buf, size_t size);\n /* Returns: result - the number of actually written bytes.\n (result < size) means error */\n-} ISeqOutStream;\n+};\n+#define ISeqOutStream_Write(p, buf, size) (p)->Write(p, buf, size)\n \n typedef enum\n {\n@@ -142,78 +197,162 @@ typedef enum\n SZ_SEEK_END = 2\n } ESzSeek;\n \n-typedef struct\n+\n+typedef struct ISeekInStream ISeekInStream;\n+struct ISeekInStream\n {\n- SRes (*Read)(void *p, void *buf, size_t *size); /* same as ISeqInStream::Read */\n- SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin);\n-} ISeekInStream;\n+ SRes (*Read)(const ISeekInStream *p, void *buf, size_t *size); /* same as ISeqInStream::Read */\n+ SRes (*Seek)(const ISeekInStream *p, Int64 *pos, ESzSeek origin);\n+};\n+#define ISeekInStream_Read(p, buf, size) (p)->Read(p, buf, size)\n+#define ISeekInStream_Seek(p, pos, origin) (p)->Seek(p, pos, origin)\n \n-typedef struct\n+\n+typedef struct ILookInStream ILookInStream;\n+struct ILookInStream\n {\n- SRes (*Look)(void *p, const void **buf, size_t *size);\n+ SRes (*Look)(const ILookInStream *p, const void **buf, size_t *size);\n /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.\n (output(*size) > input(*size)) is not allowed\n (output(*size) < input(*size)) is allowed */\n- SRes (*Skip)(void *p, size_t offset);\n+ SRes (*Skip)(const ILookInStream *p, size_t offset);\n /* offset must be <= output(*size) of Look */\n \n- SRes (*Read)(void *p, void *buf, size_t *size);\n+ SRes (*Read)(const ILookInStream *p, void *buf, size_t *size);\n /* reads directly (without buffer). It's same as ISeqInStream::Read */\n- SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin);\n-} ILookInStream;\n+ SRes (*Seek)(const ILookInStream *p, Int64 *pos, ESzSeek origin);\n+};\n+\n+#define ILookInStream_Look(p, buf, size) (p)->Look(p, buf, size)\n+#define ILookInStream_Skip(p, offset) (p)->Skip(p, offset)\n+#define ILookInStream_Read(p, buf, size) (p)->Read(p, buf, size)\n+#define ILookInStream_Seek(p, pos, origin) (p)->Seek(p, pos, origin)\n+\n \n-SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size);\n-SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset);\n+SRes LookInStream_LookRead(const ILookInStream *stream, void *buf, size_t *size);\n+SRes LookInStream_SeekTo(const ILookInStream *stream, UInt64 offset);\n \n /* reads via ILookInStream::Read */\n-SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType);\n-SRes LookInStream_Read(ILookInStream *stream, void *buf, size_t size);\n+SRes LookInStream_Read2(const ILookInStream *stream, void *buf, size_t size, SRes errorType);\n+SRes LookInStream_Read(const ILookInStream *stream, void *buf, size_t size);\n+\n \n-#define LookToRead_BUF_SIZE (1 << 14)\n \n typedef struct\n {\n- ILookInStream s;\n- ISeekInStream *realStream;\n+ ILookInStream vt;\n+ const ISeekInStream *realStream;\n+ \n size_t pos;\n- size_t size;\n- Byte buf[LookToRead_BUF_SIZE];\n-} CLookToRead;\n+ size_t size; /* it's data size */\n+ \n+ /* the following variables must be set outside */\n+ Byte *buf;\n+ size_t bufSize;\n+} CLookToRead2;\n+\n+void LookToRead2_CreateVTable(CLookToRead2 *p, int lookahead);\n+\n+#define LookToRead2_Init(p) { (p)->pos = (p)->size = 0; }\n \n-void LookToRead_CreateVTable(CLookToRead *p, int lookahead);\n-void LookToRead_Init(CLookToRead *p);\n \n typedef struct\n {\n- ISeqInStream s;\n- ILookInStream *realStream;\n+ ISeqInStream vt;\n+ const ILookInStream *realStream;\n } CSecToLook;\n \n void SecToLook_CreateVTable(CSecToLook *p);\n \n+\n+\n typedef struct\n {\n- ISeqInStream s;\n- ILookInStream *realStream;\n+ ISeqInStream vt;\n+ const ILookInStream *realStream;\n } CSecToRead;\n \n void SecToRead_CreateVTable(CSecToRead *p);\n \n-typedef struct\n+\n+typedef struct ICompressProgress ICompressProgress;\n+\n+struct ICompressProgress\n {\n- SRes (*Progress)(void *p, UInt64 inSize, UInt64 outSize);\n+ SRes (*Progress)(const ICompressProgress *p, UInt64 inSize, UInt64 outSize);\n /* Returns: result. (result != SZ_OK) means break.\n Value (UInt64)(Int64)-1 for size means unknown value. */\n-} ICompressProgress;\n+};\n+#define ICompressProgress_Progress(p, inSize, outSize) (p)->Progress(p, inSize, outSize)\n \n-typedef struct\n+\n+\n+typedef struct ISzAlloc ISzAlloc;\n+typedef const ISzAlloc * ISzAllocPtr;\n+\n+struct ISzAlloc\n {\n- void *(*Alloc)(void *p, size_t size);\n- void (*Free)(void *p, void *address); /* address can be 0 */\n-} ISzAlloc;\n+ void *(*Alloc)(ISzAllocPtr p, size_t size);\n+ void (*Free)(ISzAllocPtr p, void *address); /* address can be 0 */\n+};\n+\n+#define ISzAlloc_Alloc(p, size) (p)->Alloc(p, size)\n+#define ISzAlloc_Free(p, a) (p)->Free(p, a)\n+\n+/* deprecated */\n+#define IAlloc_Alloc(p, size) ISzAlloc_Alloc(p, size)\n+#define IAlloc_Free(p, a) ISzAlloc_Free(p, a)\n+\n+\n+\n+\n+\n+#ifndef MY_offsetof\n+ #ifdef offsetof\n+ #define MY_offsetof(type, m) offsetof(type, m)\n+ /*\n+ #define MY_offsetof(type, m) FIELD_OFFSET(type, m)\n+ */\n+ #else\n+ #define MY_offsetof(type, m) ((size_t)&(((type *)0)->m))\n+ #endif\n+#endif\n+\n+\n+\n+#ifndef MY_container_of\n+\n+/*\n+#define MY_container_of(ptr, type, m) container_of(ptr, type, m)\n+#define MY_container_of(ptr, type, m) CONTAINING_RECORD(ptr, type, m)\n+#define MY_container_of(ptr, type, m) ((type *)((char *)(ptr) - offsetof(type, m)))\n+#define MY_container_of(ptr, type, m) (&((type *)0)->m == (ptr), ((type *)(((char *)(ptr)) - MY_offsetof(type, m))))\n+*/\n+\n+/*\n+ GCC shows warning: \"perhaps the 'offsetof' macro was used incorrectly\"\n+ GCC 3.4.4 : classes with constructor\n+ GCC 4.8.1 : classes with non-public variable members\"\n+*/\n+\n+#define MY_container_of(ptr, type, m) ((type *)((char *)(1 ? (ptr) : &((type *)0)->m) - MY_offsetof(type, m)))\n+\n+\n+#endif\n+\n+#define CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m) ((type *)(ptr))\n+\n+/*\n+#define CONTAINER_FROM_VTBL(ptr, type, m) CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)\n+*/\n+#define CONTAINER_FROM_VTBL(ptr, type, m) MY_container_of(ptr, type, m)\n+\n+#define CONTAINER_FROM_VTBL_CLS(ptr, type, m) CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)\n+/*\n+#define CONTAINER_FROM_VTBL_CLS(ptr, type, m) CONTAINER_FROM_VTBL(ptr, type, m)\n+*/\n+\n \n-#define IAlloc_Alloc(p, size) (p)->Alloc((p), size)\n-#define IAlloc_Free(p, a) (p)->Free((p), a)\n \n #ifdef _WIN32\n \n@@ -225,10 +364,12 @@ typedef struct\n #else\n \n #define CHAR_PATH_SEPARATOR '/'\n-#define WCHAR_PATH_SEPARATOR u'/'\n+#define WCHAR_PATH_SEPARATOR L'/'\n #define STRING_PATH_SEPARATOR \"/\"\n-#define WSTRING_PATH_SEPARATOR u\"/\"\n+#define WSTRING_PATH_SEPARATOR L\"/\"\n \n #endif\n \n+EXTERN_C_END\n+\n #endif\ndiff --git a/lib/lzma/Compiler.h b/lib/lzma/Compiler.h\nindex 6e964897e1ee..0cc409d8a864 100644\n--- a/lib/lzma/Compiler.h\n+++ b/lib/lzma/Compiler.h\n@@ -1,5 +1,5 @@\n-/* Compiler.h -- Compiler ypes\n-2013-11-12 : Igor Pavlov : Public domain */\n+/* Compiler.h\n+2017-04-03 : Igor Pavlov : Public domain */\n \n #ifndef __7Z_COMPILER_H\n #define __7Z_COMPILER_H\n@@ -18,11 +18,16 @@\n #else\n #pragma warning(disable : 4511) // copy constructor could not be generated\n #pragma warning(disable : 4512) // assignment operator could not be generated\n+ #pragma warning(disable : 4514) // unreferenced inline function has been removed\n #pragma warning(disable : 4702) // unreachable code\n #pragma warning(disable : 4710) // not inlined\n+ #pragma warning(disable : 4714) // function marked as __forceinline not inlined\n #pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information\n #endif\n \n #endif\n \n+#define UNUSED_VAR(x) (void)x;\n+/* #define UNUSED_VAR(x) x=x; */\n+\n #endif\ndiff --git a/lib/lzma/LzmaDec.c b/lib/lzma/LzmaDec.c\nindex 53196e37076b..3319c7cf4938 100644\n--- a/lib/lzma/LzmaDec.c\n+++ b/lib/lzma/LzmaDec.c\n@@ -1,13 +1,14 @@\n /* LzmaDec.c -- LZMA Decoder\n-2015-01-01 : Igor Pavlov : Public domain */\n+2018-07-04 : Igor Pavlov : Public domain */\n \n #include \"Precomp.h\"\n \n #include \n #include \n-#include \"LzmaDec.h\"\n \n #include \n+/* #include \"CpuArch.h\" */\n+#include \"LzmaDec.h\"\n \n #define kNumTopBits 24\n #define kTopValue ((UInt32)1 << kNumTopBits)\n@@ -20,15 +21,22 @@\n \n #define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }\n \n-#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)\n+#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound)\n #define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));\n #define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits));\n #define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \\\n { UPDATE_0(p); i = (i + i); A0; } else \\\n { UPDATE_1(p); i = (i + i) + 1; A1; }\n-#define GET_BIT(p, i) GET_BIT2(p, i, ; , ;)\n \n-#define TREE_GET_BIT(probs, i) { GET_BIT((probs + i), i); }\n+#define TREE_GET_BIT(probs, i) { GET_BIT2(probs + i, i, ;, ;); }\n+\n+#define REV_BIT(p, i, A0, A1) IF_BIT_0(p + i) \\\n+ { UPDATE_0(p + i); A0; } else \\\n+ { UPDATE_1(p + i); A1; }\n+#define REV_BIT_VAR( p, i, m) REV_BIT(p, i, i += m; m += m, m += m; i += m; )\n+#define REV_BIT_CONST(p, i, m) REV_BIT(p, i, i += m; , i += m * 2; )\n+#define REV_BIT_LAST( p, i, m) REV_BIT(p, i, i -= m , ; )\n+\n #define TREE_DECODE(probs, limit, i) \\\n { i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; }\n \n@@ -48,16 +56,19 @@\n i -= 0x40; }\n #endif\n \n-#define NORMAL_LITER_DEC GET_BIT(prob + symbol, symbol)\n+#define NORMAL_LITER_DEC TREE_GET_BIT(prob, symbol)\n #define MATCHED_LITER_DEC \\\n- matchByte <<= 1; \\\n- bit = (matchByte & offs); \\\n- probLit = prob + offs + bit + symbol; \\\n- GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit)\n+ matchByte += matchByte; \\\n+ bit = offs; \\\n+ offs &= matchByte; \\\n+ probLit = prob + (offs + bit + symbol); \\\n+ GET_BIT2(probLit, symbol, offs ^= bit; , ;)\n+\n+\n \n #define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); }\n \n-#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)\n+#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound)\n #define UPDATE_0_CHECK range = bound;\n #define UPDATE_1_CHECK range -= bound; code -= bound;\n #define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \\\n@@ -67,24 +78,29 @@\n #define TREE_DECODE_CHECK(probs, limit, i) \\\n { i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; }\n \n+\n+#define REV_BIT_CHECK(p, i, m) IF_BIT_0_CHECK(p + i) \\\n+ { UPDATE_0_CHECK; i += m; m += m; } else \\\n+ { UPDATE_1_CHECK; m += m; i += m; }\n+\n+\n #define kNumPosBitsMax 4\n #define kNumPosStatesMax (1 << kNumPosBitsMax)\n \n #define kLenNumLowBits 3\n #define kLenNumLowSymbols (1 << kLenNumLowBits)\n-#define kLenNumMidBits 3\n-#define kLenNumMidSymbols (1 << kLenNumMidBits)\n #define kLenNumHighBits 8\n #define kLenNumHighSymbols (1 << kLenNumHighBits)\n \n-#define LenChoice 0\n-#define LenChoice2 (LenChoice + 1)\n-#define LenLow (LenChoice2 + 1)\n-#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))\n-#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))\n+#define LenLow 0\n+#define LenHigh (LenLow + 2 * (kNumPosStatesMax << kLenNumLowBits))\n #define kNumLenProbs (LenHigh + kLenNumHighSymbols)\n \n+#define LenChoice LenLow\n+#define LenChoice2 (LenLow + (1 << kLenNumLowBits))\n+\n #define kNumStates 12\n+#define kNumStates2 16\n #define kNumLitStates 7\n \n #define kStartPosModelIndex 4\n@@ -98,54 +114,117 @@\n #define kAlignTableSize (1 << kNumAlignBits)\n \n #define kMatchMinLen 2\n-#define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols + kLenNumMidSymbols + kLenNumHighSymbols)\n+#define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols * 2 + kLenNumHighSymbols)\n+\n+/* External ASM code needs same CLzmaProb array layout. So don't change it. */\n \n-#define IsMatch 0\n-#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))\n+/* (probs_1664) is faster and better for code size at some platforms */\n+/*\n+#ifdef MY_CPU_X86_OR_AMD64\n+*/\n+#define kStartOffset 1664\n+#define GET_PROBS p->probs_1664\n+/*\n+#define GET_PROBS p->probs + kStartOffset\n+#else\n+#define kStartOffset 0\n+#define GET_PROBS p->probs\n+#endif\n+*/\n+\n+#define SpecPos (-kStartOffset)\n+#define IsRep0Long (SpecPos + kNumFullDistances)\n+#define RepLenCoder (IsRep0Long + (kNumStates2 << kNumPosBitsMax))\n+#define LenCoder (RepLenCoder + kNumLenProbs)\n+#define IsMatch (LenCoder + kNumLenProbs)\n+#define Align (IsMatch + (kNumStates2 << kNumPosBitsMax))\n+#define IsRep (Align + kAlignTableSize)\n #define IsRepG0 (IsRep + kNumStates)\n #define IsRepG1 (IsRepG0 + kNumStates)\n #define IsRepG2 (IsRepG1 + kNumStates)\n-#define IsRep0Long (IsRepG2 + kNumStates)\n-#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))\n-#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))\n-#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)\n-#define LenCoder (Align + kAlignTableSize)\n-#define RepLenCoder (LenCoder + kNumLenProbs)\n-#define Literal (RepLenCoder + kNumLenProbs)\n+#define PosSlot (IsRepG2 + kNumStates)\n+#define Literal (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))\n+#define NUM_BASE_PROBS (Literal + kStartOffset)\n \n-#define LZMA_BASE_SIZE 1846\n-#define LZMA_LIT_SIZE 768\n-\n-#define LzmaProps_GetNumProbs(p) ((UInt32)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))\n+#if Align != 0 && kStartOffset != 0\n+ #error Stop_Compiling_Bad_LZMA_kAlign\n+#endif\n \n-#if Literal != LZMA_BASE_SIZE\n-StopCompilingDueBUG\n+#if NUM_BASE_PROBS != 1984\n+ #error Stop_Compiling_Bad_LZMA_PROBS\n #endif\n \n+\n+#define LZMA_LIT_SIZE 0x300\n+\n+#define LzmaProps_GetNumProbs(p) (NUM_BASE_PROBS + ((UInt32)LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))\n+\n+\n+#define CALC_POS_STATE(processedPos, pbMask) (((processedPos) & (pbMask)) << 4)\n+#define COMBINED_PS_STATE (posState + state)\n+#define GET_LEN_STATE (posState)\n+\n #define LZMA_DIC_MIN (1 << 12)\n \n-/* First LZMA-symbol is always decoded.\n-And it decodes new LZMA-symbols while (buf < bufLimit), but \"buf\" is without last normalization\n+/*\n+p->remainLen : shows status of LZMA decoder:\n+ < kMatchSpecLenStart : normal remain\n+ = kMatchSpecLenStart : finished\n+ = kMatchSpecLenStart + 1 : need init range coder\n+ = kMatchSpecLenStart + 2 : need init range coder and state\n+*/\n+\n+/* ---------- LZMA_DECODE_REAL ---------- */\n+/*\n+LzmaDec_DecodeReal_3() can be implemented in external ASM file.\n+3 - is the code compatibility version of that function for check at link time.\n+*/\n+\n+#define LZMA_DECODE_REAL LzmaDec_DecodeReal_3\n+\n+/*\n+LZMA_DECODE_REAL()\n+In:\n+ RangeCoder is normalized\n+ if (p->dicPos == limit)\n+ {\n+ LzmaDec_TryDummy() was called before to exclude LITERAL and MATCH-REP cases.\n+ So first symbol can be only MATCH-NON-REP. And if that MATCH-NON-REP symbol\n+ is not END_OF_PAYALOAD_MARKER, then function returns error code.\n+ }\n+\n+Processing:\n+ first LZMA symbol will be decoded in any case\n+ All checks for limits are at the end of main loop,\n+ It will decode new LZMA-symbols while (p->buf < bufLimit && dicPos < limit),\n+ RangeCoder is still without last normalization when (p->buf < bufLimit) is being checked.\n+\n Out:\n+ RangeCoder is normalized\n Result:\n SZ_OK - OK\n SZ_ERROR_DATA - Error\n p->remainLen:\n < kMatchSpecLenStart : normal remain\n = kMatchSpecLenStart : finished\n- = kMatchSpecLenStart + 1 : Flush marker\n- = kMatchSpecLenStart + 2 : State Init Marker\n */\n \n-static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit)\n-{\n- CLzmaProb *probs = p->probs;\n \n- unsigned state = p->state;\n+#ifdef _LZMA_DEC_OPT\n+\n+int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit);\n+\n+#else\n+\n+static\n+int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit)\n+{\n+ CLzmaProb *probs = GET_PROBS;\n+ unsigned state = (unsigned)p->state;\n UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];\n unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;\n- unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1;\n unsigned lc = p->prop.lc;\n+ unsigned lpMask = ((unsigned)0x100 << p->prop.lp) - ((unsigned)0x100 >> lc);\n \n Byte *dic = p->dic;\n SizeT dicBufSize = p->dicBufSize;\n@@ -165,20 +244,20 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte\n CLzmaProb *prob;\n UInt32 bound;\n unsigned ttt;\n- unsigned posState = processedPos & pbMask;\n+ unsigned posState = CALC_POS_STATE(processedPos, pbMask);\n \n if (!(loop++ & 1023))\n \t schedule();\n \n- prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;\n+ prob = probs + IsMatch + COMBINED_PS_STATE;\n IF_BIT_0(prob)\n {\n unsigned symbol;\n UPDATE_0(prob);\n prob = probs + Literal;\n- if (checkDicSize != 0 || processedPos != 0)\n- prob += (LZMA_LIT_SIZE * (((processedPos & lpMask) << lc) +\n- (dic[(dicPos == 0 ? dicBufSize : dicPos) - 1] >> (8 - lc))));\n+ if (processedPos != 0 || checkDicSize != 0)\n+ prob += (UInt32)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);\n+ processedPos++;\n \n if (state < kNumLitStates)\n {\n@@ -199,7 +278,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte\n }\n else\n {\n- unsigned matchByte = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];\n+ unsigned matchByte = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];\n unsigned offs = 0x100;\n state -= (state < 10) ? 3 : 6;\n symbol = 1;\n@@ -226,11 +305,11 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte\n }\n #endif\n }\n+\n dic[dicPos++] = (Byte)symbol;\n- processedPos++;\n continue;\n }\n- else\n+\n {\n UPDATE_1(prob);\n prob = probs + IsRep + state;\n@@ -243,17 +322,20 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte\n else\n {\n UPDATE_1(prob);\n+ /*\n+ // that case was checked before with kBadRepCode\n if (checkDicSize == 0 && processedPos == 0)\n return SZ_ERROR_DATA;\n+ */\n prob = probs + IsRepG0 + state;\n IF_BIT_0(prob)\n {\n UPDATE_0(prob);\n- prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;\n+ prob = probs + IsRep0Long + COMBINED_PS_STATE;\n IF_BIT_0(prob)\n {\n UPDATE_0(prob);\n- dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];\n+ dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];\n dicPos++;\n processedPos++;\n state = state < kNumLitStates ? 9 : 11;\n@@ -294,15 +376,17 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte\n state = state < kNumLitStates ? 8 : 11;\n prob = probs + RepLenCoder;\n }\n+\n+ #ifdef _LZMA_SIZE_OPT\n {\n- unsigned limit, offset;\n+ unsigned lim, offset;\n CLzmaProb *probLen = prob + LenChoice;\n IF_BIT_0(probLen)\n {\n UPDATE_0(probLen);\n- probLen = prob + LenLow + (posState << kLenNumLowBits);\n+ probLen = prob + LenLow + GET_LEN_STATE;\n offset = 0;\n- limit = (1 << kLenNumLowBits);\n+ lim = (1 << kLenNumLowBits);\n }\n else\n {\n@@ -311,21 +395,57 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte\n IF_BIT_0(probLen)\n {\n UPDATE_0(probLen);\n- probLen = prob + LenMid + (posState << kLenNumMidBits);\n+ probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);\n offset = kLenNumLowSymbols;\n- limit = (1 << kLenNumMidBits);\n+ lim = (1 << kLenNumLowBits);\n }\n else\n {\n UPDATE_1(probLen);\n probLen = prob + LenHigh;\n- offset = kLenNumLowSymbols + kLenNumMidSymbols;\n- limit = (1 << kLenNumHighBits);\n+ offset = kLenNumLowSymbols * 2;\n+ lim = (1 << kLenNumHighBits);\n }\n }\n- TREE_DECODE(probLen, limit, len);\n+ TREE_DECODE(probLen, lim, len);\n len += offset;\n }\n+ #else\n+ {\n+ CLzmaProb *probLen = prob + LenChoice;\n+ IF_BIT_0(probLen)\n+ {\n+ UPDATE_0(probLen);\n+ probLen = prob + LenLow + GET_LEN_STATE;\n+ len = 1;\n+ TREE_GET_BIT(probLen, len);\n+ TREE_GET_BIT(probLen, len);\n+ TREE_GET_BIT(probLen, len);\n+ len -= 8;\n+ }\n+ else\n+ {\n+ UPDATE_1(probLen);\n+ probLen = prob + LenChoice2;\n+ IF_BIT_0(probLen)\n+ {\n+ UPDATE_0(probLen);\n+ probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);\n+ len = 1;\n+ TREE_GET_BIT(probLen, len);\n+ TREE_GET_BIT(probLen, len);\n+ TREE_GET_BIT(probLen, len);\n+ }\n+ else\n+ {\n+ UPDATE_1(probLen);\n+ probLen = prob + LenHigh;\n+ TREE_DECODE(probLen, (1 << kLenNumHighBits), len);\n+ len += kLenNumLowSymbols * 2;\n+ }\n+ }\n+ }\n+ #endif\n \n if (state >= kNumStates)\n {\n@@ -336,28 +456,26 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte\n if (distance >= kStartPosModelIndex)\n {\n unsigned posSlot = (unsigned)distance;\n- int numDirectBits = (int)(((distance >> 1) - 1));\n+ unsigned numDirectBits = (unsigned)(((distance >> 1) - 1));\n distance = (2 | (distance & 1));\n if (posSlot < kEndPosModelIndex)\n {\n distance <<= numDirectBits;\n- prob = probs + SpecPos + distance - posSlot - 1;\n+ prob = probs + SpecPos;\n {\n- UInt32 mask = 1;\n- unsigned i = 1;\n-\n+ UInt32 m = 1;\n+ distance++;\n do\n {\n- GET_BIT2(prob + i, i, ; , distance |= mask);\n- mask <<= 1;\n+ REV_BIT_VAR(prob, distance, m);\n }\n- while (--numDirectBits != 0);\n+ while (--numDirectBits);\n+ distance -= m;\n }\n }\n else\n {\n numDirectBits -= kNumAlignBits;\n-\n do\n {\n NORMALIZE\n@@ -379,64 +497,69 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte\n }\n */\n }\n- while (--numDirectBits != 0);\n+ while (--numDirectBits);\n prob = probs + Align;\n distance <<= kNumAlignBits;\n {\n unsigned i = 1;\n- GET_BIT2(prob + i, i, ; , distance |= 1);\n- GET_BIT2(prob + i, i, ; , distance |= 2);\n- GET_BIT2(prob + i, i, ; , distance |= 4);\n- GET_BIT2(prob + i, i, ; , distance |= 8);\n+ REV_BIT_CONST(prob, i, 1);\n+ REV_BIT_CONST(prob, i, 2);\n+ REV_BIT_CONST(prob, i, 4);\n+ REV_BIT_LAST (prob, i, 8);\n+ distance |= i;\n }\n if (distance == (UInt32)0xFFFFFFFF)\n {\n- len += kMatchSpecLenStart;\n+ len = kMatchSpecLenStart;\n state -= kNumStates;\n break;\n }\n }\n }\n+\n rep3 = rep2;\n rep2 = rep1;\n rep1 = rep0;\n rep0 = distance + 1;\n- if (checkDicSize == 0)\n+ state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;\n+ if (distance >= (checkDicSize == 0 ? processedPos: checkDicSize))\n {\n- if (distance >= processedPos)\n- return SZ_ERROR_DATA;\n- }\n- else if (distance >= checkDicSize)\n+ p->dicPos = dicPos;\n return SZ_ERROR_DATA;\n- state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;\n+ }\n }\n \n len += kMatchMinLen;\n \n- if (limit == dicPos)\n- return SZ_ERROR_DATA;\n {\n- SizeT rem = limit - dicPos;\n- unsigned curLen = ((rem < len) ? (unsigned)rem : len);\n- SizeT pos = (dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0);\n+ SizeT rem;\n+ unsigned curLen;\n+ SizeT pos;\n+\n+ if ((rem = limit - dicPos) == 0)\n+ {\n+ p->dicPos = dicPos;\n+ return SZ_ERROR_DATA;\n+ }\n \n- processedPos += curLen;\n+ curLen = ((rem < len) ? (unsigned)rem : len);\n+ pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);\n+\n+ processedPos += (UInt32)curLen;\n \n len -= curLen;\n- if (pos + curLen <= dicBufSize)\n+ if (curLen <= dicBufSize - pos)\n {\n Byte *dest = dic + dicPos;\n ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;\n const Byte *lim = dest + curLen;\n- dicPos += curLen;\n-\n+ dicPos += (SizeT)curLen;\n do\n *(dest) = (Byte)*(dest + src);\n while (++dest != lim);\n }\n else\n {\n-\n do\n {\n dic[dicPos++] = dic[pos];\n@@ -453,20 +576,22 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte\n schedule();\n \n NORMALIZE;\n+\n p->buf = buf;\n p->range = range;\n p->code = code;\n- p->remainLen = len;\n+ p->remainLen = (UInt32)len;\n p->dicPos = dicPos;\n p->processedPos = processedPos;\n p->reps[0] = rep0;\n p->reps[1] = rep1;\n p->reps[2] = rep2;\n p->reps[3] = rep3;\n- p->state = state;\n+ p->state = (UInt32)state;\n \n return SZ_OK;\n }\n+#endif\n \n static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)\n {\n@@ -475,26 +600,35 @@ static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)\n Byte *dic = p->dic;\n SizeT dicPos = p->dicPos;\n SizeT dicBufSize = p->dicBufSize;\n- unsigned len = p->remainLen;\n- UInt32 rep0 = p->reps[0];\n- if (limit - dicPos < len)\n- len = (unsigned)(limit - dicPos);\n+ unsigned len = (unsigned)p->remainLen;\n+ SizeT rep0 = p->reps[0]; /* we use SizeT to avoid the BUG of VC14 for AMD64 */\n+ SizeT rem = limit - dicPos;\n+ if (rem < len)\n+ len = (unsigned)(rem);\n \n if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)\n p->checkDicSize = p->prop.dicSize;\n \n- p->processedPos += len;\n- p->remainLen -= len;\n+ p->processedPos += (UInt32)len;\n+ p->remainLen -= (UInt32)len;\n while (len != 0)\n {\n len--;\n- dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];\n+ dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];\n dicPos++;\n }\n p->dicPos = dicPos;\n }\n }\n \n+\n+#define kRange0 0xFFFFFFFF\n+#define kBound0 ((kRange0 >> kNumBitModelTotalBits) << (kNumBitModelTotalBits - 1))\n+#define kBadRepCode (kBound0 + (((kRange0 - kBound0) >> kNumBitModelTotalBits) << (kNumBitModelTotalBits - 1)))\n+#if kBadRepCode != (0xC0000000 - 0x400)\n+ #error Stop_Compiling_Bad_LZMA_Check\n+#endif\n+\n static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)\n {\n do\n@@ -505,18 +639,21 @@ static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte\n UInt32 rem = p->prop.dicSize - p->processedPos;\n if (limit - p->dicPos > rem)\n limit2 = p->dicPos + rem;\n+\n+ if (p->processedPos == 0)\n+ if (p->code >= kBadRepCode)\n+ return SZ_ERROR_DATA;\n }\n- RINOK(LzmaDec_DecodeReal(p, limit2, bufLimit));\n- if (p->processedPos >= p->prop.dicSize)\n+\n+ RINOK(LZMA_DECODE_REAL(p, limit2, bufLimit));\n+\n+ if (p->checkDicSize == 0 && p->processedPos >= p->prop.dicSize)\n p->checkDicSize = p->prop.dicSize;\n+\n LzmaDec_WriteRem(p, limit);\n }\n while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);\n \n- if (p->remainLen > kMatchSpecLenStart)\n- {\n- p->remainLen = kMatchSpecLenStart;\n- }\n return 0;\n }\n \n@@ -533,17 +670,17 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS\n UInt32 range = p->range;\n UInt32 code = p->code;\n const Byte *bufLimit = buf + inSize;\n- CLzmaProb *probs = p->probs;\n- unsigned state = p->state;\n+ const CLzmaProb *probs = GET_PROBS;\n+ unsigned state = (unsigned)p->state;\n ELzmaDummy res;\n \n {\n- CLzmaProb *prob;\n+ const CLzmaProb *prob;\n UInt32 bound;\n unsigned ttt;\n- unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1);\n+ unsigned posState = CALC_POS_STATE(p->processedPos, (1 << p->prop.pb) - 1);\n \n- prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;\n+ prob = probs + IsMatch + COMBINED_PS_STATE;\n IF_BIT_0_CHECK(prob)\n {\n UPDATE_0_CHECK\n@@ -552,9 +689,9 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS\n \n prob = probs + Literal;\n if (p->checkDicSize != 0 || p->processedPos != 0)\n- prob += (LZMA_LIT_SIZE *\n- ((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) +\n- (p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));\n+ prob += ((UInt32)LZMA_LIT_SIZE *\n+ ((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) +\n+ (p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));\n \n if (state < kNumLitStates)\n {\n@@ -564,17 +701,18 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS\n else\n {\n unsigned matchByte = p->dic[p->dicPos - p->reps[0] +\n- ((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)];\n+ (p->dicPos < p->reps[0] ? p->dicBufSize : 0)];\n unsigned offs = 0x100;\n unsigned symbol = 1;\n do\n {\n unsigned bit;\n- CLzmaProb *probLit;\n- matchByte <<= 1;\n- bit = (matchByte & offs);\n- probLit = prob + offs + bit + symbol;\n- GET_BIT2_CHECK(probLit, symbol, offs &= ~bit, offs &= bit)\n+ const CLzmaProb *probLit;\n+ matchByte += matchByte;\n+ bit = offs;\n+ offs &= matchByte;\n+ probLit = prob + (offs + bit + symbol);\n+ GET_BIT2_CHECK(probLit, symbol, offs ^= bit; , ; )\n }\n while (symbol < 0x100);\n }\n@@ -601,7 +739,7 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS\n IF_BIT_0_CHECK(prob)\n {\n UPDATE_0_CHECK;\n- prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;\n+ prob = probs + IsRep0Long + COMBINED_PS_STATE;\n IF_BIT_0_CHECK(prob)\n {\n UPDATE_0_CHECK;\n@@ -640,11 +778,11 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS\n }\n {\n unsigned limit, offset;\n- CLzmaProb *probLen = prob + LenChoice;\n+ const CLzmaProb *probLen = prob + LenChoice;\n IF_BIT_0_CHECK(probLen)\n {\n UPDATE_0_CHECK;\n- probLen = prob + LenLow + (posState << kLenNumLowBits);\n+ probLen = prob + LenLow + GET_LEN_STATE;\n offset = 0;\n limit = 1 << kLenNumLowBits;\n }\n@@ -655,15 +793,15 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS\n IF_BIT_0_CHECK(probLen)\n {\n UPDATE_0_CHECK;\n- probLen = prob + LenMid + (posState << kLenNumMidBits);\n+ probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);\n offset = kLenNumLowSymbols;\n- limit = 1 << kLenNumMidBits;\n+ limit = 1 << kLenNumLowBits;\n }\n else\n {\n UPDATE_1_CHECK;\n probLen = prob + LenHigh;\n- offset = kLenNumLowSymbols + kLenNumMidSymbols;\n+ offset = kLenNumLowSymbols * 2;\n limit = 1 << kLenNumHighBits;\n }\n }\n@@ -675,18 +813,18 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS\n {\n unsigned posSlot;\n prob = probs + PosSlot +\n- ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<\n+ ((len < kNumLenToPosStates - 1 ? len : kNumLenToPosStates - 1) <<\n kNumPosSlotBits);\n TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot);\n if (posSlot >= kStartPosModelIndex)\n {\n- int numDirectBits = ((posSlot >> 1) - 1);\n+ unsigned numDirectBits = ((posSlot >> 1) - 1);\n \n /* if (bufLimit - buf >= 8) return DUMMY_MATCH; */\n \n if (posSlot < kEndPosModelIndex)\n {\n- prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits) - posSlot - 1;\n+ prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits);\n }\n else\n {\n@@ -698,17 +836,18 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS\n code -= range & (((code - range) >> 31) - 1);\n /* if (code >= range) code -= range; */\n }\n- while (--numDirectBits != 0);\n+ while (--numDirectBits);\n prob = probs + Align;\n numDirectBits = kNumAlignBits;\n }\n {\n unsigned i = 1;\n+ unsigned m = 1;\n do\n {\n- GET_BIT_CHECK(prob + i, i);\n+ REV_BIT_CHECK(prob, i, m);\n }\n- while (--numDirectBits != 0);\n+ while (--numDirectBits);\n }\n }\n }\n@@ -718,27 +857,20 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS\n return res;\n }\n \n-static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data)\n-{\n- p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]);\n- p->range = 0xFFFFFFFF;\n- p->needFlush = 0;\n-}\n \n-void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState)\n+void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState)\n {\n- p->needFlush = 1;\n- p->remainLen = 0;\n+ p->remainLen = kMatchSpecLenStart + 1;\n p->tempBufSize = 0;\n \n if (initDic)\n {\n p->processedPos = 0;\n p->checkDicSize = 0;\n- p->needInitState = 1;\n+ p->remainLen = kMatchSpecLenStart + 2;\n }\n if (initState)\n- p->needInitState = 1;\n+ p->remainLen = kMatchSpecLenStart + 2;\n }\n \n void LzmaDec_Init(CLzmaDec *p)\n@@ -747,48 +879,54 @@ void LzmaDec_Init(CLzmaDec *p)\n LzmaDec_InitDicAndState(p, True, True);\n }\n \n-static void LzmaDec_InitStateReal(CLzmaDec *p)\n-{\n- UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp));\n- UInt32 i;\n- CLzmaProb *probs = p->probs;\n- for (i = 0; i < numProbs; i++)\n- probs[i] = kBitModelTotal >> 1;\n- p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;\n- p->state = 0;\n- p->needInitState = 0;\n-}\n \n SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,\n ELzmaFinishMode finishMode, ELzmaStatus *status)\n {\n SizeT inSize = *srcLen;\n (*srcLen) = 0;\n- LzmaDec_WriteRem(p, dicLimit);\n \n *status = LZMA_STATUS_NOT_SPECIFIED;\n \n- while (p->remainLen != kMatchSpecLenStart)\n+ if (p->remainLen > kMatchSpecLenStart)\n {\n- int checkEndMarkNow;\n+ for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--)\n+ p->tempBuf[p->tempBufSize++] = *src++;\n+ if (p->tempBufSize != 0 && p->tempBuf[0] != 0)\n+ return SZ_ERROR_DATA;\n+ if (p->tempBufSize < RC_INIT_SIZE)\n+ {\n+ *status = LZMA_STATUS_NEEDS_MORE_INPUT;\n+ return SZ_OK;\n+ }\n+ p->code =\n+ ((UInt32)p->tempBuf[1] << 24)\n+ | ((UInt32)p->tempBuf[2] << 16)\n+ | ((UInt32)p->tempBuf[3] << 8)\n+ | ((UInt32)p->tempBuf[4]);\n+ p->range = 0xFFFFFFFF;\n+ p->tempBufSize = 0;\n+\n+ if (p->remainLen > kMatchSpecLenStart + 1)\n+ {\n+ SizeT numProbs = LzmaProps_GetNumProbs(&p->prop);\n+ SizeT i;\n+ CLzmaProb *probs = p->probs;\n+ for (i = 0; i < numProbs; i++)\n+ probs[i] = kBitModelTotal >> 1;\n+ p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;\n+ p->state = 0;\n+ }\n \n- if (p->needFlush != 0)\n- {\n- for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--)\n- p->tempBuf[p->tempBufSize++] = *src++;\n- if (p->tempBufSize < RC_INIT_SIZE)\n- {\n- *status = LZMA_STATUS_NEEDS_MORE_INPUT;\n- return SZ_OK;\n- }\n- if (p->tempBuf[0] != 0)\n- return SZ_ERROR_DATA;\n+ p->remainLen = 0;\n+ }\n \n- LzmaDec_InitRc(p, p->tempBuf);\n- p->tempBufSize = 0;\n- }\n+ LzmaDec_WriteRem(p, dicLimit);\n+\n+ while (p->remainLen != kMatchSpecLenStart)\n+ {\n+ int checkEndMarkNow = 0;\n \n- checkEndMarkNow = 0;\n if (p->dicPos >= dicLimit)\n {\n if (p->remainLen == 0 && p->code == 0)\n@@ -809,9 +947,6 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr\n checkEndMarkNow = 1;\n }\n \n- if (p->needInitState)\n- LzmaDec_InitStateReal(p);\n-\n if (p->tempBufSize == 0)\n {\n SizeT processed;\n@@ -852,10 +987,10 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr\n p->tempBufSize = rem;\n if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)\n {\n- int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, rem);\n+ int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, (SizeT)rem);\n if (dummyRes == DUMMY_ERROR)\n {\n- (*srcLen) += lookAhead;\n+ (*srcLen) += (SizeT)lookAhead;\n *status = LZMA_STATUS_NEEDS_MORE_INPUT;\n return SZ_OK;\n }\n@@ -868,18 +1003,30 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr\n p->buf = p->tempBuf;\n if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)\n return SZ_ERROR_DATA;\n- lookAhead -= (rem - (unsigned)(p->buf - p->tempBuf));\n- (*srcLen) += lookAhead;\n+\n+ {\n+ unsigned kkk = (unsigned)(p->buf - p->tempBuf);\n+ if (rem < kkk)\n+ return SZ_ERROR_FAIL; /* some internal error */\n+ rem -= kkk;\n+ if (lookAhead < rem)\n+ return SZ_ERROR_FAIL; /* some internal error */\n+ lookAhead -= rem;\n+ }\n+ (*srcLen) += (SizeT)lookAhead;\n src += lookAhead;\n- inSize -= lookAhead;\n+ inSize -= (SizeT)lookAhead;\n p->tempBufSize = 0;\n }\n }\n- if (p->code == 0)\n- *status = LZMA_STATUS_FINISHED_WITH_MARK;\n- return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA;\n+\n+ if (p->code != 0)\n+ return SZ_ERROR_DATA;\n+ *status = LZMA_STATUS_FINISHED_WITH_MARK;\n+ return SZ_OK;\n }\n \n+\n SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)\n {\n SizeT outSize = *destLen;\n@@ -920,19 +1067,19 @@ SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *sr\n }\n }\n \n-void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)\n+void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc)\n {\n- alloc->Free(alloc, p->probs);\n- p->probs = 0;\n+ ISzAlloc_Free(alloc, p->probs);\n+ p->probs = NULL;\n }\n \n-static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc)\n+static void LzmaDec_FreeDict(CLzmaDec *p, ISzAllocPtr alloc)\n {\n- alloc->Free(alloc, p->dic);\n- p->dic = 0;\n+ ISzAlloc_Free(alloc, p->dic);\n+ p->dic = NULL;\n }\n \n-void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc)\n+void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc)\n {\n LzmaDec_FreeProbs(p, alloc);\n LzmaDec_FreeDict(p, alloc);\n@@ -956,29 +1103,30 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)\n if (d >= (9 * 5 * 5))\n return SZ_ERROR_UNSUPPORTED;\n \n- p->lc = d % 9;\n+ p->lc = (Byte)(d % 9);\n d /= 9;\n- p->pb = d / 5;\n- p->lp = d % 5;\n+ p->pb = (Byte)(d / 5);\n+ p->lp = (Byte)(d % 5);\n \n return SZ_OK;\n }\n \n-static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc)\n+static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAllocPtr alloc)\n {\n UInt32 numProbs = LzmaProps_GetNumProbs(propNew);\n- if (p->probs == 0 || numProbs != p->numProbs)\n+ if (!p->probs || numProbs != p->numProbs)\n {\n LzmaDec_FreeProbs(p, alloc);\n- p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb));\n- p->numProbs = numProbs;\n- if (p->probs == 0)\n+ p->probs = (CLzmaProb *)ISzAlloc_Alloc(alloc, numProbs * sizeof(CLzmaProb));\n+ if (!p->probs)\n return SZ_ERROR_MEM;\n+ p->probs_1664 = p->probs + 1664;\n+ p->numProbs = numProbs;\n }\n return SZ_OK;\n }\n \n-SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)\n+SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc)\n {\n CLzmaProps propNew;\n RINOK(LzmaProps_Decode(&propNew, props, propsSize));\n@@ -987,18 +1135,28 @@ SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, I\n return SZ_OK;\n }\n \n-SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)\n+SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc)\n {\n CLzmaProps propNew;\n SizeT dicBufSize;\n RINOK(LzmaProps_Decode(&propNew, props, propsSize));\n RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));\n- dicBufSize = propNew.dicSize;\n- if (p->dic == 0 || dicBufSize != p->dicBufSize)\n+\n+ {\n+ UInt32 dictSize = propNew.dicSize;\n+ SizeT mask = ((UInt32)1 << 12) - 1;\n+ if (dictSize >= ((UInt32)1 << 30)) mask = ((UInt32)1 << 22) - 1;\n+ else if (dictSize >= ((UInt32)1 << 22)) mask = ((UInt32)1 << 20) - 1;;\n+ dicBufSize = ((SizeT)dictSize + mask) & ~mask;\n+ if (dicBufSize < dictSize)\n+ dicBufSize = dictSize;\n+ }\n+\n+ if (!p->dic || dicBufSize != p->dicBufSize)\n {\n LzmaDec_FreeDict(p, alloc);\n- p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize);\n- if (p->dic == 0)\n+ p->dic = (Byte *)ISzAlloc_Alloc(alloc, dicBufSize);\n+ if (!p->dic)\n {\n LzmaDec_FreeProbs(p, alloc);\n return SZ_ERROR_MEM;\n@@ -1011,7 +1169,7 @@ SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAll\n \n SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,\n const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,\n- ELzmaStatus *status, ISzAlloc *alloc)\n+ ELzmaStatus *status, ISzAllocPtr alloc)\n {\n CLzmaDec p;\n SRes res;\n@@ -1028,7 +1186,6 @@ SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,\n *srcLen = inSize;\n res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);\n *destLen = p.dicPos;\n-\n if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)\n res = SZ_ERROR_INPUT_EOF;\n LzmaDec_FreeProbs(&p, alloc);\ndiff --git a/lib/lzma/LzmaDec.h b/lib/lzma/LzmaDec.h\nindex 1e266991fd08..f3702f5ce608 100644\n--- a/lib/lzma/LzmaDec.h\n+++ b/lib/lzma/LzmaDec.h\n@@ -1,20 +1,25 @@\n /* LzmaDec.h -- LZMA Decoder\n-2013-01-18 : Igor Pavlov : Public domain */\n+2018-04-21 : Igor Pavlov : Public domain */\n \n #ifndef __LZMA_DEC_H\n #define __LZMA_DEC_H\n \n #include \"7zTypes.h\"\n \n+EXTERN_C_BEGIN\n+\n /* #define _LZMA_PROB32 */\n /* _LZMA_PROB32 can increase the speed on some CPUs,\n but memory usage for CLzmaDec::probs will be doubled in that case */\n \n+typedef\n #ifdef _LZMA_PROB32\n-#define CLzmaProb UInt32\n+ UInt32\n #else\n-#define CLzmaProb UInt16\n+ UInt16\n #endif\n+ CLzmaProb;\n+\n \n /* ---------- LZMA Properties ---------- */\n \n@@ -22,7 +27,10 @@\n \n typedef struct _CLzmaProps\n {\n- unsigned lc, lp, pb;\n+ Byte lc;\n+ Byte lp;\n+ Byte pb;\n+ Byte _pad_;\n UInt32 dicSize;\n } CLzmaProps;\n \n@@ -34,6 +42,7 @@ Returns:\n \n SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);\n \n+\n /* ---------- LZMA Decoder state ---------- */\n \n /* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case.\n@@ -43,32 +52,34 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);\n \n typedef struct\n {\n+ /* Don't change this structure. ASM code can use it. */\n CLzmaProps prop;\n CLzmaProb *probs;\n+ CLzmaProb *probs_1664;\n Byte *dic;\n- const Byte *buf;\n- UInt32 range, code;\n- SizeT dicPos;\n SizeT dicBufSize;\n+ SizeT dicPos;\n+ const Byte *buf;\n+ UInt32 range;\n+ UInt32 code;\n UInt32 processedPos;\n UInt32 checkDicSize;\n- unsigned state;\n UInt32 reps[4];\n- unsigned remainLen;\n- int needFlush;\n- int needInitState;\n+ UInt32 state;\n+ UInt32 remainLen;\n+\n UInt32 numProbs;\n unsigned tempBufSize;\n Byte tempBuf[LZMA_REQUIRED_INPUT_MAX];\n } CLzmaDec;\n \n-#define LzmaDec_Construct(p) { (p)->dic = 0; (p)->probs = 0; }\n+#define LzmaDec_Construct(p) { (p)->dic = NULL; (p)->probs = NULL; }\n \n void LzmaDec_Init(CLzmaDec *p);\n \n /* There are two types of LZMA streams:\n- 0) Stream with end mark. That end mark adds about 6 bytes to compressed size.\n- 1) Stream without end mark. You must know exact uncompressed size to decompress such stream. */\n+ - Stream with end mark. That end mark adds about 6 bytes to compressed size.\n+ - Stream without end mark. You must know exact uncompressed size to decompress such stream. */\n \n typedef enum\n {\n@@ -102,6 +113,7 @@ typedef enum\n \n /* ELzmaStatus is used only as output value for function call */\n \n+\n /* ---------- Interfaces ---------- */\n \n /* There are 3 levels of interfaces:\n@@ -111,6 +123,7 @@ typedef enum\n You can select any of these interfaces, but don't mix functions from different\n groups for same object. */\n \n+\n /* There are two variants to allocate state for Dictionary Interface:\n 1) LzmaDec_Allocate / LzmaDec_Free\n 2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs\n@@ -123,11 +136,11 @@ LzmaDec_Allocate* can return:\n SZ_ERROR_UNSUPPORTED - Unsupported properties\n */\n \n-SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc);\n-void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc);\n+SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);\n+void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc);\n \n-SRes LzmaDec_Allocate(CLzmaDec *state, const Byte *prop, unsigned propsSize, ISzAlloc *alloc);\n-void LzmaDec_Free(CLzmaDec *state, ISzAlloc *alloc);\n+SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);\n+void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc);\n \n /* ---------- Dictionary Interface ---------- */\n \n@@ -136,7 +149,7 @@ void LzmaDec_Free(CLzmaDec *state, ISzAlloc *alloc);\n You must work with CLzmaDec variables directly in this interface.\n \n STEPS:\n- LzmaDec_Constr()\n+ LzmaDec_Construct()\n LzmaDec_Allocate()\n for (each new stream)\n {\n@@ -173,6 +186,7 @@ Returns:\n SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,\n const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);\n \n+\n /* ---------- Buffer Interface ---------- */\n \n /* It's zlib-like interface.\n@@ -189,6 +203,7 @@ finishMode:\n SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,\n const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);\n \n+\n /* ---------- One Call Interface ---------- */\n \n /* LzmaDecode\n@@ -212,6 +227,8 @@ Returns:\n \n SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,\n const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,\n- ELzmaStatus *status, ISzAlloc *alloc);\n+ ELzmaStatus *status, ISzAllocPtr alloc);\n+\n+EXTERN_C_END\n \n #endif\ndiff --git a/lib/lzma/LzmaTools.c b/lib/lzma/LzmaTools.c\nindex 400d606784ea..28c42d7293c8 100644\n--- a/lib/lzma/LzmaTools.c\n+++ b/lib/lzma/LzmaTools.c\n@@ -33,8 +33,8 @@\n #include \n #include \n \n-static void *SzAlloc(void *p, size_t size) { return malloc(size); }\n-static void SzFree(void *p, void *address) { free(address); }\n+static void *SzAlloc(ISzAllocPtr p, size_t size) { return malloc(size); }\n+static void SzFree(ISzAllocPtr p, void *address) { free(address); }\n \n int lzmaBuffToBuffDecompress(unsigned char *outStream, SizeT *uncompressedSize,\n \t\t\t const unsigned char *inStream, SizeT length)\n","prefixes":["RFC","5/9"]}