240105.1 · 383f4f5327363d4c5e6a8ae53c57c4a9620aa5e9
released 4.5.0
- add 7zip archive search with option -z, fix #185
- apply Unicode normalization to combining characters in regex patterns, fix #298
- improved TUI TAB directory navigation when searching from the FS root
- updated ugrep.exe option -P to use PCRE2 10.42
reading declarations
@@ -1,4 +1,4 @@-SUBDIRS = lib src+SUBDIRS = lib lzma/C src man1_MANS = man/ugrep.1
@@ -382,7 +382,7 @@ target_alias = @target_alias@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@-SUBDIRS = lib src+SUBDIRS = lib lzma/C src man1_MANS = man/ugrep.1 EXTRA_DIST = README.md LICENSE.txt CONTRIBUTING.md CODE_OF_CONDUCT.md UGREP = $(shell pwd)/$(top_builddir)/bin/ugrep$(EXEEXT)
@@ -59,7 +59,7 @@ Overview 💡 `-Q` replaces `PATTERN` on the command line to let you enter patterns interactively in the TUI. In the TUI use ALT+letter keys to toggle short "letter options" on/off, for example ALT-n (option `-n`) to show/hide line numbers. -- Search the contents of [archives](#archives) (cpio, jar, tar, pax, zip) and [compressed files](#archives) (zip, gz, Z, bz, bz2, lzma, xz, lz4, zstd, brotli)+- Search the contents of [archives](#archives) (zip, tar, pax, jar, cpio, 7z) and [compressed files](#archives) (gz, Z, bz, bz2, lzma, xz, lz4, zstd, brotli) ug -z PATTERN ... ug -z --zmax=2 PATTERN ... @@ -89,7 +89,6 @@ Overview ug --filter='odt,doc,docx,rtf,xls,xlsx,ppt,pptx:soffice --headless --cat %' PATTERN ... ug --filter='pem:openssl x509 -text,cer,crt,der:openssl x509 -text -inform der' PATTERN ... ug --filter='latin1:iconv -f LATIN1 -t UTF-8' PATTERN ...- ug --filter='7z:7z x -so -si' PATTERN ... 💡 the `ug+` command is the same as the `ug` command, but also uses filters to search PDFs, documents, and image metadata @@ -749,9 +748,9 @@ Commonly-used aliases to add to `.bashrc` to increase productivity: - **ugrep** supports fuzzy (approximate) matching with option `-Z`. - **ugrep** supports user-defined global and local configuration files. - **ugrep** searches compressed files and archives with option `-z`.-- **ugrep** searches cpio, jar, pax, tar and zip archives with option `-z`.-- **ugrep** searches cpio, jar, pax, tar and zip archives recursively stored- within archives with `-z` and `--zmax=NUM` for up to `NUM` levels deep.+- **ugrep** searches cpio, jar, pax, tar, zip and 7z archives with option `-z`.+- **ugrep** searches cpio, jar, pax, tar, zip and 7z archives recursively+ stored within archives with `-z` and `--zmax=NUM` for up to `NUM` levels deep. - **ugrep** searches pdf, doc, docx, xls, xlsx, epub, and more with `--filter` using third-party format conversion utilities as plugins. - **ugrep** searches a directory when the FILE argument is a directory, like@@ -778,7 +777,7 @@ Commonly-used aliases to add to `.bashrc` to increase productivity: signature magic byte patterns, and predefined file types, respectively. This allows searching for certain types of files in directory trees, for example with recursive search options `-R` and `-r`. Options `-O`, `-M`, and `-t`- also applies to archived files in cpio, jar, pax, tar, and zip files.+ also applies to archived files in cpio, jar, pax, tar, zip and 7z files. - **ugrep** option `-k`, `--column-number` to display the column number, taking tab spacing into account by expanding tabs, as specified by option `--tabs`. - **ugrep** option `-P` (Perl regular expressions) supports backreferences@@ -1621,13 +1620,11 @@ same line, like XOR: If the standard input is searched, the string ``(standard input)'' is written. -N PATTERN, --neg-regexp=PATTERN- Specify a negative PATTERN used during the search of the input: an- input line is selected only if it matches the specified patterns- unless it matches the negative PATTERN. Same as -e (?^PATTERN).- Negative pattern matches are essentially removed before any other- patterns are matched. Note that longer patterns take precedence- over shorter patterns. Option -N cannot be specified with -P.- This option may be repeated.+ Specify a negative PATTERN to reject specific -e PATTERN matches+ with a counter pattern. Note that longer patterns take precedence+ over shorter patterns, i.e. a negative pattern must be of the same+ length or longer to reject matching patterns. Option -N cannot be+ specified with -P. This option may be repeated. -v, --invert-match Selected lines are those not matching any of the specified patterns.@@ -2023,15 +2020,15 @@ comments: -z, --decompress Search compressed files and archives. Archives (.cpio, .pax, .tar)- and compressed archives (e.g. .zip, .taz, .tgz, .tpz, .tbz, .tbz2,- .tb2, .tz2, .tlz, .txz, .tzst) are searched and matching pathnames- of files in archives are output in braces. When used with option- --zmax=NUM, searches the contents of compressed files and archives- stored within archives up to NUM levels. If -g, -O, -M, or -t is- specified, searches files stored in archives whose filenames match- globs, match filename extensions, match file signature magic bytes,- or match file types, respectively.- Supported compression formats: gzip (.gz), compress (.Z), zip,+ and compressed archives (e.g. .zip, .7z, .taz, .tgz, .tpz, .tbz,+ .tbz2, .tb2, .tz2, .tlz, .txz, .tzst) are searched and matching+ pathnames of files in archives are output in braces. When used+ with option --zmax=NUM, searches the contents of compressed files+ and archives stored within archives up to NUM levels. If -g, -O,+ -M, or -t is specified, searches files stored in archives whose+ filenames match globs, match filename extensions, match file+ signature magic bytes, or match file types, respectively.+ Supported compression formats: gzip (.gz), compress (.Z), zip, 7z, bzip2 (requires suffix .bz, .bz2, .bzip2, .tbz, .tbz2, .tb2, .tz2), lzma and xz (requires suffix .lzma, .tlz, .xz, .txz), lz4 (requires suffix .lz4),@@ -2041,12 +2038,12 @@ comments: --zmax=NUM When used with option -z (--decompress), searches the contents of compressed files and archives stored within archives by up to NUM- expansion levels deep. The default --zmax=1 only permits searching- uncompressed files stored in cpio, pax, tar and zip archives;+ expansion stages. The default --zmax=1 only permits searching+ uncompressed files stored in cpio, pax, tar, zip and 7z archives; compressed files and archives are detected as binary files and are effectively ignored. Specify --zmax=2 to search compressed files- and archives stored in cpio, pax, tar and zip archives. NUM may- range from 1 to 99 for up to 99 decompression and de-archiving+ and archives stored in cpio, pax, tar, zip and 7z archives. NUM+ may range from 1 to 99 for up to 99 decompression and de-archiving steps. Increasing NUM values gradually degrades performance. Files compressed with gzip (`.gz`), compress (`.Z`), bzip2 (`.bz`, `.bz2`,@@ -2058,20 +2055,20 @@ although slower. Other compression formats can be searched with **ugrep** [filters](#filter). -Archives (cpio, jar, pax, tar, and zip) are searched with option `-z`. Regular-files in an archive that match are output with the archive pathnames enclosed-in `{` and `}` braces. Supported tar formats are v7, ustar, gnu, oldgnu, and-pax. Supported cpio formats are odc, newc, and crc. Not supported is the-obsolete non-portable old binary cpio format. Archive formats cpio, tar, and-pax are automatically recognized with option `-z` based on their content,-independent of their filename suffix.+Archives (cpio, jar, pax, tar, zip and 7z) are searched with option `-z`.+Regular files in an archive that match are output with the archive pathnames+enclosed in `{` and `}` braces. Supported tar formats are v7, ustar, gnu,+oldgnu, and pax. Supported cpio formats are odc, newc, and crc. Not supported+is the obsolete non-portable old binary cpio format. Archive formats cpio,+tar, and pax are automatically recognized with option `-z` based on their+content, independent of their filename suffix. By default, uncompressed archives stored within zip archives are also searched:-all cpio, pax, and tar files in zip archives are automatically recognized and-searched. However, by default compressed files stored within archives are not-recognized, e.g. zip files stored within tar files are not searched but rather-all compressed files and archives are searched as if they are binary files-without decompressing them.+all cpio, pax, and tar files stored in zip and 7z archives are automatically+recognized and searched. However, by default, compressed files stored within+archives are not recognized, e.g. zip files stored within tar files are not+searched but rather all compressed files and archives are searched as if they+are binary files without decompressing them. Specify `--zmax=NUM` to search archives that contain compressed files and archives for up to `NUM` levels deep. The value of `NUM` may range from 1 to@@ -2086,14 +2083,14 @@ compressed and uncompressed files that match the filename selection criteria `ugrep -r -z -tc++` searches C++ files such as `main.cpp` and zip and tar archives that contain C++ files such as `main.cpp`. Also included in the search are compressed C++ files such as `main.cpp.gz` and `main.cpp.xz` when-present. Also any cpio, pax, tar, and zip archives when present are searched-for C++ files that they contain, such as `main.cpp`. Use option `--stats` to-see a list of the glob patterns applied to filter file pathnames in the-recursive search and when searching archive contents.+present. Also any cpio, pax, tar, zip and 7z archives when present are+searched for C++ files that they contain, such as `main.cpp`. Use option+`--stats` to see a list of the glob patterns applied to filter file pathnames+in the recursive search and when searching archive contents. When option `-z` is used with options `-g`, `-O`, `-M`, or `-t` to search cpio,-jar, pax, tar, and zip archives, archived files that match the filename selection-criteria are searched only.+jar, pax, tar, zip and 7z archives, archived files that match the filename+selection criteria are searched only. The gzip, compress, and zip formats are automatically detected, which is useful when reading gzip-compressed data from standard input, e.g. input redirected@@ -2113,6 +2110,7 @@ format | filename suffix | tar/pax archive short suffix | suffix r gzip | `.gz` | `.taz`, `.tgz`, `.tpz` | no | automatic | libz | compress | `.Z` | `.taZ`, `.tZ` | no | automatic | *built-in* | zip | `.zip`, `.zipx`, `.ZIP` | | no | automatic | libz |+7zip | `.7z` | | yes | `--label=.7z` | *built-in* | bzip2 | `.bz`, `.bz2`, `.bzip2` | `.tb2`, `.tbz`, `.tbz2`, `.tz2` | yes | `--label=.bz2` | libbz2 | lzma | `.lzma` | `.tlz` | yes | `--label=.lzma` | liblzma | xz | `.xz` | `.txz` | yes | `--label=.xz` | liblzma |@@ -2122,7 +2120,7 @@ brotli | `.br` | | yes bzip3 | `.bz3` | | yes | `--label=.bz3` | libbzip3 | The gzip, bzip2, xz, lz4 and zstd formats support concatenated compressed-files. Concatenated compressed files are searched as one file.+files. Concatenated compressed files are searched as one single file. Supported zip compression methods are stored (0), deflate (8), bzip2 (12), lzma (14), xz (95) and zstd (93). The bzip2, lzma, xz and zstd methods require@@ -2131,12 +2129,18 @@ ugrep to be compiled with the corresponding compression libraries. Searching encrypted zip archives is not supported (perhaps in future releases, depending on requests for enhancements). +Searching 7zip archives takes a lot more RAM and more time compared to other+methods. The 7zip LZMA SDK implementation does not support streaming,+requiring a physical seekable 7z file. This means that 7z files cannot be+searched when nested within archives. Best is to avoid 7zip. Support for 7zip+can be disabled with `./build.sh --disable-7zip` to build ugrep.+ Option `-z` uses threads for task parallelism to speed up searching larger files by running the decompressor concurrently with a search of the decompressed stream. To list all non-empty files stored in a `package.zip` archive, including the-contents of all cpio, pax, tar and zip files that are stored in it:+contents of all cpio, pax, tar, zip and 7z files that are stored in it: ug --zmax=2 -z -l '' package.zip @@ -4471,9 +4475,9 @@ in markdown: specified, use up to MAX mmap memory per thread. -N PATTERN, --neg-regexp=PATTERN- Specify a negative PATTERN to reject pattern matches that also- match PATTERN. Note that longer patterns take precedence over- shorter patterns, i.e. a negative pattern must be of the same+ Specify a negative PATTERN to reject specific -e PATTERN matches+ with a counter pattern. Note that longer patterns take precedence+ over shorter patterns, i.e. a negative pattern must be of the same length or longer to reject matching patterns. Option -N cannot be specified with -P. This option may be repeated. @@ -4756,29 +4760,29 @@ in markdown: -z, --decompress Search compressed files and archives. Archives (.cpio, .pax,- .tar) and compressed archives (e.g. .zip, .taz, .tgz, .tpz, .tbz,- .tbz2, .tb2, .tz2, .tlz, .txz, .tzst) are searched and matching- pathnames of files in archives are output in braces. When used- with option --zmax=NUM, searches the contents of compressed files- and archives stored within archives up to NUM levels. If -g, -O,- -M, or -t is specified, searches files stored in archives whose- filenames match globs, match filename extensions, match file- signature magic bytes, or match file types, respectively.- Supported compression formats: gzip (.gz), compress (.Z), zip,- bzip2 (requires suffix .bz, .bz2, .bzip2, .tbz, .tbz2, .tb2,- .tz2), lzma and xz (requires suffix .lzma, .tlz, .xz, .txz), lz4- (requires suffix .lz4), zstd (requires suffix .zst, .zstd, .tzst),- brotli (requires suffix .br).+ .tar) and compressed archives (e.g. .zip, .7z, .taz, .tgz, .tpz,+ .tbz, .tbz2, .tb2, .tz2, .tlz, .txz, .tzst) are searched and+ matching pathnames of files in archives are output in braces.+ When used with option --zmax=NUM, searches the contents of+ compressed files and archives stored within archives up to NUM+ levels. If -g, -O, -M, or -t is specified, searches files stored+ in archives whose filenames match globs, match filename+ extensions, match file signature magic bytes, or match file types,+ respectively. Supported compression formats: gzip (.gz), compress+ (.Z), zip, 7z, bzip2 (requires suffix .bz, .bz2, .bzip2, .tbz,+ .tbz2, .tb2, .tz2), lzma and xz (requires suffix .lzma, .tlz, .xz,+ .txz), lz4 (requires suffix .lz4), zstd (requires suffix .zst,+ .zstd, .tzst), brotli (requires suffix .br). --zmax=NUM When used with option -z (--decompress), searches the contents of compressed files and archives stored within archives by up to NUM expansion stages. The default --zmax=1 only permits searching- uncompressed files stored in cpio, pax, tar and zip archives;+ uncompressed files stored in cpio, pax, tar, zip and 7z archives; compressed files and archives are detected as binary files and are effectively ignored. Specify --zmax=2 to search compressed files- and archives stored in cpio, pax, tar and zip archives. NUM may- range from 1 to 99 for up to 99 decompression and de-archiving+ and archives stored in cpio, pax, tar, zip and 7z archives. NUM+ may range from 1 to 99 for up to 99 decompression and de-archiving steps. Increasing NUM values gradually degrades performance. -0, --null@@ -5290,8 +5294,9 @@ in markdown: $ ugrep -n FIXME -tc++ -g^bak/,^old/ - Recursively search for the word `copyright' in cpio/jar/pax/tar/zip- archives, compressed and regular files, and in PDFs using a PDF filter:+ Recursively search for the word `copyright' in cpio, jar, pax, tar, zip,+ 7z archives, compressed and regular files, and in PDFs using a PDF+ filter: $ ugrep -z -w --filter='pdf:pdftotext % -' copyright @@ -5348,7 +5353,7 @@ in markdown: - ugrep 4.4.1 December 19, 2023 UGREP(1)+ ugrep 4.5.0 January 5, 2024 UGREP(1) 🔝 [Back to table of contents](#toc)
@@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles.-# Generated by GNU Autoconf 2.71 for ugrep 4.4.+# Generated by GNU Autoconf 2.71 for ugrep 4.5. # # # Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation,@@ -610,8 +610,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='ugrep' PACKAGE_TARNAME='ugrep'-PACKAGE_VERSION='4.4'-PACKAGE_STRING='ugrep 4.4'+PACKAGE_VERSION='4.5'+PACKAGE_STRING='ugrep 4.5' PACKAGE_BUGREPORT='' PACKAGE_URL='' @@ -796,6 +796,7 @@ with_lzma with_lz4 with_zstd with_brotli+enable_7zip with_bzip3 with_bash_completion_dir with_fish_completion_dir@@ -1379,7 +1380,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF-\`configure' configures ugrep 4.4 to adapt to many kinds of systems.+\`configure' configures ugrep 4.5 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1450,7 +1451,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in- short | recursive ) echo "Configuration of ugrep 4.4:";;+ short | recursive ) echo "Configuration of ugrep 4.5:";; esac cat <<\_ACEOF @@ -1464,6 +1465,8 @@ Optional Features: do not reject slow dependency extractors --disable-dependency-tracking speeds up one-time build+ --disable-7zip to disable 7zip and no longer search .7z files (7z+ requires more memory and takes long to decompress) --disable-auto-color disable automatic colors, otherwise colors are enabled by default --enable-color deprecated, use --disable-auto-color@@ -1623,7 +1626,7 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF-ugrep configure 4.4+ugrep configure 4.5 generated by GNU Autoconf 2.71 Copyright (C) 2021 Free Software Foundation, Inc.@@ -2160,7 +2163,7 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by ugrep $as_me 4.4, which was+It was created by ugrep $as_me 4.5, which was generated by GNU Autoconf 2.71. Invocation command line was $ $0$ac_configure_args_raw@@ -3647,7 +3650,7 @@ fi # Define the identity of the package. PACKAGE='ugrep'- VERSION='4.4'+ VERSION='4.5' printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h@@ -8094,6 +8097,8 @@ printf "%s\n" "#define HAVE_LIBZ 1" >>confdefs.h fi +if test -n "${zlib_places}"; then+ # # Handle user hints #@@ -8759,6 +8764,28 @@ printf "%s\n" "#define HAVE_LIBBROTLI 1" >>confdefs.h fi +# Check whether --enable-7zip was given.+if test ${enable_7zip+y}+then :+ enableval=$enable_7zip; with_no_7zip="yes"+else $as_nop+ with_no_7zip="no"+fi++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for --disable-7zip" >&5+printf %s "checking for --disable-7zip... " >&6; }+if test "x$with_no_7zip" = "xno"; then+ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5+printf "%s\n" "no" >&6; }+ CPPFLAGS="$CPPFLAGS -I../lzma/C"+ LDFLAGS="$LDFLAGS -L../lzma/C"+ LIBS="-lviiz $LIBS"+else+ EXTRA_CFLAGS="-DWITH_NO_7ZIP ${EXTRA_CFLAGS}"+ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5+printf "%s\n" "yes" >&6; }+fi+ # Check whether --with-bzip3 was given. if test ${with_bzip3+y}@@ -8906,6 +8933,8 @@ fi fi +fi+ # Check whether --with-bash-completion-dir was given. if test ${with_bash_completion_dir+y}@@ -9642,7 +9671,7 @@ PTHREAD_CFLAGS="" PTHREAD_LIBS="-lpthread" -ac_config_files="$ac_config_files Makefile lib/Makefile src/Makefile"+ac_config_files="$ac_config_files Makefile lib/Makefile src/Makefile lzma/C/Makefile" cat >confcache <<\_ACEOF@@ -10188,7 +10217,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log="-This file was extended by ugrep $as_me 4.4, which was+This file was extended by ugrep $as_me 4.5, which was generated by GNU Autoconf 2.71. Invocation command line was CONFIG_FILES = $CONFIG_FILES@@ -10256,7 +10285,7 @@ ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\-ugrep config.status 4.4+ugrep config.status 4.5 configured by $0, generated by GNU Autoconf 2.71, with options \\"\$ac_cs_config\\" @@ -10390,6 +10419,7 @@ do "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "lib/Makefile") CONFIG_FILES="$CONFIG_FILES lib/Makefile" ;; "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;+ "lzma/C/Makefile") CONFIG_FILES="$CONFIG_FILES lzma/C/Makefile" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac
@@ -1,4 +1,4 @@-AC_INIT([ugrep],[4.4])+AC_INIT([ugrep],[4.5]) AM_INIT_AUTOMAKE([foreign]) AC_CONFIG_HEADERS([config.h]) AC_COPYRIGHT([Copyright (C) 2019-2023 Robert van Engelen, Genivia Inc.])@@ -70,6 +70,8 @@ fi AX_CHECK_ZLIB([], [echo "recommended zlib not found: ugrep option -z is disabled"]) +if test -n "${zlib_places}"; then+ AX_CHECK_BZ2LIB([], [echo "recommended libbz2 not found: ugrep option -z cannot search .bz and .bz2 files"]) AX_CHECK_LZMALIB([], [echo "recommended liblzma not found: ugrep option -z cannot search .lzma and .xz files"])@@ -80,6 +82,22 @@ AX_CHECK_ZSTDLIB([], [echo "optional libzstd not found: install if you want ugre AX_CHECK_BROTLILIB([], [echo "optional brotli library not found: install if you want ugrep option -z to search .br files"]) +AC_ARG_ENABLE(7zip,+ [AS_HELP_STRING([--disable-7zip],+ [to disable 7zip and no longer search .7z files (7z requires more memory and takes long to decompress)])],+ [with_no_7zip="yes"],+ [with_no_7zip="no"])+AC_MSG_CHECKING(for --disable-7zip)+if test "x$with_no_7zip" = "xno"; then+ AC_MSG_RESULT(no)+ CPPFLAGS="$CPPFLAGS -I../lzma/C"+ LDFLAGS="$LDFLAGS -L../lzma/C"+ LIBS="-lviiz $LIBS"+else+ EXTRA_CFLAGS="-DWITH_NO_7ZIP ${EXTRA_CFLAGS}"+ AC_MSG_RESULT(yes)+fi+ AC_ARG_WITH(bzip3, [AS_HELP_STRING([--with-bzip3], [to enable bzip3 library to decompress .bz3 files])],@@ -92,6 +110,8 @@ if test "x$with_bzip3_library" != "x"; then AX_CHECK_BZIP3LIB([], [echo "optional libbzip3 not found: install if you want ugrep option -z to search .bz3 files"]) fi +fi+ AC_ARG_WITH([bash-completion-dir], [AS_HELP_STRING([--with-bash-completion-dir[=PATH]], [install the bash auto-completion script in this directory. @<:@default=yes@:>@])],@@ -353,6 +373,6 @@ AC_SUBST(SIMD_AVX512BW_FLAGS) AC_SUBST([PTHREAD_CFLAGS], [""]) AC_SUBST([PTHREAD_LIBS], ["-lpthread"]) -AC_CONFIG_FILES([Makefile lib/Makefile src/Makefile])+AC_CONFIG_FILES([Makefile lib/Makefile src/Makefile lzma/C/Makefile]) AC_OUTPUT
@@ -56,8 +56,8 @@ class Tables { const int * range(const char *); -}+} // namespace Posix -}+} // namesapce reflex #endif
@@ -265,7 +265,7 @@ struct lazy_intersection { { return !operator==(rhs); }- void find(void)+ void find() { while (i1 != i1_end && i2 != i2_end) {@@ -277,7 +277,7 @@ struct lazy_intersection { break; } }- void next(void)+ void next() { if (i1 != i1_end) i1++;@@ -295,11 +295,11 @@ struct lazy_intersection { s1(s1), s2(s2) { }- const_iterator begin(void) const+ const_iterator begin() const { return const_iterator(s1, s2); }- const_iterator end(void) const+ const_iterator end() const { return const_iterator(s1.end(), s2.end()); }@@ -358,7 +358,7 @@ struct lazy_union { { return !operator==(rhs); }- void find(void)+ void find() { if (i1 == i1_end) {@@ -370,7 +370,7 @@ struct lazy_union { ++i2; } }- void next(void)+ void next() { if (i1 == i1_end) {@@ -428,11 +428,11 @@ struct lazy_union { s1(s1), s2(s2) { }- const_iterator begin(void) const+ const_iterator begin() const { return const_iterator(s1, s2); }- const_iterator end(void) const+ const_iterator end() const { return const_iterator(s1.end(), s2.end()); }
@@ -46,16 +46,20 @@ namespace Unicode { class Tables : public Posix::Tables { public: Tables();+ typedef std::map<int,const int*> Compose;+ Compose compose; private:- void block_scripts(void);- void language_scripts(void);- void letter_scripts(void);+ void block_scripts();+ void language_scripts();+ void letter_scripts();+ void composer(); }; const int * range(const char *);+int compose(int, int); } // namespace Unicode -} // namespace reflex;+} // namespace reflex #endif
@@ -1,6 +1,6 @@ noinst_LIBRARIES = libreflex.a libreflex_a_CPPFLAGS = -I$(top_srcdir)/include $(SIMD_FLAGS) -DWITH_NO_INDENT -DWITH_NO_CODEGEN-libreflex_a_SOURCES = $(top_srcdir)/include/reflex/abslexer.h $(top_srcdir)/include/reflex/absmatcher.h $(top_srcdir)/include/reflex/bits.h $(top_srcdir)/include/reflex/boostmatcher.h $(top_srcdir)/include/reflex/convert.h $(top_srcdir)/include/reflex/debug.h $(top_srcdir)/include/reflex/error.h $(top_srcdir)/include/reflex/flexlexer.h $(top_srcdir)/include/reflex/input.h $(top_srcdir)/include/reflex/matcher.h $(top_srcdir)/include/reflex/pattern.h $(top_srcdir)/include/reflex/posix.h $(top_srcdir)/include/reflex/ranges.h $(top_srcdir)/include/reflex/setop.h $(top_srcdir)/include/reflex/simd.h $(top_srcdir)/include/reflex/stdmatcher.h $(top_srcdir)/include/reflex/timer.h $(top_srcdir)/include/reflex/traits.h $(top_srcdir)/include/reflex/unicode.h $(top_srcdir)/include/reflex/utf8.h convert.cpp debug.cpp error.cpp input.cpp matcher.cpp matcher_avx2.cpp matcher_avx512bw.cpp pattern.cpp posix.cpp simd_avx2.cpp simd_avx512bw.cpp unicode.cpp utf8.cpp block_scripts.cpp language_scripts.cpp letter_scripts.cpp+libreflex_a_SOURCES = $(top_srcdir)/include/reflex/abslexer.h $(top_srcdir)/include/reflex/absmatcher.h $(top_srcdir)/include/reflex/bits.h $(top_srcdir)/include/reflex/boostmatcher.h $(top_srcdir)/include/reflex/convert.h $(top_srcdir)/include/reflex/debug.h $(top_srcdir)/include/reflex/error.h $(top_srcdir)/include/reflex/flexlexer.h $(top_srcdir)/include/reflex/input.h $(top_srcdir)/include/reflex/matcher.h $(top_srcdir)/include/reflex/pattern.h $(top_srcdir)/include/reflex/posix.h $(top_srcdir)/include/reflex/ranges.h $(top_srcdir)/include/reflex/setop.h $(top_srcdir)/include/reflex/simd.h $(top_srcdir)/include/reflex/stdmatcher.h $(top_srcdir)/include/reflex/timer.h $(top_srcdir)/include/reflex/traits.h $(top_srcdir)/include/reflex/unicode.h $(top_srcdir)/include/reflex/utf8.h convert.cpp debug.cpp error.cpp input.cpp matcher.cpp matcher_avx2.cpp matcher_avx512bw.cpp pattern.cpp posix.cpp simd_avx2.cpp simd_avx512bw.cpp unicode.cpp utf8.cpp block_scripts.cpp language_scripts.cpp letter_scripts.cpp composer.cpp # separately compile matcher_avx2.cpp and matcher_avx512bw (with the same content as matcher.cpp) with AVX optimizations enabled libreflex_a-matcher_avx2.$(OBJEXT) : CXXFLAGS += $(SIMD_AVX2_FLAGS)
@@ -128,7 +128,8 @@ am_libreflex_a_OBJECTS = libreflex_a-convert.$(OBJEXT) \ libreflex_a-unicode.$(OBJEXT) libreflex_a-utf8.$(OBJEXT) \ libreflex_a-block_scripts.$(OBJEXT) \ libreflex_a-language_scripts.$(OBJEXT) \- libreflex_a-letter_scripts.$(OBJEXT)+ libreflex_a-letter_scripts.$(OBJEXT) \+ libreflex_a-composer.$(OBJEXT) libreflex_a_OBJECTS = $(am_libreflex_a_OBJECTS) AM_V_P = $(am__v_P_@AM_V@) am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)@@ -146,6 +147,7 @@ DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) depcomp = $(SHELL) $(top_srcdir)/depcomp am__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/libreflex_a-block_scripts.Po \+ ./$(DEPDIR)/libreflex_a-composer.Po \ ./$(DEPDIR)/libreflex_a-convert.Po \ ./$(DEPDIR)/libreflex_a-debug.Po \ ./$(DEPDIR)/libreflex_a-error.Po \@@ -344,7 +346,30 @@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ noinst_LIBRARIES = libreflex.a libreflex_a_CPPFLAGS = -I$(top_srcdir)/include $(SIMD_FLAGS) -DWITH_NO_INDENT -DWITH_NO_CODEGEN-libreflex_a_SOURCES = $(top_srcdir)/include/reflex/abslexer.h $(top_srcdir)/include/reflex/absmatcher.h $(top_srcdir)/include/reflex/bits.h $(top_srcdir)/include/reflex/boostmatcher.h $(top_srcdir)/include/reflex/convert.h $(top_srcdir)/include/reflex/debug.h $(top_srcdir)/include/reflex/error.h $(top_srcdir)/include/reflex/flexlexer.h $(top_srcdir)/include/reflex/input.h $(top_srcdir)/include/reflex/matcher.h $(top_srcdir)/include/reflex/pattern.h $(top_srcdir)/include/reflex/posix.h $(top_srcdir)/include/reflex/ranges.h $(top_srcdir)/include/reflex/setop.h $(top_srcdir)/include/reflex/simd.h $(top_srcdir)/include/reflex/stdmatcher.h $(top_srcdir)/include/reflex/timer.h $(top_srcdir)/include/reflex/traits.h $(top_srcdir)/include/reflex/unicode.h $(top_srcdir)/include/reflex/utf8.h convert.cpp debug.cpp error.cpp input.cpp matcher.cpp matcher_avx2.cpp matcher_avx512bw.cpp pattern.cpp posix.cpp simd_avx2.cpp simd_avx512bw.cpp unicode.cpp utf8.cpp block_scripts.cpp language_scripts.cpp letter_scripts.cpp+libreflex_a_SOURCES = $(top_srcdir)/include/reflex/abslexer.h \+ $(top_srcdir)/include/reflex/absmatcher.h \+ $(top_srcdir)/include/reflex/bits.h \+ $(top_srcdir)/include/reflex/boostmatcher.h \+ $(top_srcdir)/include/reflex/convert.h \+ $(top_srcdir)/include/reflex/debug.h \+ $(top_srcdir)/include/reflex/error.h \+ $(top_srcdir)/include/reflex/flexlexer.h \+ $(top_srcdir)/include/reflex/input.h \+ $(top_srcdir)/include/reflex/matcher.h \+ $(top_srcdir)/include/reflex/pattern.h \+ $(top_srcdir)/include/reflex/posix.h \+ $(top_srcdir)/include/reflex/ranges.h \+ $(top_srcdir)/include/reflex/setop.h \+ $(top_srcdir)/include/reflex/simd.h \+ $(top_srcdir)/include/reflex/stdmatcher.h \+ $(top_srcdir)/include/reflex/timer.h \+ $(top_srcdir)/include/reflex/traits.h \+ $(top_srcdir)/include/reflex/unicode.h \+ $(top_srcdir)/include/reflex/utf8.h convert.cpp debug.cpp \+ error.cpp input.cpp matcher.cpp matcher_avx2.cpp \+ matcher_avx512bw.cpp pattern.cpp posix.cpp simd_avx2.cpp \+ simd_avx512bw.cpp unicode.cpp utf8.cpp block_scripts.cpp \+ language_scripts.cpp letter_scripts.cpp composer.cpp all: all-am .SUFFIXES:@@ -394,6 +419,7 @@ distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libreflex_a-block_scripts.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libreflex_a-composer.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libreflex_a-convert.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libreflex_a-debug.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libreflex_a-error.Po@am__quote@ # am--include-marker@@ -654,6 +680,20 @@ libreflex_a-letter_scripts.obj: letter_scripts.cpp @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libreflex_a_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libreflex_a-letter_scripts.obj `if test -f 'letter_scripts.cpp'; then $(CYGPATH_W) 'letter_scripts.cpp'; else $(CYGPATH_W) '$(srcdir)/letter_scripts.cpp'; fi` +libreflex_a-composer.o: composer.cpp+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libreflex_a_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libreflex_a-composer.o -MD -MP -MF $(DEPDIR)/libreflex_a-composer.Tpo -c -o libreflex_a-composer.o `test -f 'composer.cpp' || echo '$(srcdir)/'`composer.cpp+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libreflex_a-composer.Tpo $(DEPDIR)/libreflex_a-composer.Po+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='composer.cpp' object='libreflex_a-composer.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libreflex_a_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libreflex_a-composer.o `test -f 'composer.cpp' || echo '$(srcdir)/'`composer.cpp++libreflex_a-composer.obj: composer.cpp+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libreflex_a_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libreflex_a-composer.obj -MD -MP -MF $(DEPDIR)/libreflex_a-composer.Tpo -c -o libreflex_a-composer.obj `if test -f 'composer.cpp'; then $(CYGPATH_W) 'composer.cpp'; else $(CYGPATH_W) '$(srcdir)/composer.cpp'; fi`+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libreflex_a-composer.Tpo $(DEPDIR)/libreflex_a-composer.Po+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='composer.cpp' object='libreflex_a-composer.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libreflex_a_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libreflex_a-composer.obj `if test -f 'composer.cpp'; then $(CYGPATH_W) 'composer.cpp'; else $(CYGPATH_W) '$(srcdir)/composer.cpp'; fi`+ ID: $(am__tagged_files) $(am__define_uniq_tagged_files); mkid -fID $$unique tags: tags-am@@ -778,6 +818,7 @@ clean-am: clean-generic clean-noinstLIBRARIES mostlyclean-am distclean: distclean-am -rm -f ./$(DEPDIR)/libreflex_a-block_scripts.Po+ -rm -f ./$(DEPDIR)/libreflex_a-composer.Po -rm -f ./$(DEPDIR)/libreflex_a-convert.Po -rm -f ./$(DEPDIR)/libreflex_a-debug.Po -rm -f ./$(DEPDIR)/libreflex_a-error.Po@@ -839,6 +880,7 @@ installcheck-am: maintainer-clean: maintainer-clean-am -rm -f ./$(DEPDIR)/libreflex_a-block_scripts.Po+ -rm -f ./$(DEPDIR)/libreflex_a-composer.Po -rm -f ./$(DEPDIR)/libreflex_a-convert.Po -rm -f ./$(DEPDIR)/libreflex_a-debug.Po -rm -f ./$(DEPDIR)/libreflex_a-error.Po
@@ -0,0 +1,1844 @@+// Converted from http://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt by composer.l+// With Knuth-Bendix completion applied+#include <reflex/unicode.h>+void reflex::Unicode::Tables::composer()+{+ static const int _768[] = {+ 65, 803,+ 69, 807,+ 73, 780,+ 78, 504,+ 79, 795,+ 85, 795,+ 87, 7808,+ 89, 7922,+ 97, 803,+ 101, 807,+ 105, 780,+ 110, 505,+ 111, 795,+ 117, 795,+ 119, 7809,+ 121, 7923,+ 194, 7846,+ 196, 479,+ 197, 507,+ 202, 7872,+ 207, 479,+ 212, 7890,+ 219, 7785,+ 220, 475,+ 226, 7847,+ 228, 479,+ 229, 507,+ 234, 7873,+ 239, 479,+ 244, 7891,+ 251, 7785,+ 252, 476,+ 258, 7856,+ 259, 7857,+ 274, 7700,+ 275, 7701,+ 278, 481,+ 279, 481,+ 280, 493,+ 281, 493,+ 332, 7760,+ 333, 7761,+ 416, 7900,+ 417, 7901,+ 431, 7914,+ 432, 7915,+ 550, 481,+ 551, 481,+ 768, 7781,+ 769, 8167,+ 770, 7921,+ 771, 472,+ 772, 7803,+ 774, 507,+ 775, 8167,+ 776, 7783,+ 777, 472,+ 778, 7783,+ 780, 7703,+ 795, 7703,+ 803, 472,+ 807, 7803,+ 808, 7785,+ 834, 788,+ 913, 788,+ 917, 788,+ 919, 788,+ 921, 788,+ 927, 788,+ 933, 788,+ 937, 788,+ 938, 8167,+ 939, 8167,+ 945, 788,+ 949, 788,+ 951, 788,+ 953, 788,+ 959, 788,+ 965, 788,+ 969, 788,+ 970, 8146,+ 971, 8162,+ 1045, 1024,+ 1048, 1037,+ 1077, 1104,+ 1080, 1117,+ 7936, 7938,+ 7937, 7939,+ 7944, 7946,+ 7945, 7947,+ 7952, 7954,+ 7953, 7955,+ 7960, 7962,+ 7961, 7963,+ 7968, 7970,+ 7969, 7971,+ 7976, 7978,+ 7977, 7979,+ 7984, 7986,+ 7985, 7987,+ 7992, 7994,+ 7993, 7995,+ 8000, 8002,+ 8001, 8003,+ 8008, 8010,+ 8009, 8011,+ 8016, 8018,+ 8017, 8019,+ 8025, 8027,+ 8032, 8034,+ 8033, 8035,+ 8040, 8042,+ 8041, 8043,+ 8064, 8066,+ 8065, 8067,+ 8072, 8074,+ 8073, 8075,+ 8080, 8082,+ 8081, 8083,+ 8088, 8090,+ 8089, 8091,+ 8096, 8098,+ 8097, 8099,+ 8104, 8106,+ 8105, 8107,+ 8115, 788,+ 8131, 788,+ 8179, 788,+ 0, 0+ };+ compose[768] = _768;+ static const int _769[] = {+ 65, 776,+ 67, 807,+ 69, 807,+ 71, 500,+ 73, 776,+ 75, 7728,+ 76, 313,+ 77, 7742,+ 78, 323,+ 79, 795,+ 80, 7764,+ 82, 340,+ 83, 807,+ 85, 795,+ 87, 7810,+ 89, 221,+ 90, 377,+ 97, 776,+ 99, 807,+ 101, 807,+ 103, 501,+ 105, 776,+ 107, 7729,+ 108, 314,+ 109, 7743,+ 110, 324,+ 111, 795,+ 112, 7765,+ 114, 341,+ 115, 807,+ 117, 795,+ 119, 7811,+ 121, 253,+ 122, 378,+ 194, 7844,+ 197, 506,+ 198, 508,+ 199, 7688,+ 202, 7870,+ 206, 7783,+ 207, 7726,+ 212, 7888,+ 213, 7756,+ 216, 510,+ 219, 7785,+ 220, 471,+ 226, 7845,+ 229, 507,+ 230, 509,+ 231, 7689,+ 234, 7871,+ 238, 7783,+ 239, 7727,+ 244, 7889,+ 245, 7757,+ 248, 511,+ 251, 7785,+ 252, 472,+ 258, 7854,+ 259, 7855,+ 260, 493,+ 261, 493,+ 264, 7803,+ 265, 7803,+ 266, 7803,+ 267, 7803,+ 268, 7803,+ 269, 7803,+ 274, 7702,+ 275, 7703,+ 278, 481,+ 279, 481,+ 280, 493,+ 281, 493,+ 296, 7703,+ 297, 7703,+ 298, 7783,+ 299, 7783,+ 300, 7803,+ 301, 7803,+ 302, 493,+ 303, 493,+ 304, 481,+ 332, 7762,+ 333, 7763,+ 360, 7800,+ 361, 7801,+ 416, 7898,+ 417, 7899,+ 431, 7912,+ 432, 7913,+ 463, 7803,+ 464, 7803,+ 768, 7781,+ 769, 8167,+ 770, 7921,+ 771, 472,+ 772, 7803,+ 774, 7783,+ 775, 8167,+ 776, 7783,+ 777, 472,+ 778, 7781,+ 780, 7703,+ 795, 7703,+ 803, 7781,+ 807, 7803,+ 808, 7785,+ 834, 788,+ 913, 788,+ 917, 788,+ 919, 788,+ 921, 788,+ 927, 788,+ 933, 788,+ 937, 788,+ 938, 8167,+ 939, 8167,+ 945, 788,+ 949, 788,+ 951, 788,+ 953, 788,+ 959, 788,+ 965, 788,+ 969, 788,+ 970, 912,+ 971, 944,+ 978, 979,+ 1043, 1027,+ 1050, 1036,+ 1075, 1107,+ 1082, 1116,+ 7776, 7780,+ 7777, 7781,+ 7880, 7703,+ 7881, 7703,+ 7882, 7879,+ 7883, 7879,+ 7936, 7940,+ 7937, 7941,+ 7944, 7948,+ 7945, 7949,+ 7952, 7956,+ 7953, 7957,+ 7960, 7964,+ 7961, 7965,+ 7968, 7972,+ 7969, 7973,+ 7976, 7980,+ 7977, 7981,+ 7984, 7988,+ 7985, 7989,+ 7992, 7996,+ 7993, 7997,+ 8000, 8004,+ 8001, 8005,+ 8008, 8012,+ 8009, 8013,+ 8016, 8020,+ 8017, 8021,+ 8025, 8029,+ 8032, 8036,+ 8033, 8037,+ 8040, 8044,+ 8041, 8045,+ 8064, 8068,+ 8065, 8069,+ 8072, 8076,+ 8073, 8077,+ 8080, 8084,+ 8081, 8085,+ 8088, 8092,+ 8089, 8093,+ 8096, 8100,+ 8097, 8101,+ 8104, 8108,+ 8105, 8109,+ 8115, 788,+ 8131, 788,+ 8179, 788,+ 0, 0+ };+ compose[769] = _769;+ static const int _770[] = {+ 65, 803,+ 67, 807,+ 69, 807,+ 71, 284,+ 72, 292,+ 73, 803,+ 74, 308,+ 79, 795,+ 83, 807,+ 85, 803,+ 87, 372,+ 89, 374,+ 90, 7824,+ 97, 803,+ 99, 807,+ 101, 807,+ 103, 285,+ 104, 293,+ 105, 803,+ 106, 309,+ 111, 795,+ 115, 807,+ 117, 803,+ 119, 373,+ 121, 375,+ 122, 7825,+ 192, 7846,+ 193, 7844,+ 195, 7850,+ 200, 7872,+ 201, 7870,+ 210, 7890,+ 211, 7888,+ 213, 7894,+ 224, 7847,+ 225, 7845,+ 227, 7851,+ 232, 7873,+ 233, 7871,+ 236, 8167,+ 242, 7891,+ 243, 7889,+ 245, 7895,+ 268, 493,+ 269, 493,+ 278, 481,+ 279, 481,+ 280, 493,+ 281, 493,+ 282, 7783,+ 283, 7783,+ 346, 8167,+ 347, 8167,+ 352, 7783,+ 353, 7783,+ 362, 7803,+ 363, 7803,+ 364, 7785,+ 365, 7785,+ 370, 7803,+ 371, 7803,+ 461, 7783,+ 462, 7783,+ 465, 7783,+ 466, 7783,+ 768, 7803,+ 770, 7785,+ 772, 7781,+ 774, 7783,+ 775, 8167,+ 776, 7783,+ 777, 7803,+ 778, 7781,+ 780, 7803,+ 795, 7785,+ 803, 7921,+ 807, 7803,+ 808, 7803,+ 7778, 7785,+ 7779, 7785,+ 7840, 7852,+ 7841, 7853,+ 7842, 7848,+ 7843, 7849,+ 7864, 7878,+ 7865, 7879,+ 7866, 7874,+ 7867, 7875,+ 7868, 7876,+ 7869, 7877,+ 7884, 7896,+ 7885, 7897,+ 7886, 7892,+ 7887, 7893,+ 0, 0+ };+ compose[770] = _770;+ static const int _771[] = {+ 65, 803,+ 69, 807,+ 73, 776,+ 78, 209,+ 79, 795,+ 85, 795,+ 86, 7804,+ 89, 7928,+ 97, 803,+ 101, 807,+ 105, 776,+ 110, 241,+ 111, 795,+ 117, 795,+ 118, 7805,+ 121, 7929,+ 194, 7850,+ 196, 479,+ 197, 507,+ 202, 7876,+ 203, 7785,+ 211, 7756,+ 212, 7894,+ 214, 7758,+ 218, 7800,+ 219, 7785,+ 220, 472,+ 226, 7851,+ 228, 479,+ 229, 507,+ 234, 7877,+ 235, 7785,+ 243, 7757,+ 244, 7895,+ 246, 7759,+ 250, 7801,+ 251, 7785,+ 252, 472,+ 258, 7860,+ 259, 7861,+ 274, 7703,+ 275, 7703,+ 332, 556,+ 333, 557,+ 416, 7904,+ 417, 7905,+ 431, 7918,+ 432, 7919,+ 550, 481,+ 551, 481,+ 768, 7785,+ 769, 493,+ 770, 7703,+ 771, 472,+ 772, 7803,+ 774, 507,+ 775, 8167,+ 776, 7703,+ 777, 472,+ 778, 7783,+ 780, 7785,+ 795, 7703,+ 803, 472,+ 807, 7803,+ 808, 7785,+ 0, 0+ };+ compose[771] = _771;+ static const int _772[] = {+ 65, 776,+ 69, 807,+ 71, 7712,+ 73, 803,+ 79, 795,+ 85, 803,+ 89, 562,+ 97, 776,+ 101, 807,+ 103, 7713,+ 105, 803,+ 111, 795,+ 117, 803,+ 121, 563,+ 196, 478,+ 198, 482,+ 200, 7700,+ 201, 7702,+ 210, 7760,+ 211, 7762,+ 213, 556,+ 214, 554,+ 220, 469,+ 228, 479,+ 230, 483,+ 232, 7701,+ 233, 7703,+ 242, 7761,+ 243, 7763,+ 245, 557,+ 246, 555,+ 252, 470,+ 260, 493,+ 261, 493,+ 278, 481,+ 279, 481,+ 280, 493,+ 281, 493,+ 364, 7785,+ 365, 7785,+ 370, 7803,+ 371, 7803,+ 431, 7907,+ 432, 7907,+ 490, 492,+ 491, 493,+ 550, 480,+ 551, 481,+ 558, 560,+ 559, 561,+ 768, 7803,+ 770, 7703,+ 772, 7703,+ 774, 7803,+ 775, 7803,+ 776, 7783,+ 777, 7803,+ 778, 7781,+ 780, 561,+ 795, 7785,+ 803, 7803,+ 807, 7803,+ 808, 7785,+ 913, 8121,+ 921, 8153,+ 933, 8169,+ 945, 8113,+ 953, 8145,+ 965, 8161,+ 1048, 1250,+ 1059, 1262,+ 1080, 1251,+ 1091, 1263,+ 7734, 7736,+ 7735, 7737,+ 7770, 7772,+ 7771, 7773,+ 0, 0+ };+ compose[772] = _772;+ static const int _774[] = {+ 65, 803,+ 69, 807,+ 71, 286,+ 73, 803,+ 79, 795,+ 85, 803,+ 97, 803,+ 101, 807,+ 103, 287,+ 105, 803,+ 111, 795,+ 117, 803,+ 192, 7856,+ 193, 7854,+ 195, 7860,+ 224, 7857,+ 225, 7855,+ 227, 7861,+ 236, 8167,+ 370, 7803,+ 371, 7803,+ 416, 561,+ 417, 561,+ 461, 7783,+ 462, 7783,+ 552, 7708,+ 553, 7709,+ 768, 7803,+ 770, 7803,+ 772, 7803,+ 774, 7783,+ 775, 8167,+ 776, 7803,+ 777, 7803,+ 778, 7781,+ 780, 7803,+ 795, 7785,+ 803, 7803,+ 807, 7803,+ 808, 561,+ 913, 8120,+ 921, 8152,+ 933, 8168,+ 945, 8112,+ 953, 8144,+ 965, 8160,+ 1040, 1232,+ 1045, 1238,+ 1046, 1217,+ 1048, 1049,+ 1059, 1038,+ 1072, 1233,+ 1077, 1239,+ 1078, 1218,+ 1080, 1081,+ 1091, 1118,+ 7840, 7862,+ 7841, 7863,+ 7842, 7858,+ 7843, 7859,+ 0, 0+ };+ compose[774] = _774;+ static const int _775[] = {+ 65, 803,+ 66, 7682,+ 67, 807,+ 68, 7690,+ 69, 807,+ 70, 7710,+ 71, 288,+ 72, 7714,+ 73, 803,+ 77, 7744,+ 78, 7748,+ 79, 795,+ 80, 7766,+ 82, 7768,+ 83, 803,+ 84, 7786,+ 87, 7814,+ 88, 7818,+ 89, 7822,+ 90, 379,+ 97, 803,+ 98, 7683,+ 99, 807,+ 100, 7691,+ 101, 807,+ 102, 7711,+ 103, 289,+ 104, 7715,+ 109, 7745,+ 110, 7749,+ 111, 795,+ 112, 7767,+ 114, 7769,+ 115, 803,+ 116, 7787,+ 119, 7815,+ 120, 7819,+ 121, 7823,+ 122, 380,+ 204, 8167,+ 256, 480,+ 257, 481,+ 332, 560,+ 333, 561,+ 346, 7780,+ 347, 7781,+ 348, 7921,+ 349, 7921,+ 350, 7785,+ 351, 7785,+ 352, 7782,+ 353, 7783,+ 383, 7835,+ 416, 561,+ 417, 561,+ 768, 7803,+ 770, 7783,+ 772, 7803,+ 774, 481,+ 775, 8167,+ 776, 481,+ 777, 7803,+ 778, 561,+ 780, 7803,+ 795, 7785,+ 803, 7803,+ 807, 7803,+ 808, 561,+ 7778, 7784,+ 7779, 7785,+ 7840, 7921,+ 7841, 7921,+ 0, 0+ };+ compose[775] = _775;+ static const int _776[] = {+ 65, 778,+ 69, 807,+ 72, 7718,+ 73, 808,+ 79, 795,+ 85, 803,+ 87, 7812,+ 88, 7820,+ 89, 376,+ 97, 778,+ 101, 807,+ 104, 7719,+ 105, 808,+ 111, 795,+ 116, 7831,+ 117, 803,+ 119, 7813,+ 120, 7821,+ 121, 255,+ 205, 7726,+ 213, 7758,+ 217, 475,+ 218, 471,+ 237, 7727,+ 245, 7759,+ 249, 476,+ 250, 472,+ 256, 478,+ 257, 479,+ 296, 7785,+ 297, 7785,+ 332, 554,+ 333, 555,+ 362, 7802,+ 363, 7803,+ 364, 7803,+ 365, 7803,+ 366, 7803,+ 367, 7803,+ 370, 7803,+ 371, 7803,+ 416, 7803,+ 417, 7803,+ 463, 7785,+ 464, 7785,+ 467, 473,+ 468, 474,+ 770, 7785,+ 772, 7703,+ 774, 479,+ 775, 472,+ 776, 474,+ 777, 481,+ 778, 561,+ 780, 7803,+ 788, 8167,+ 795, 472,+ 803, 7803,+ 807, 561,+ 808, 7803,+ 921, 769,+ 933, 769,+ 943, 912,+ 953, 970,+ 965, 971,+ 973, 944,+ 978, 980,+ 1030, 1031,+ 1040, 1234,+ 1045, 1025,+ 1046, 1244,+ 1047, 1246,+ 1048, 1252,+ 1054, 1254,+ 1059, 1264,+ 1063, 1268,+ 1067, 1272,+ 1069, 1260,+ 1072, 1235,+ 1077, 1105,+ 1078, 1245,+ 1079, 1247,+ 1080, 1253,+ 1086, 1255,+ 1091, 1265,+ 1095, 1269,+ 1099, 1273,+ 1101, 1261,+ 1110, 1111,+ 1240, 1242,+ 1241, 1243,+ 1256, 1258,+ 1257, 1259,+ 7840, 7921,+ 7841, 7921,+ 7864, 7921,+ 7865, 7921,+ 7880, 7785,+ 7881, 7785,+ 7882, 7879,+ 7883, 7879,+ 8054, 8146,+ 8058, 8162,+ 8150, 8151,+ 8166, 8167,+ 0, 0+ };+ compose[776] = _776;+ static const int _777[] = {+ 65, 803,+ 69, 807,+ 73, 776,+ 79, 795,+ 85, 795,+ 89, 7926,+ 97, 803,+ 101, 807,+ 105, 776,+ 111, 795,+ 117, 795,+ 121, 7927,+ 194, 7848,+ 196, 479,+ 197, 507,+ 202, 7874,+ 203, 7785,+ 212, 7892,+ 219, 7785,+ 220, 472,+ 226, 7849,+ 228, 479,+ 229, 507,+ 234, 7875,+ 235, 7785,+ 244, 7893,+ 251, 7785,+ 252, 472,+ 258, 7858,+ 259, 7859,+ 274, 7703,+ 275, 7703,+ 416, 7902,+ 417, 7903,+ 431, 7916,+ 432, 7917,+ 550, 481,+ 551, 481,+ 768, 7785,+ 769, 493,+ 770, 7703,+ 771, 472,+ 772, 7803,+ 774, 507,+ 775, 8167,+ 776, 7703,+ 777, 472,+ 778, 7783,+ 780, 7785,+ 795, 7703,+ 803, 472,+ 807, 7803,+ 808, 7785,+ 0, 0+ };+ compose[777] = _777;+ static const int _778[] = {+ 65, 803,+ 85, 795,+ 97, 803,+ 117, 795,+ 119, 7832,+ 121, 7833,+ 193, 506,+ 225, 507,+ 370, 7921,+ 371, 7921,+ 770, 7921,+ 772, 7803,+ 774, 507,+ 776, 561,+ 778, 507,+ 780, 7803,+ 795, 7785,+ 803, 7803,+ 808, 7785,+ 7840, 7921,+ 7841, 7921,+ 0, 0+ };+ compose[778] = _778;+ static const int _779[] = {+ 79, 336,+ 85, 368,+ 111, 337,+ 117, 369,+ 1059, 1266,+ 1091, 1267,+ 0, 0+ };+ compose[779] = _779;+ static const int _780[] = {+ 65, 803,+ 67, 770,+ 68, 270,+ 69, 807,+ 71, 486,+ 72, 542,+ 73, 776,+ 75, 488,+ 76, 317,+ 78, 327,+ 79, 795,+ 82, 344,+ 83, 807,+ 84, 356,+ 85, 803,+ 90, 381,+ 97, 803,+ 99, 770,+ 100, 271,+ 101, 807,+ 103, 487,+ 104, 543,+ 105, 776,+ 106, 496,+ 107, 489,+ 108, 318,+ 110, 328,+ 111, 795,+ 114, 345,+ 115, 807,+ 116, 357,+ 117, 803,+ 122, 382,+ 196, 479,+ 197, 507,+ 199, 7785,+ 203, 7785,+ 220, 473,+ 228, 479,+ 229, 507,+ 231, 7785,+ 235, 7785,+ 252, 474,+ 274, 7703,+ 275, 7703,+ 334, 7803,+ 335, 7803,+ 370, 7803,+ 371, 7803,+ 431, 7907,+ 432, 7907,+ 439, 494,+ 490, 493,+ 491, 493,+ 550, 481,+ 551, 481,+ 558, 481,+ 559, 481,+ 658, 495,+ 768, 7785,+ 769, 493,+ 770, 7703,+ 772, 7703,+ 774, 507,+ 775, 7783,+ 776, 7803,+ 777, 474,+ 778, 7783,+ 780, 481,+ 795, 7703,+ 803, 7783,+ 807, 7803,+ 808, 7785,+ 7776, 7782,+ 7777, 7783,+ 7864, 472,+ 7865, 472,+ 0, 0+ };+ compose[780] = _780;+ static const int _783[] = {+ 65, 512,+ 69, 516,+ 73, 520,+ 79, 524,+ 82, 528,+ 85, 532,+ 97, 513,+ 101, 517,+ 105, 521,+ 111, 525,+ 114, 529,+ 117, 533,+ 1140, 1142,+ 1141, 1143,+ 0, 0+ };+ compose[783] = _783;+ static const int _785[] = {+ 65, 514,+ 69, 518,+ 73, 522,+ 79, 526,+ 82, 530,+ 85, 534,+ 97, 515,+ 101, 519,+ 105, 523,+ 111, 527,+ 114, 531,+ 117, 535,+ 0, 0+ };+ compose[785] = _785;+ static const int _787[] = {+ 788, 8038,+ 834, 834,+ 902, 7948,+ 904, 7964,+ 905, 7980,+ 906, 7996,+ 908, 8012,+ 911, 8044,+ 913, 7944,+ 917, 7960,+ 919, 7976,+ 921, 7992,+ 927, 8008,+ 937, 8040,+ 940, 7940,+ 941, 7956,+ 942, 7972,+ 943, 7988,+ 945, 7936,+ 949, 7952,+ 951, 7968,+ 953, 7984,+ 959, 8000,+ 961, 8164,+ 965, 8016,+ 969, 8032,+ 972, 8004,+ 973, 8020,+ 974, 8036,+ 8048, 7938,+ 8050, 7954,+ 8052, 7970,+ 8054, 7986,+ 8056, 8002,+ 8058, 8018,+ 8060, 8034,+ 8107, 8107,+ 8109, 8109,+ 8111, 8111,+ 8114, 8066,+ 8115, 8064,+ 8116, 8068,+ 8118, 7942,+ 8119, 8070,+ 8122, 7946,+ 8124, 8072,+ 8130, 8082,+ 8131, 8080,+ 8132, 8084,+ 8134, 7974,+ 8135, 8086,+ 8136, 7962,+ 8138, 7978,+ 8140, 8088,+ 8150, 7990,+ 8154, 7994,+ 8166, 8022,+ 8178, 8098,+ 8179, 8096,+ 8180, 8100,+ 8182, 8038,+ 8183, 8102,+ 8184, 8010,+ 8186, 8042,+ 8188, 8104,+ 0, 0+ };+ compose[787] = _787;+ static const int _788[] = {+ 788, 8039,+ 834, 834,+ 902, 7949,+ 904, 7965,+ 905, 7981,+ 906, 7997,+ 908, 8013,+ 910, 8029,+ 911, 8045,+ 913, 7945,+ 917, 7961,+ 919, 7977,+ 921, 7993,+ 927, 8009,+ 929, 8172,+ 933, 8025,+ 937, 8041,+ 940, 7941,+ 941, 7957,+ 942, 7973,+ 943, 7989,+ 945, 7937,+ 949, 7953,+ 951, 7969,+ 953, 7985,+ 959, 8001,+ 961, 8165,+ 965, 8017,+ 969, 8033,+ 972, 8005,+ 973, 8021,+ 974, 8037,+ 8048, 7939,+ 8050, 7955,+ 8052, 7971,+ 8054, 7987,+ 8056, 8003,+ 8058, 8019,+ 8060, 8035,+ 8107, 8107,+ 8109, 8109,+ 8111, 8111,+ 8114, 8067,+ 8115, 8065,+ 8116, 8069,+ 8118, 7943,+ 8119, 8071,+ 8122, 7947,+ 8124, 8073,+ 8130, 8083,+ 8131, 8081,+ 8132, 8085,+ 8134, 7975,+ 8135, 8087,+ 8136, 7963,+ 8138, 7979,+ 8140, 8089,+ 8150, 7991,+ 8154, 7995,+ 8166, 8023,+ 8170, 8027,+ 8178, 8099,+ 8179, 8097,+ 8180, 8101,+ 8182, 8039,+ 8183, 8103,+ 8184, 8011,+ 8186, 8043,+ 8188, 8105,+ 0, 0+ };+ compose[788] = _788;+ static const int _795[] = {+ 79, 776,+ 85, 803,+ 111, 776,+ 117, 803,+ 210, 7900,+ 211, 7898,+ 213, 7904,+ 217, 7914,+ 218, 7912,+ 242, 7901,+ 243, 7899,+ 245, 7905,+ 249, 7915,+ 250, 7913,+ 360, 7918,+ 361, 7919,+ 364, 7803,+ 365, 7803,+ 366, 7803,+ 367, 7803,+ 370, 7803,+ 371, 7803,+ 770, 7907,+ 772, 472,+ 775, 7903,+ 776, 7803,+ 778, 7785,+ 780, 561,+ 795, 7921,+ 803, 7803,+ 808, 7879,+ 7884, 7906,+ 7885, 7907,+ 7886, 7902,+ 7887, 7903,+ 7908, 7920,+ 7909, 7921,+ 7910, 7916,+ 7911, 7917,+ 0, 0+ };+ compose[795] = _795;+ static const int _803[] = {+ 65, 778,+ 66, 7684,+ 68, 7692,+ 69, 807,+ 72, 7716,+ 73, 776,+ 75, 7730,+ 76, 7734,+ 77, 7746,+ 78, 7750,+ 79, 795,+ 82, 7770,+ 83, 807,+ 84, 7788,+ 85, 795,+ 86, 7806,+ 87, 7816,+ 89, 7924,+ 90, 7826,+ 97, 778,+ 98, 7685,+ 100, 7693,+ 101, 807,+ 104, 7717,+ 105, 776,+ 107, 7731,+ 108, 7735,+ 109, 7747,+ 110, 7751,+ 111, 795,+ 114, 7771,+ 115, 807,+ 116, 7789,+ 117, 795,+ 118, 7807,+ 119, 7817,+ 121, 7925,+ 122, 7827,+ 194, 7852,+ 202, 7878,+ 212, 7896,+ 219, 7785,+ 220, 472,+ 226, 7853,+ 234, 7879,+ 244, 7897,+ 251, 7785,+ 252, 472,+ 258, 7862,+ 259, 7863,+ 364, 7785,+ 365, 7785,+ 416, 7906,+ 417, 7907,+ 431, 7920,+ 432, 7921,+ 768, 7879,+ 769, 493,+ 770, 7921,+ 771, 472,+ 772, 7803,+ 774, 7783,+ 775, 7785,+ 776, 7879,+ 777, 472,+ 778, 7853,+ 780, 7921,+ 795, 7785,+ 803, 7785,+ 807, 7803,+ 808, 7785,+ 7776, 7784,+ 7777, 7785,+ 0, 0+ };+ compose[803] = _803;+ static const int _804[] = {+ 85, 7794,+ 117, 7795,+ 0, 0+ };+ compose[804] = _804;+ static const int _805[] = {+ 65, 7680,+ 97, 7681,+ 0, 0+ };+ compose[805] = _805;+ static const int _806[] = {+ 83, 536,+ 84, 538,+ 115, 537,+ 116, 539,+ 0, 0+ };+ compose[806] = _806;+ static const int _807[] = {+ 67, 780,+ 68, 7696,+ 69, 808,+ 71, 290,+ 72, 7720,+ 75, 310,+ 76, 315,+ 78, 325,+ 82, 342,+ 83, 775,+ 84, 354,+ 99, 780,+ 100, 7697,+ 101, 808,+ 103, 291,+ 104, 7721,+ 107, 311,+ 108, 316,+ 110, 326,+ 114, 343,+ 115, 775,+ 116, 355,+ 262, 7688,+ 263, 7689,+ 276, 7708,+ 277, 7709,+ 769, 7803,+ 770, 7785,+ 772, 7709,+ 775, 8167,+ 776, 7785,+ 777, 493,+ 780, 7785,+ 803, 7785,+ 807, 7709,+ 808, 7785,+ 0, 0+ };+ compose[807] = _807;+ static const int _808[] = {+ 65, 778,+ 69, 807,+ 73, 803,+ 79, 780,+ 85, 795,+ 97, 778,+ 101, 807,+ 105, 803,+ 111, 780,+ 117, 795,+ 332, 492,+ 333, 493,+ 552, 7709,+ 553, 7709,+ 768, 7803,+ 774, 8167,+ 776, 493,+ 778, 7803,+ 780, 7803,+ 795, 7921,+ 803, 7803,+ 807, 7803,+ 808, 493,+ 0, 0+ };+ compose[808] = _808;+ static const int _813[] = {+ 68, 7698,+ 69, 7704,+ 76, 7740,+ 78, 7754,+ 84, 7792,+ 85, 7798,+ 100, 7699,+ 101, 7705,+ 108, 7741,+ 110, 7755,+ 116, 7793,+ 117, 7799,+ 0, 0+ };+ compose[813] = _813;+ static const int _814[] = {+ 72, 7722,+ 104, 7723,+ 0, 0+ };+ compose[814] = _814;+ static const int _816[] = {+ 69, 7706,+ 73, 7724,+ 85, 7796,+ 101, 7707,+ 105, 7725,+ 117, 7797,+ 0, 0+ };+ compose[816] = _816;+ static const int _817[] = {+ 66, 7686,+ 68, 7694,+ 75, 7732,+ 76, 7738,+ 78, 7752,+ 82, 7774,+ 84, 7790,+ 90, 7828,+ 98, 7687,+ 100, 7695,+ 104, 7830,+ 107, 7733,+ 108, 7739,+ 110, 7753,+ 114, 7775,+ 116, 7791,+ 122, 7829,+ 0, 0+ };+ compose[817] = _817;+ static const int _834[] = {+ 834, 788,+ 945, 788,+ 951, 788,+ 953, 788,+ 965, 788,+ 969, 788,+ 970, 8151,+ 971, 8167,+ 7936, 7942,+ 7937, 7943,+ 7944, 7950,+ 7945, 7951,+ 7968, 7974,+ 7969, 7975,+ 7976, 7982,+ 7977, 7983,+ 7984, 7990,+ 7985, 7991,+ 7992, 7998,+ 7993, 7999,+ 8016, 8022,+ 8017, 8023,+ 8025, 8031,+ 8032, 8038,+ 8033, 8039,+ 8040, 8046,+ 8041, 8047,+ 8064, 8070,+ 8065, 8071,+ 8072, 8078,+ 8073, 8079,+ 8080, 8086,+ 8081, 8087,+ 8088, 8094,+ 8089, 8095,+ 8096, 8102,+ 8097, 8103,+ 8104, 8110,+ 8105, 8111,+ 8115, 788,+ 8131, 788,+ 8179, 788,+ 0, 0+ };+ compose[834] = _834;+ static const int _837[] = {+ 913, 788,+ 919, 788,+ 937, 788,+ 940, 788,+ 942, 788,+ 945, 788,+ 951, 788,+ 969, 788,+ 974, 788,+ 7936, 834,+ 7937, 834,+ 7938, 8066,+ 7939, 8067,+ 7940, 8068,+ 7941, 8069,+ 7942, 8070,+ 7943, 8071,+ 7944, 834,+ 7945, 834,+ 7946, 8074,+ 7947, 8075,+ 7948, 8076,+ 7949, 8077,+ 7950, 8078,+ 7951, 8079,+ 7968, 834,+ 7969, 834,+ 7970, 8082,+ 7971, 8083,+ 7972, 8084,+ 7973, 8085,+ 7974, 8086,+ 7975, 8087,+ 7976, 834,+ 7977, 834,+ 7978, 8090,+ 7979, 8091,+ 7980, 8092,+ 7981, 8093,+ 7982, 8094,+ 7983, 8095,+ 8032, 834,+ 8033, 834,+ 8034, 8098,+ 8035, 8099,+ 8036, 8100,+ 8037, 8101,+ 8038, 8102,+ 8039, 8103,+ 8040, 834,+ 8041, 834,+ 8042, 8106,+ 8043, 8107,+ 8044, 8108,+ 8045, 8109,+ 8046, 8110,+ 8047, 8111,+ 8048, 788,+ 8052, 788,+ 8060, 788,+ 8118, 788,+ 8134, 788,+ 8182, 788,+ 0, 0+ };+ compose[837] = _837;+ static const int _2364[] = {+ 2325, 2392,+ 2326, 2393,+ 2327, 2394,+ 2332, 2395,+ 2337, 2396,+ 2338, 2397,+ 2344, 2345,+ 2347, 2398,+ 2351, 2399,+ 2352, 2353,+ 2355, 2356,+ 0, 0+ };+ compose[2364] = _2364;+ static const int _2492[] = {+ 2465, 2524,+ 2466, 2525,+ 2479, 2527,+ 0, 0+ };+ compose[2492] = _2492;+ static const int _2494[] = {+ 2503, 2507,+ 0, 0+ };+ compose[2494] = _2494;+ static const int _2519[] = {+ 2503, 2508,+ 0, 0+ };+ compose[2519] = _2519;+ static const int _2620[] = {+ 2582, 2649,+ 2583, 2650,+ 2588, 2651,+ 2603, 2654,+ 2610, 2611,+ 2616, 2614,+ 0, 0+ };+ compose[2620] = _2620;+ static const int _2876[] = {+ 2849, 2908,+ 2850, 2909,+ 0, 0+ };+ compose[2876] = _2876;+ static const int _2878[] = {+ 2887, 2891,+ 0, 0+ };+ compose[2878] = _2878;+ static const int _2902[] = {+ 2887, 2888,+ 0, 0+ };+ compose[2902] = _2902;+ static const int _2903[] = {+ 2887, 2892,+ 0, 0+ };+ compose[2903] = _2903;+ static const int _3006[] = {+ 3014, 3018,+ 3015, 3019,+ 0, 0+ };+ compose[3006] = _3006;+ static const int _3031[] = {+ 2962, 2964,+ 3014, 3020,+ 0, 0+ };+ compose[3031] = _3031;+ static const int _3266[] = {+ 3266, 3275,+ 3270, 3274,+ 3271, 3275,+ 0, 0+ };+ compose[3266] = _3266;+ static const int _3285[] = {+ 3263, 3264,+ 3270, 3266,+ 3274, 3275,+ 0, 0+ };+ compose[3285] = _3285;+ static const int _3286[] = {+ 3270, 3272,+ 0, 0+ };+ compose[3286] = _3286;+ static const int _3390[] = {+ 3398, 3402,+ 3399, 3403,+ 0, 0+ };+ compose[3390] = _3390;+ static const int _3415[] = {+ 3398, 3404,+ 0, 0+ };+ compose[3415] = _3415;+ static const int _3530[] = {+ 3545, 3535,+ 3548, 3549,+ 0, 0+ };+ compose[3530] = _3530;+ static const int _3535[] = {+ 3535, 3549,+ 3545, 3548,+ 3546, 3549,+ 0, 0+ };+ compose[3535] = _3535;+ static const int _3551[] = {+ 3545, 3550,+ 0, 0+ };+ compose[3551] = _3551;+ static const int _4021[] = {+ 3904, 3945,+ 0, 0+ };+ compose[4021] = _4021;+ static const int _4023[] = {+ 3906, 3907,+ 3916, 3917,+ 3921, 3922,+ 3926, 3927,+ 3931, 3932,+ 0, 0+ };+ compose[4023] = _4023;+ static const int _4142[] = {+ 4133, 4134,+ 0, 0+ };+ compose[4142] = _4142;+ static const int _6965[] = {+ 6917, 6918,+ 6919, 6920,+ 6921, 6922,+ 6923, 6924,+ 6925, 6926,+ 6929, 6930,+ 6970, 6971,+ 6972, 6973,+ 6974, 6976,+ 6975, 6977,+ 6978, 6979,+ 0, 0+ };+ compose[6965] = _6965;+ static const int _12441[] = {+ 12358, 12436,+ 12363, 12364,+ 12365, 12366,+ 12367, 12368,+ 12369, 12370,+ 12371, 12372,+ 12373, 12374,+ 12375, 12376,+ 12377, 12378,+ 12379, 12380,+ 12381, 12382,+ 12383, 12384,+ 12385, 12386,+ 12388, 12389,+ 12390, 12391,+ 12392, 12393,+ 12399, 12400,+ 12402, 12403,+ 12405, 12406,+ 12408, 12409,+ 12411, 12412,+ 12445, 12446,+ 12454, 12532,+ 12459, 12460,+ 12461, 12462,+ 12463, 12464,+ 12465, 12466,+ 12467, 12468,+ 12469, 12470,+ 12471, 12472,+ 12473, 12474,+ 12475, 12476,+ 12477, 12478,+ 12479, 12480,+ 12481, 12482,+ 12484, 12485,+ 12486, 12487,+ 12488, 12489,+ 12495, 12496,+ 12498, 12499,+ 12501, 12502,+ 12504, 12505,+ 12507, 12508,+ 12527, 12535,+ 12528, 12536,+ 12529, 12537,+ 12530, 12538,+ 12541, 12542,+ 0, 0+ };+ compose[12441] = _12441;+ static const int _12442[] = {+ 12399, 12401,+ 12402, 12404,+ 12405, 12407,+ 12408, 12410,+ 12411, 12413,+ 12495, 12497,+ 12498, 12500,+ 12501, 12503,+ 12504, 12506,+ 12507, 12509,+ 0, 0+ };+ compose[12442] = _12442;+ static const int _69818[] = {+ 69785, 69786,+ 69787, 69788,+ 69797, 69803,+ 0, 0+ };+ compose[69818] = _69818;+ static const int _70462[] = {+ 70471, 70475,+ 0, 0+ };+ compose[70462] = _70462;+ static const int _70487[] = {+ 70471, 70476,+ 0, 0+ };+ compose[70487] = _70487;+ static const int _70832[] = {+ 70841, 70844,+ 0, 0+ };+ compose[70832] = _70832;+ static const int _70842[] = {+ 70841, 70843,+ 0, 0+ };+ compose[70842] = _70842;+ static const int _70845[] = {+ 70841, 70846,+ 0, 0+ };+ compose[70845] = _70845;+ static const int _71087[] = {+ 71096, 71098,+ 71097, 71099,+ 0, 0+ };+ compose[71087] = _71087;+ static const int _71984[] = {+ 71989, 71992,+ 0, 0+ };+ compose[71984] = _71984;+ static const int _119141[] = {+ 119127, 119134,+ 119128, 119135,+ 119225, 119227,+ 119226, 119228,+ 0, 0+ };+ compose[119141] = _119141;+ static const int _119150[] = {+ 119135, 119136,+ 119227, 119229,+ 119228, 119230,+ 0, 0+ };+ compose[119150] = _119150;+ static const int _119151[] = {+ 119135, 119137,+ 119227, 119231,+ 119228, 119232,+ 0, 0+ };+ compose[119151] = _119151;+ static const int _119152[] = {+ 119135, 119138,+ 0, 0+ };+ compose[119152] = _119152;+ static const int _119153[] = {+ 119135, 119139,+ 0, 0+ };+ compose[119153] = _119153;+ static const int _119154[] = {+ 119135, 119140,+ 0, 0+ };+ compose[119154] = _119154;+}
@@ -498,6 +498,31 @@ static void expand_list(const char *pattern, size_t len, size_t& loc, size_t& po pos += 3; expand_list(pattern, len, loc, pos, flags, mod, signature, par, macros, regex, nl1); }+ else if ((c & 0xC0) == 0xC0 && is_modified(mod, 'u'))+ {+ // Unicode normalization may need to combine a previous ASCII character with a Unicode combining character+ if (loc < pos && std::isalpha(pattern[pos - 1]))+ --pos;+ regex.append(&pattern[loc], pos - loc);+ const char *s = &pattern[pos];+ c = utf8(s, &s);+ while (true)+ {+ // try combining one or more Unicode combining characters, if any+ pos = s - pattern;+ if (pos >= len || (*s & 0xC0) != 0xC0)+ break;+ int next = utf8(s, &s);+ int combined = Unicode::compose(c, next);+ if (combined < 0)+ break;+ c = combined;+ }+ char buf[8];+ size_t size = utf8(c, buf);+ regex.append(buf, size);+ loc = pos--;+ } ++pos; if (pos >= len || pattern[pos] == ']') break;@@ -992,12 +1017,24 @@ static void insert_list(const char *pattern, size_t len, size_t& pos, convert_fl } else {- if ((c & 0xC0) == 0xC0 && is_modified(mod, 'u'))+ if (is_modified(mod, 'u')) {- // unicode: UTF-8 sequence- const char *r;- c = utf8(&pattern[pos], &r);- pos += r - &pattern[pos] - 1;+ // Unicode normalization+ const char *s = &pattern[pos];+ c = utf8(s, &s);+ while (true)+ {+ // try combining one or more Unicode combining characters, if any+ pos = s - pattern;+ if (pos >= len || (*s & 0xC0) != 0xC0)+ break;+ int next = utf8(s, &s);+ int combined = Unicode::compose(c, next);+ if (combined < 0)+ break;+ c = combined;+ }+ --pos; } if (range) {@@ -2179,26 +2216,44 @@ std::string convert(const char *pattern, const char *signature, convert_flag_typ loc = pos + 1; } }- else if ((c & 0xC0) == 0xC0 && is_modified(mod, 'u') && !supports_escape(signature, 'p'))+ else if ((c & 0xC0) == 0xC0 && is_modified(mod, 'u')) {- // unicode: group UTF-8 sequence+ // Unicode normalization may need to combine a previous ASCII character with a Unicode combining character+ if (loc < pos && std::isalpha(pattern[pos - 1]))+ --pos; regex.append(&pattern[loc], pos - loc);- loc = pos;- while (pos + 1 < len && ((c = pattern[++pos]) & 0xC0) == 0x80)- continue;+ const char *s = &pattern[pos];+ c = utf8(s, &s);+ while (true)+ {+ // try combining one or more Unicode combining characters, if any+ pos = s - pattern;+ if (pos >= len || (*s & 0xC0) != 0xC0)+ break;+ int next = utf8(s, &s);+ int combined = Unicode::compose(c, next);+ if (combined < 0)+ break;+ c = combined;+ }+ char buf[8];+ size_t size = utf8(c, buf); if (pos < len &&+ !supports_escape(signature, 'p') && (pattern[pos] == '*' || ((flags & convert_flag::basic) && pos + 1 < len ? (pattern[pos] == '\\' && (pattern[pos + 1] == '?' || pattern[pos + 1] == '+' || pattern[pos + 1] == '{')) : (pattern[pos] == '?' || pattern[pos] == '+' || pattern[pos] == '{')))) {- regex.append(par).append(&pattern[loc], pos - loc).push_back(')');- loc = pos;- --pos;+ // group normalized Unicode character as UTF-8+ regex.append(par).append(buf, size).push_back(')');+ loc = pos--; } else if (pos > loc) {- --pos;+ // save normalized Unicode character as UTF-8+ regex.append(buf, size);+ loc = pos--; } } anc = false;
@@ -83,6 +83,6 @@ const int * range(const char *s) return NULL; } -}+} // namespace Posix -}+} // namespace reflex
@@ -46,6 +46,7 @@ Tables::Tables() block_scripts(); language_scripts(); letter_scripts();+ composer(); range["Other"] = range["C"]; range["Letter"] = range["L"];@@ -99,6 +100,16 @@ const int * range(const char *s) return NULL; } +int compose(int prev, int next)+{+ Tables::Compose::const_iterator i = tables.compose.find(next);+ if (i != tables.compose.end())+ for (const int *p = i->second; p[0] != 0; p += 2)+ if (p[0] == prev)+ return p[1];+ return -1; } -}+} // namespace Unicode++} // namespace reflex
@@ -0,0 +1,117 @@+/******************************************************************************\+* Copyright (c) 2023, Robert van Engelen, Genivia Inc. All rights reserved. *+* *+* Redistribution and use in source and binary forms, with or without *+* modification, are permitted provided that the following conditions are met: *+* *+* (1) Redistributions of source code must retain the above copyright notice, *+* this list of conditions and the following disclaimer. *+* *+* (2) Redistributions in binary form must reproduce the above copyright *+* notice, this list of conditions and the following disclaimer in the *+* documentation and/or other materials provided with the distribution. *+* *+* (3) The name of the author may not be used to endorse or promote products *+* derived from this software without specific prior written permission. *+* *+* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED *+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO *+* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, *+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *+* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, *+* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR *+* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF *+* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *+\******************************************************************************/++/**+@file 7zls.c+@brief list 7zip archive contents to test and use the new viizip API+@author Robert van Engelen - engelen@genivia.com+@copyright (c) 2023-2023, Robert van Engelen, Genivia Inc. All rights reserved.+@copyright (c) BSD-3 License - see LICENSE.txt+*/++#include <stdlib.h>+#include <stdio.h>+#include <string.h>+#include <time.h>+#include <limits.h>++#include "C/viizip.h"++/* 7zip archive part pathname max length if limits.h doesn't define it */+#ifndef PATH_MAX+#define PATH_MAX 4096+#endif++int main(int argc, char **argv)+{+ struct viizip *viizip;+ FILE *file;++ if (argc < 2)+ exit(EXIT_FAILURE);++ file = fopen(argv[1], "rb");+ if (file == NULL)+ {+ perror("cannot open file");+ exit(EXIT_FAILURE);+ }++ viizip = viinew(file);+ if (viizip == NULL)+ {+ fprintf(stderr, "viinew() failed\n");+ exit(EXIT_FAILURE);+ }++ printf("%zu entries:\n", viinum(viizip));++ while (1)+ {+ unsigned char buf[65536];+ char name[PATH_MAX];+ size_t len;+ time_t mtime;+ uint64_t usize;+ char *ct = "??? ??? ?? ??:??\0?? ????";+ int res = viiget(viizip, name, PATH_MAX, &mtime, &usize);+ if (res < 0)+ {+ fprintf(stderr, "viiget() failed\n");+ exit(EXIT_FAILURE);+ }++ /* no more entries? */+ if (res != 0)+ break;++ len = strlen(name);+ if (len > 0 && name[len - 1] != '/')+ printf("%12llu", usize);+ else+ printf("%12s", "");+ ct = ctime(&mtime); /* note: not MT safe */+ if (ct != NULL)+ ct[19] = ct[24] = '\0';+ printf(" %s %s %s\n", ct + 20, ct + 4, name);++ /* uncomment this code to test incremental decompression into buf[] with viidec()+ {+ ssize_t num;+ while ((num = viidec(viizip, buf, sizeof(buf))) > 0)+ usize -= num;+ if (usize != 0)+ fprintf(stderr, "viidec() failed\n");+ }+ */+ }++ viifree(viizip);+ fclose(file);+ exit(EXIT_SUCCESS);+}
@@ -0,0 +1,204 @@+/* 7z.h -- 7z interface+2023-04-02 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_7Z_H+#define ZIP7_INC_7Z_H++#include "7zTypes.h"++EXTERN_C_BEGIN++#define k7zStartHeaderSize 0x20+#define k7zSignatureSize 6++extern const Byte k7zSignature[k7zSignatureSize];++typedef struct+{+ const Byte *Data;+ size_t Size;+} CSzData;++/* CSzCoderInfo & CSzFolder support only default methods */++typedef struct+{+ size_t PropsOffset;+ UInt32 MethodID;+ Byte NumStreams;+ Byte PropsSize;+} CSzCoderInfo;++typedef struct+{+ UInt32 InIndex;+ UInt32 OutIndex;+} CSzBond;++#define SZ_NUM_CODERS_IN_FOLDER_MAX 4+#define SZ_NUM_BONDS_IN_FOLDER_MAX 3+#define SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX 4++typedef struct+{+ UInt32 NumCoders;+ UInt32 NumBonds;+ UInt32 NumPackStreams;+ UInt32 UnpackStream;+ UInt32 PackStreams[SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX];+ CSzBond Bonds[SZ_NUM_BONDS_IN_FOLDER_MAX];+ CSzCoderInfo Coders[SZ_NUM_CODERS_IN_FOLDER_MAX];+} CSzFolder;+++SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd);++typedef struct+{+ UInt32 Low;+ UInt32 High;+} CNtfsFileTime;++typedef struct+{+ Byte *Defs; /* MSB 0 bit numbering */+ UInt32 *Vals;+} CSzBitUi32s;++typedef struct+{+ Byte *Defs; /* MSB 0 bit numbering */+ // UInt64 *Vals;+ CNtfsFileTime *Vals;+} CSzBitUi64s;++#define SzBitArray_Check(p, i) (((p)[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)++#define SzBitWithVals_Check(p, i) ((p)->Defs && ((p)->Defs[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)++typedef struct+{+ UInt32 NumPackStreams;+ UInt32 NumFolders;++ UInt64 *PackPositions; // NumPackStreams + 1+ CSzBitUi32s FolderCRCs; // NumFolders++ size_t *FoCodersOffsets; // NumFolders + 1+ UInt32 *FoStartPackStreamIndex; // NumFolders + 1+ UInt32 *FoToCoderUnpackSizes; // NumFolders + 1+ Byte *FoToMainUnpackSizeIndex; // NumFolders+ UInt64 *CoderUnpackSizes; // for all coders in all folders++ Byte *CodersData;++ UInt64 RangeLimit;+} CSzAr;++UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex);++SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,+ ILookInStreamPtr stream, UInt64 startPos,+ Byte *outBuffer, size_t outSize,+ ISzAllocPtr allocMain);++typedef struct+{+ CSzAr db;++ UInt64 startPosAfterHeader;+ UInt64 dataPos;+ + UInt32 NumFiles;++ UInt64 *UnpackPositions; // NumFiles + 1+ // Byte *IsEmptyFiles;+ Byte *IsDirs;+ CSzBitUi32s CRCs;++ CSzBitUi32s Attribs;+ // CSzBitUi32s Parents;+ CSzBitUi64s MTime;+ CSzBitUi64s CTime;++ UInt32 *FolderToFile; // NumFolders + 1+ UInt32 *FileToFolder; // NumFiles++ size_t *FileNameOffsets; /* in 2-byte steps */+ Byte *FileNames; /* UTF-16-LE */+} CSzArEx;++#define SzArEx_IsDir(p, i) (SzBitArray_Check((p)->IsDirs, i))++#define SzArEx_GetFileSize(p, i) ((p)->UnpackPositions[(i) + 1] - (p)->UnpackPositions[i])++void SzArEx_Init(CSzArEx *p);+void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc);+UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);+int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize);++/*+if dest == NULL, the return value specifies the required size of the buffer,+ in 16-bit characters, including the null-terminating character.+if dest != NULL, the return value specifies the number of 16-bit characters that+ are written to the dest, including the null-terminating character. */++size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest);++/*+size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex);+UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest);+*/++++/*+ SzArEx_Extract extracts file from archive++ *outBuffer must be 0 before first call for each new archive.++ Extracting cache:+ If you need to decompress more than one file, you can send+ these values from previous call:+ *blockIndex,+ *outBuffer,+ *outBufferSize+ You can consider "*outBuffer" as cache of solid block. If your archive is solid,+ it will increase decompression speed.+ + If you use external function, you can declare these 3 cache variables+ (blockIndex, outBuffer, outBufferSize) as static in that external function.+ + Free *outBuffer and set *outBuffer to 0, if you want to flush cache.+*/++SRes SzArEx_Extract(+ const CSzArEx *db,+ ILookInStreamPtr inStream,+ UInt32 fileIndex, /* index of file */+ UInt32 *blockIndex, /* index of solid block */+ Byte **outBuffer, /* pointer to pointer to output buffer (allocated with allocMain) */+ size_t *outBufferSize, /* buffer size for output buffer */+ size_t *offset, /* offset of stream for required file in *outBuffer */+ size_t *outSizeProcessed, /* size of file in *outBuffer */+ ISzAllocPtr allocMain,+ ISzAllocPtr allocTemp);+++/*+SzArEx_Open Errors:+SZ_ERROR_NO_ARCHIVE+SZ_ERROR_ARCHIVE+SZ_ERROR_UNSUPPORTED+SZ_ERROR_MEM+SZ_ERROR_CRC+SZ_ERROR_INPUT_EOF+SZ_ERROR_FAIL+*/++SRes SzArEx_Open(CSzArEx *p, ILookInStreamPtr inStream,+ ISzAllocPtr allocMain, ISzAllocPtr allocTemp);++EXTERN_C_END++#endif
@@ -0,0 +1,89 @@+/* 7zAlloc.c -- Allocation functions for 7z processing+2023-03-04 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include <stdlib.h>++#include "7zAlloc.h"++/* #define SZ_ALLOC_DEBUG */+/* use SZ_ALLOC_DEBUG to debug alloc/free operations */++#ifdef SZ_ALLOC_DEBUG++/*+#ifdef _WIN32+#include "7zWindows.h"+#endif+*/++#include <stdio.h>+static int g_allocCount = 0;+static int g_allocCountTemp = 0;++static void Print_Alloc(const char *s, size_t size, int *counter)+{+ const unsigned size2 = (unsigned)size;+ fprintf(stderr, "\n%s count = %10d : %10u bytes; ", s, *counter, size2);+ (*counter)++;+}+static void Print_Free(const char *s, int *counter)+{+ (*counter)--;+ fprintf(stderr, "\n%s count = %10d", s, *counter);+}+#endif++void *SzAlloc(ISzAllocPtr p, size_t size)+{+ UNUSED_VAR(p)+ if (size == 0)+ return 0;+ #ifdef SZ_ALLOC_DEBUG+ Print_Alloc("Alloc", size, &g_allocCount);+ #endif+ return malloc(size);+}++void SzFree(ISzAllocPtr p, void *address)+{+ UNUSED_VAR(p)+ #ifdef SZ_ALLOC_DEBUG+ if (address)+ Print_Free("Free ", &g_allocCount);+ #endif+ free(address);+}++void *SzAllocTemp(ISzAllocPtr p, size_t size)+{+ UNUSED_VAR(p)+ if (size == 0)+ return 0;+ #ifdef SZ_ALLOC_DEBUG+ Print_Alloc("Alloc_temp", size, &g_allocCountTemp);+ /*+ #ifdef _WIN32+ return HeapAlloc(GetProcessHeap(), 0, size);+ #endif+ */+ #endif+ return malloc(size);+}++void SzFreeTemp(ISzAllocPtr p, void *address)+{+ UNUSED_VAR(p)+ #ifdef SZ_ALLOC_DEBUG+ if (address)+ Print_Free("Free_temp ", &g_allocCountTemp);+ /*+ #ifdef _WIN32+ HeapFree(GetProcessHeap(), 0, address);+ return;+ #endif+ */+ #endif+ free(address);+}
@@ -0,0 +1,19 @@+/* 7zAlloc.h -- Allocation functions+2023-03-04 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_7Z_ALLOC_H+#define ZIP7_INC_7Z_ALLOC_H++#include "7zTypes.h"++EXTERN_C_BEGIN++void *SzAlloc(ISzAllocPtr p, size_t size);+void SzFree(ISzAllocPtr p, void *address);++void *SzAllocTemp(ISzAllocPtr p, size_t size);+void SzFreeTemp(ISzAllocPtr p, void *address);++EXTERN_C_END++#endif
@@ -0,0 +1,1786 @@+/* 7zArcIn.c -- 7z Input functions+2023-05-11 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include <string.h>++#include "7z.h"+#include "7zBuf.h"+#include "7zCrc.h"+#include "CpuArch.h"++#define MY_ALLOC(T, p, size, alloc) \+ { if ((p = (T *)ISzAlloc_Alloc(alloc, (size) * sizeof(T))) == NULL) return SZ_ERROR_MEM; }++#define MY_ALLOC_ZE(T, p, size, alloc) \+ { if ((size) == 0) p = NULL; else MY_ALLOC(T, p, size, alloc) }++#define MY_ALLOC_AND_CPY(to, size, from, alloc) \+ { MY_ALLOC(Byte, to, size, alloc); memcpy(to, from, size); }++#define MY_ALLOC_ZE_AND_CPY(to, size, from, alloc) \+ { if ((size) == 0) to = NULL; else { MY_ALLOC_AND_CPY(to, size, from, alloc) } }++#define k7zMajorVersion 0++enum EIdEnum+{+ k7zIdEnd,+ k7zIdHeader,+ k7zIdArchiveProperties,+ k7zIdAdditionalStreamsInfo,+ k7zIdMainStreamsInfo,+ k7zIdFilesInfo,+ k7zIdPackInfo,+ k7zIdUnpackInfo,+ k7zIdSubStreamsInfo,+ k7zIdSize,+ k7zIdCRC,+ k7zIdFolder,+ k7zIdCodersUnpackSize,+ k7zIdNumUnpackStream,+ k7zIdEmptyStream,+ k7zIdEmptyFile,+ k7zIdAnti,+ k7zIdName,+ k7zIdCTime,+ k7zIdATime,+ k7zIdMTime,+ k7zIdWinAttrib,+ k7zIdComment,+ k7zIdEncodedHeader,+ k7zIdStartPos,+ k7zIdDummy+ // k7zNtSecure,+ // k7zParent,+ // k7zIsReal+};++const Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};++#define SzBitUi32s_INIT(p) { (p)->Defs = NULL; (p)->Vals = NULL; }++static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAllocPtr alloc)+{+ if (num == 0)+ {+ p->Defs = NULL;+ p->Vals = NULL;+ }+ else+ {+ MY_ALLOC(Byte, p->Defs, (num + 7) >> 3, alloc)+ MY_ALLOC(UInt32, p->Vals, num, alloc)+ }+ return SZ_OK;+}++static void SzBitUi32s_Free(CSzBitUi32s *p, ISzAllocPtr alloc)+{+ ISzAlloc_Free(alloc, p->Defs); p->Defs = NULL;+ ISzAlloc_Free(alloc, p->Vals); p->Vals = NULL;+}++#define SzBitUi64s_INIT(p) { (p)->Defs = NULL; (p)->Vals = NULL; }++static void SzBitUi64s_Free(CSzBitUi64s *p, ISzAllocPtr alloc)+{+ ISzAlloc_Free(alloc, p->Defs); p->Defs = NULL;+ ISzAlloc_Free(alloc, p->Vals); p->Vals = NULL;+}+++static void SzAr_Init(CSzAr *p)+{+ p->NumPackStreams = 0;+ p->NumFolders = 0;+ + p->PackPositions = NULL;+ SzBitUi32s_INIT(&p->FolderCRCs)++ p->FoCodersOffsets = NULL;+ p->FoStartPackStreamIndex = NULL;+ p->FoToCoderUnpackSizes = NULL;+ p->FoToMainUnpackSizeIndex = NULL;+ p->CoderUnpackSizes = NULL;++ p->CodersData = NULL;++ p->RangeLimit = 0;+}++static void SzAr_Free(CSzAr *p, ISzAllocPtr alloc)+{+ ISzAlloc_Free(alloc, p->PackPositions);+ SzBitUi32s_Free(&p->FolderCRCs, alloc);+ + ISzAlloc_Free(alloc, p->FoCodersOffsets);+ ISzAlloc_Free(alloc, p->FoStartPackStreamIndex);+ ISzAlloc_Free(alloc, p->FoToCoderUnpackSizes);+ ISzAlloc_Free(alloc, p->FoToMainUnpackSizeIndex);+ ISzAlloc_Free(alloc, p->CoderUnpackSizes);+ + ISzAlloc_Free(alloc, p->CodersData);++ SzAr_Init(p);+}+++void SzArEx_Init(CSzArEx *p)+{+ SzAr_Init(&p->db);+ + p->NumFiles = 0;+ p->dataPos = 0;+ + p->UnpackPositions = NULL;+ p->IsDirs = NULL;+ + p->FolderToFile = NULL;+ p->FileToFolder = NULL;+ + p->FileNameOffsets = NULL;+ p->FileNames = NULL;+ + SzBitUi32s_INIT(&p->CRCs)+ SzBitUi32s_INIT(&p->Attribs)+ // SzBitUi32s_INIT(&p->Parents)+ SzBitUi64s_INIT(&p->MTime)+ SzBitUi64s_INIT(&p->CTime)+}++void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc)+{+ ISzAlloc_Free(alloc, p->UnpackPositions);+ ISzAlloc_Free(alloc, p->IsDirs);++ ISzAlloc_Free(alloc, p->FolderToFile);+ ISzAlloc_Free(alloc, p->FileToFolder);++ ISzAlloc_Free(alloc, p->FileNameOffsets);+ ISzAlloc_Free(alloc, p->FileNames);++ SzBitUi32s_Free(&p->CRCs, alloc);+ SzBitUi32s_Free(&p->Attribs, alloc);+ // SzBitUi32s_Free(&p->Parents, alloc);+ SzBitUi64s_Free(&p->MTime, alloc);+ SzBitUi64s_Free(&p->CTime, alloc);+ + SzAr_Free(&p->db, alloc);+ SzArEx_Init(p);+}+++static int TestSignatureCandidate(const Byte *testBytes)+{+ unsigned i;+ for (i = 0; i < k7zSignatureSize; i++)+ if (testBytes[i] != k7zSignature[i])+ return 0;+ return 1;+}++#define SzData_CLEAR(p) { (p)->Data = NULL; (p)->Size = 0; }++#define SZ_READ_BYTE_SD_NOCHECK(_sd_, dest) \+ (_sd_)->Size--; dest = *(_sd_)->Data++;++#define SZ_READ_BYTE_SD(_sd_, dest) \+ if ((_sd_)->Size == 0) return SZ_ERROR_ARCHIVE; \+ SZ_READ_BYTE_SD_NOCHECK(_sd_, dest)++#define SZ_READ_BYTE(dest) SZ_READ_BYTE_SD(sd, dest)++#define SZ_READ_BYTE_2(dest) \+ if (sd.Size == 0) return SZ_ERROR_ARCHIVE; \+ sd.Size--; dest = *sd.Data++;++#define SKIP_DATA(sd, size) { sd->Size -= (size_t)(size); sd->Data += (size_t)(size); }+#define SKIP_DATA2(sd, size) { sd.Size -= (size_t)(size); sd.Data += (size_t)(size); }++#define SZ_READ_32(dest) if (sd.Size < 4) return SZ_ERROR_ARCHIVE; \+ dest = GetUi32(sd.Data); SKIP_DATA2(sd, 4);++static Z7_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)+{+ Byte firstByte, mask;+ unsigned i;+ UInt32 v;++ SZ_READ_BYTE(firstByte)+ if ((firstByte & 0x80) == 0)+ {+ *value = firstByte;+ return SZ_OK;+ }+ SZ_READ_BYTE(v)+ if ((firstByte & 0x40) == 0)+ {+ *value = (((UInt32)firstByte & 0x3F) << 8) | v;+ return SZ_OK;+ }+ SZ_READ_BYTE(mask)+ *value = v | ((UInt32)mask << 8);+ mask = 0x20;+ for (i = 2; i < 8; i++)+ {+ Byte b;+ if ((firstByte & mask) == 0)+ {+ const UInt64 highPart = (unsigned)firstByte & (unsigned)(mask - 1);+ *value |= (highPart << (8 * i));+ return SZ_OK;+ }+ SZ_READ_BYTE(b)+ *value |= ((UInt64)b << (8 * i));+ mask >>= 1;+ }+ return SZ_OK;+}+++static Z7_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)+{+ Byte firstByte;+ UInt64 value64;+ if (sd->Size == 0)+ return SZ_ERROR_ARCHIVE;+ firstByte = *sd->Data;+ if ((firstByte & 0x80) == 0)+ {+ *value = firstByte;+ sd->Data++;+ sd->Size--;+ return SZ_OK;+ }+ RINOK(ReadNumber(sd, &value64))+ if (value64 >= (UInt32)0x80000000 - 1)+ return SZ_ERROR_UNSUPPORTED;+ if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 4)))+ return SZ_ERROR_UNSUPPORTED;+ *value = (UInt32)value64;+ return SZ_OK;+}++#define ReadID(sd, value) ReadNumber(sd, value)++static SRes SkipData(CSzData *sd)+{+ UInt64 size;+ RINOK(ReadNumber(sd, &size))+ if (size > sd->Size)+ return SZ_ERROR_ARCHIVE;+ SKIP_DATA(sd, size)+ return SZ_OK;+}++static SRes WaitId(CSzData *sd, UInt32 id)+{+ for (;;)+ {+ UInt64 type;+ RINOK(ReadID(sd, &type))+ if (type == id)+ return SZ_OK;+ if (type == k7zIdEnd)+ return SZ_ERROR_ARCHIVE;+ RINOK(SkipData(sd))+ }+}++static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v)+{+ const UInt32 numBytes = (numItems + 7) >> 3;+ if (numBytes > sd->Size)+ return SZ_ERROR_ARCHIVE;+ *v = sd->Data;+ SKIP_DATA(sd, numBytes)+ return SZ_OK;+}++static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)+{+ Byte b = 0;+ unsigned m = 0;+ UInt32 sum = 0;+ for (; numItems != 0; numItems--)+ {+ if (m == 0)+ {+ b = *bits++;+ m = 8;+ }+ m--;+ sum += ((b >> m) & 1);+ }+ return sum;+}++static Z7_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, ISzAllocPtr alloc)+{+ Byte allAreDefined;+ Byte *v2;+ const UInt32 numBytes = (numItems + 7) >> 3;+ *v = NULL;+ SZ_READ_BYTE(allAreDefined)+ if (numBytes == 0)+ return SZ_OK;+ if (allAreDefined == 0)+ {+ if (numBytes > sd->Size)+ return SZ_ERROR_ARCHIVE;+ MY_ALLOC_AND_CPY(*v, numBytes, sd->Data, alloc)+ SKIP_DATA(sd, numBytes)+ return SZ_OK;+ }+ MY_ALLOC(Byte, *v, numBytes, alloc)+ v2 = *v;+ memset(v2, 0xFF, (size_t)numBytes);+ {+ const unsigned numBits = (unsigned)numItems & 7;+ if (numBits != 0)+ v2[(size_t)numBytes - 1] = (Byte)((((UInt32)1 << numBits) - 1) << (8 - numBits));+ }+ return SZ_OK;+}++static Z7_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)+{+ UInt32 i;+ CSzData sd;+ UInt32 *vals;+ const Byte *defs;+ MY_ALLOC_ZE(UInt32, crcs->Vals, numItems, alloc)+ sd = *sd2;+ defs = crcs->Defs;+ vals = crcs->Vals;+ for (i = 0; i < numItems; i++)+ if (SzBitArray_Check(defs, i))+ {+ SZ_READ_32(vals[i])+ }+ else+ vals[i] = 0;+ *sd2 = sd;+ return SZ_OK;+}++static SRes ReadBitUi32s(CSzData *sd, UInt32 numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)+{+ SzBitUi32s_Free(crcs, alloc);+ RINOK(ReadBitVector(sd, numItems, &crcs->Defs, alloc))+ return ReadUi32s(sd, numItems, crcs, alloc);+}++static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)+{+ Byte allAreDefined;+ UInt32 numDefined = numItems;+ SZ_READ_BYTE(allAreDefined)+ if (!allAreDefined)+ {+ const size_t numBytes = (numItems + 7) >> 3;+ if (numBytes > sd->Size)+ return SZ_ERROR_ARCHIVE;+ numDefined = CountDefinedBits(sd->Data, numItems);+ SKIP_DATA(sd, numBytes)+ }+ if (numDefined > (sd->Size >> 2))+ return SZ_ERROR_ARCHIVE;+ SKIP_DATA(sd, (size_t)numDefined * 4)+ return SZ_OK;+}++static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAllocPtr alloc)+{+ RINOK(SzReadNumber32(sd, &p->NumPackStreams))++ RINOK(WaitId(sd, k7zIdSize))+ MY_ALLOC(UInt64, p->PackPositions, (size_t)p->NumPackStreams + 1, alloc)+ {+ UInt64 sum = 0;+ UInt32 i;+ const UInt32 numPackStreams = p->NumPackStreams;+ for (i = 0; i < numPackStreams; i++)+ {+ UInt64 packSize;+ p->PackPositions[i] = sum;+ RINOK(ReadNumber(sd, &packSize))+ sum += packSize;+ if (sum < packSize)+ return SZ_ERROR_ARCHIVE;+ }+ p->PackPositions[i] = sum;+ }++ for (;;)+ {+ UInt64 type;+ RINOK(ReadID(sd, &type))+ if (type == k7zIdEnd)+ return SZ_OK;+ if (type == k7zIdCRC)+ {+ /* CRC of packed streams is unused now */+ RINOK(SkipBitUi32s(sd, p->NumPackStreams))+ continue;+ }+ RINOK(SkipData(sd))+ }+}++/*+static SRes SzReadSwitch(CSzData *sd)+{+ Byte external;+ RINOK(SzReadByte(sd, &external));+ return (external == 0) ? SZ_OK: SZ_ERROR_UNSUPPORTED;+}+*/++#define k_NumCodersStreams_in_Folder_MAX (SZ_NUM_BONDS_IN_FOLDER_MAX + SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)++SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)+{+ UInt32 numCoders, i;+ UInt32 numInStreams = 0;+ const Byte *dataStart = sd->Data;++ f->NumCoders = 0;+ f->NumBonds = 0;+ f->NumPackStreams = 0;+ f->UnpackStream = 0;+ + RINOK(SzReadNumber32(sd, &numCoders))+ if (numCoders == 0 || numCoders > SZ_NUM_CODERS_IN_FOLDER_MAX)+ return SZ_ERROR_UNSUPPORTED;+ + for (i = 0; i < numCoders; i++)+ {+ Byte mainByte;+ CSzCoderInfo *coder = f->Coders + i;+ unsigned idSize, j;+ UInt64 id;+ + SZ_READ_BYTE(mainByte)+ if ((mainByte & 0xC0) != 0)+ return SZ_ERROR_UNSUPPORTED;+ + idSize = (unsigned)(mainByte & 0xF);+ if (idSize > sizeof(id))+ return SZ_ERROR_UNSUPPORTED;+ if (idSize > sd->Size)+ return SZ_ERROR_ARCHIVE;+ id = 0;+ for (j = 0; j < idSize; j++)+ {+ id = ((id << 8) | *sd->Data);+ sd->Data++;+ sd->Size--;+ }+ if (id > (UInt32)0xFFFFFFFF)+ return SZ_ERROR_UNSUPPORTED;+ coder->MethodID = (UInt32)id;+ + coder->NumStreams = 1;+ coder->PropsOffset = 0;+ coder->PropsSize = 0;+ + if ((mainByte & 0x10) != 0)+ {+ UInt32 numStreams;+ + RINOK(SzReadNumber32(sd, &numStreams))+ if (numStreams > k_NumCodersStreams_in_Folder_MAX)+ return SZ_ERROR_UNSUPPORTED;+ coder->NumStreams = (Byte)numStreams;++ RINOK(SzReadNumber32(sd, &numStreams))+ if (numStreams != 1)+ return SZ_ERROR_UNSUPPORTED;+ }++ numInStreams += coder->NumStreams;++ if (numInStreams > k_NumCodersStreams_in_Folder_MAX)+ return SZ_ERROR_UNSUPPORTED;++ if ((mainByte & 0x20) != 0)+ {+ UInt32 propsSize = 0;+ RINOK(SzReadNumber32(sd, &propsSize))+ if (propsSize > sd->Size)+ return SZ_ERROR_ARCHIVE;+ if (propsSize >= 0x80)+ return SZ_ERROR_UNSUPPORTED;+ coder->PropsOffset = (size_t)(sd->Data - dataStart);+ coder->PropsSize = (Byte)propsSize;+ sd->Data += (size_t)propsSize;+ sd->Size -= (size_t)propsSize;+ }+ }++ /*+ if (numInStreams == 1 && numCoders == 1)+ {+ f->NumPackStreams = 1;+ f->PackStreams[0] = 0;+ }+ else+ */+ {+ Byte streamUsed[k_NumCodersStreams_in_Folder_MAX];+ UInt32 numBonds, numPackStreams;+ + numBonds = numCoders - 1;+ if (numInStreams < numBonds)+ return SZ_ERROR_ARCHIVE;+ if (numBonds > SZ_NUM_BONDS_IN_FOLDER_MAX)+ return SZ_ERROR_UNSUPPORTED;+ f->NumBonds = numBonds;+ + numPackStreams = numInStreams - numBonds;+ if (numPackStreams > SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)+ return SZ_ERROR_UNSUPPORTED;+ f->NumPackStreams = numPackStreams;+ + for (i = 0; i < numInStreams; i++)+ streamUsed[i] = False;+ + if (numBonds != 0)+ {+ Byte coderUsed[SZ_NUM_CODERS_IN_FOLDER_MAX];++ for (i = 0; i < numCoders; i++)+ coderUsed[i] = False;+ + for (i = 0; i < numBonds; i++)+ {+ CSzBond *bp = f->Bonds + i;+ + RINOK(SzReadNumber32(sd, &bp->InIndex))+ if (bp->InIndex >= numInStreams || streamUsed[bp->InIndex])+ return SZ_ERROR_ARCHIVE;+ streamUsed[bp->InIndex] = True;+ + RINOK(SzReadNumber32(sd, &bp->OutIndex))+ if (bp->OutIndex >= numCoders || coderUsed[bp->OutIndex])+ return SZ_ERROR_ARCHIVE;+ coderUsed[bp->OutIndex] = True;+ }+ + for (i = 0; i < numCoders; i++)+ if (!coderUsed[i])+ {+ f->UnpackStream = i;+ break;+ }+ + if (i == numCoders)+ return SZ_ERROR_ARCHIVE;+ }+ + if (numPackStreams == 1)+ {+ for (i = 0; i < numInStreams; i++)+ if (!streamUsed[i])+ break;+ if (i == numInStreams)+ return SZ_ERROR_ARCHIVE;+ f->PackStreams[0] = i;+ }+ else+ for (i = 0; i < numPackStreams; i++)+ {+ UInt32 index;+ RINOK(SzReadNumber32(sd, &index))+ if (index >= numInStreams || streamUsed[index])+ return SZ_ERROR_ARCHIVE;+ streamUsed[index] = True;+ f->PackStreams[i] = index;+ }+ }++ f->NumCoders = numCoders;++ return SZ_OK;+}+++static Z7_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)+{+ CSzData sd;+ sd = *sd2;+ for (; num != 0; num--)+ {+ Byte firstByte, mask;+ unsigned i;+ SZ_READ_BYTE_2(firstByte)+ if ((firstByte & 0x80) == 0)+ continue;+ if ((firstByte & 0x40) == 0)+ {+ if (sd.Size == 0)+ return SZ_ERROR_ARCHIVE;+ sd.Size--;+ sd.Data++;+ continue;+ }+ mask = 0x20;+ for (i = 2; i < 8 && (firstByte & mask) != 0; i++)+ mask >>= 1;+ if (i > sd.Size)+ return SZ_ERROR_ARCHIVE;+ SKIP_DATA2(sd, i)+ }+ *sd2 = sd;+ return SZ_OK;+}+++#define k_Scan_NumCoders_MAX 64+#define k_Scan_NumCodersStreams_in_Folder_MAX 64+++static SRes ReadUnpackInfo(CSzAr *p,+ CSzData *sd2,+ UInt32 numFoldersMax,+ const CBuf *tempBufs, UInt32 numTempBufs,+ ISzAllocPtr alloc)+{+ CSzData sd;+ + UInt32 fo, numFolders, numCodersOutStreams, packStreamIndex;+ const Byte *startBufPtr;+ Byte external;+ + RINOK(WaitId(sd2, k7zIdFolder))+ + RINOK(SzReadNumber32(sd2, &numFolders))+ if (numFolders > numFoldersMax)+ return SZ_ERROR_UNSUPPORTED;+ p->NumFolders = numFolders;++ SZ_READ_BYTE_SD(sd2, external)+ if (external == 0)+ sd = *sd2;+ else+ {+ UInt32 index;+ RINOK(SzReadNumber32(sd2, &index))+ if (index >= numTempBufs)+ return SZ_ERROR_ARCHIVE;+ sd.Data = tempBufs[index].data;+ sd.Size = tempBufs[index].size;+ }+ + MY_ALLOC(size_t, p->FoCodersOffsets, (size_t)numFolders + 1, alloc)+ MY_ALLOC(UInt32, p->FoStartPackStreamIndex, (size_t)numFolders + 1, alloc)+ MY_ALLOC(UInt32, p->FoToCoderUnpackSizes, (size_t)numFolders + 1, alloc)+ MY_ALLOC_ZE(Byte, p->FoToMainUnpackSizeIndex, (size_t)numFolders, alloc)+ + startBufPtr = sd.Data;+ + packStreamIndex = 0;+ numCodersOutStreams = 0;++ for (fo = 0; fo < numFolders; fo++)+ {+ UInt32 numCoders, ci, numInStreams = 0;+ + p->FoCodersOffsets[fo] = (size_t)(sd.Data - startBufPtr);+ + RINOK(SzReadNumber32(&sd, &numCoders))+ if (numCoders == 0 || numCoders > k_Scan_NumCoders_MAX)+ return SZ_ERROR_UNSUPPORTED;+ + for (ci = 0; ci < numCoders; ci++)+ {+ Byte mainByte;+ unsigned idSize;+ UInt32 coderInStreams;+ + SZ_READ_BYTE_2(mainByte)+ if ((mainByte & 0xC0) != 0)+ return SZ_ERROR_UNSUPPORTED;+ idSize = (mainByte & 0xF);+ if (idSize > 8)+ return SZ_ERROR_UNSUPPORTED;+ if (idSize > sd.Size)+ return SZ_ERROR_ARCHIVE;+ SKIP_DATA2(sd, idSize)+ + coderInStreams = 1;+ + if ((mainByte & 0x10) != 0)+ {+ UInt32 coderOutStreams;+ RINOK(SzReadNumber32(&sd, &coderInStreams))+ RINOK(SzReadNumber32(&sd, &coderOutStreams))+ if (coderInStreams > k_Scan_NumCodersStreams_in_Folder_MAX || coderOutStreams != 1)+ return SZ_ERROR_UNSUPPORTED;+ }+ + numInStreams += coderInStreams;++ if ((mainByte & 0x20) != 0)+ {+ UInt32 propsSize;+ RINOK(SzReadNumber32(&sd, &propsSize))+ if (propsSize > sd.Size)+ return SZ_ERROR_ARCHIVE;+ SKIP_DATA2(sd, propsSize)+ }+ }+ + {+ UInt32 indexOfMainStream = 0;+ UInt32 numPackStreams = 1;+ + if (numCoders != 1 || numInStreams != 1)+ {+ Byte streamUsed[k_Scan_NumCodersStreams_in_Folder_MAX];+ Byte coderUsed[k_Scan_NumCoders_MAX];+ + UInt32 i;+ const UInt32 numBonds = numCoders - 1;+ if (numInStreams < numBonds)+ return SZ_ERROR_ARCHIVE;+ + if (numInStreams > k_Scan_NumCodersStreams_in_Folder_MAX)+ return SZ_ERROR_UNSUPPORTED;+ + for (i = 0; i < numInStreams; i++)+ streamUsed[i] = False;+ for (i = 0; i < numCoders; i++)+ coderUsed[i] = False;+ + for (i = 0; i < numBonds; i++)+ {+ UInt32 index;+ + RINOK(SzReadNumber32(&sd, &index))+ if (index >= numInStreams || streamUsed[index])+ return SZ_ERROR_ARCHIVE;+ streamUsed[index] = True;+ + RINOK(SzReadNumber32(&sd, &index))+ if (index >= numCoders || coderUsed[index])+ return SZ_ERROR_ARCHIVE;+ coderUsed[index] = True;+ }+ + numPackStreams = numInStreams - numBonds;+ + if (numPackStreams != 1)+ for (i = 0; i < numPackStreams; i++)+ {+ UInt32 index;+ RINOK(SzReadNumber32(&sd, &index))+ if (index >= numInStreams || streamUsed[index])+ return SZ_ERROR_ARCHIVE;+ streamUsed[index] = True;+ }+ + for (i = 0; i < numCoders; i++)+ if (!coderUsed[i])+ {+ indexOfMainStream = i;+ break;+ }+ + if (i == numCoders)+ return SZ_ERROR_ARCHIVE;+ }+ + p->FoStartPackStreamIndex[fo] = packStreamIndex;+ p->FoToCoderUnpackSizes[fo] = numCodersOutStreams;+ p->FoToMainUnpackSizeIndex[fo] = (Byte)indexOfMainStream;+ numCodersOutStreams += numCoders;+ if (numCodersOutStreams < numCoders)+ return SZ_ERROR_UNSUPPORTED;+ if (numPackStreams > p->NumPackStreams - packStreamIndex)+ return SZ_ERROR_ARCHIVE;+ packStreamIndex += numPackStreams;+ }+ }++ p->FoToCoderUnpackSizes[fo] = numCodersOutStreams;+ + {+ const size_t dataSize = (size_t)(sd.Data - startBufPtr);+ p->FoStartPackStreamIndex[fo] = packStreamIndex;+ p->FoCodersOffsets[fo] = dataSize;+ MY_ALLOC_ZE_AND_CPY(p->CodersData, dataSize, startBufPtr, alloc)+ }+ + if (external != 0)+ {+ if (sd.Size != 0)+ return SZ_ERROR_ARCHIVE;+ sd = *sd2;+ }+ + RINOK(WaitId(&sd, k7zIdCodersUnpackSize))+ + MY_ALLOC_ZE(UInt64, p->CoderUnpackSizes, (size_t)numCodersOutStreams, alloc)+ {+ UInt32 i;+ for (i = 0; i < numCodersOutStreams; i++)+ {+ RINOK(ReadNumber(&sd, p->CoderUnpackSizes + i))+ }+ }++ for (;;)+ {+ UInt64 type;+ RINOK(ReadID(&sd, &type))+ if (type == k7zIdEnd)+ {+ *sd2 = sd;+ return SZ_OK;+ }+ if (type == k7zIdCRC)+ {+ RINOK(ReadBitUi32s(&sd, numFolders, &p->FolderCRCs, alloc))+ continue;+ }+ RINOK(SkipData(&sd))+ }+}+++UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex)+{+ return p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex] + p->FoToMainUnpackSizeIndex[folderIndex]];+}+++typedef struct+{+ UInt32 NumTotalSubStreams;+ UInt32 NumSubDigests;+ CSzData sdNumSubStreams;+ CSzData sdSizes;+ CSzData sdCRCs;+} CSubStreamInfo;+++static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)+{+ UInt64 type = 0;+ UInt32 numSubDigests = 0;+ const UInt32 numFolders = p->NumFolders;+ UInt32 numUnpackStreams = numFolders;+ UInt32 numUnpackSizesInData = 0;++ for (;;)+ {+ RINOK(ReadID(sd, &type))+ if (type == k7zIdNumUnpackStream)+ {+ UInt32 i;+ ssi->sdNumSubStreams.Data = sd->Data;+ numUnpackStreams = 0;+ numSubDigests = 0;+ for (i = 0; i < numFolders; i++)+ {+ UInt32 numStreams;+ RINOK(SzReadNumber32(sd, &numStreams))+ if (numUnpackStreams > numUnpackStreams + numStreams)+ return SZ_ERROR_UNSUPPORTED;+ numUnpackStreams += numStreams;+ if (numStreams != 0)+ numUnpackSizesInData += (numStreams - 1);+ if (numStreams != 1 || !SzBitWithVals_Check(&p->FolderCRCs, i))+ numSubDigests += numStreams;+ }+ ssi->sdNumSubStreams.Size = (size_t)(sd->Data - ssi->sdNumSubStreams.Data);+ continue;+ }+ if (type == k7zIdCRC || type == k7zIdSize || type == k7zIdEnd)+ break;+ RINOK(SkipData(sd))+ }++ if (!ssi->sdNumSubStreams.Data)+ {+ numSubDigests = numFolders;+ if (p->FolderCRCs.Defs)+ numSubDigests = numFolders - CountDefinedBits(p->FolderCRCs.Defs, numFolders);+ }+ + ssi->NumTotalSubStreams = numUnpackStreams;+ ssi->NumSubDigests = numSubDigests;++ if (type == k7zIdSize)+ {+ ssi->sdSizes.Data = sd->Data;+ RINOK(SkipNumbers(sd, numUnpackSizesInData))+ ssi->sdSizes.Size = (size_t)(sd->Data - ssi->sdSizes.Data);+ RINOK(ReadID(sd, &type))+ }++ for (;;)+ {+ if (type == k7zIdEnd)+ return SZ_OK;+ if (type == k7zIdCRC)+ {+ ssi->sdCRCs.Data = sd->Data;+ RINOK(SkipBitUi32s(sd, numSubDigests))+ ssi->sdCRCs.Size = (size_t)(sd->Data - ssi->sdCRCs.Data);+ }+ else+ {+ RINOK(SkipData(sd))+ }+ RINOK(ReadID(sd, &type))+ }+}++static SRes SzReadStreamsInfo(CSzAr *p,+ CSzData *sd,+ UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs,+ UInt64 *dataOffset,+ CSubStreamInfo *ssi,+ ISzAllocPtr alloc)+{+ UInt64 type;++ SzData_CLEAR(&ssi->sdSizes)+ SzData_CLEAR(&ssi->sdCRCs)+ SzData_CLEAR(&ssi->sdNumSubStreams)++ *dataOffset = 0;+ RINOK(ReadID(sd, &type))+ if (type == k7zIdPackInfo)+ {+ RINOK(ReadNumber(sd, dataOffset))+ if (*dataOffset > p->RangeLimit)+ return SZ_ERROR_ARCHIVE;+ RINOK(ReadPackInfo(p, sd, alloc))+ if (p->PackPositions[p->NumPackStreams] > p->RangeLimit - *dataOffset)+ return SZ_ERROR_ARCHIVE;+ RINOK(ReadID(sd, &type))+ }+ if (type == k7zIdUnpackInfo)+ {+ RINOK(ReadUnpackInfo(p, sd, numFoldersMax, tempBufs, numTempBufs, alloc))+ RINOK(ReadID(sd, &type))+ }+ if (type == k7zIdSubStreamsInfo)+ {+ RINOK(ReadSubStreamsInfo(p, sd, ssi))+ RINOK(ReadID(sd, &type))+ }+ else+ {+ ssi->NumTotalSubStreams = p->NumFolders;+ // ssi->NumSubDigests = 0;+ }++ return (type == k7zIdEnd ? SZ_OK : SZ_ERROR_UNSUPPORTED);+}++static SRes SzReadAndDecodePackedStreams(+ ILookInStreamPtr inStream,+ CSzData *sd,+ CBuf *tempBufs,+ UInt32 numFoldersMax,+ UInt64 baseOffset,+ CSzAr *p,+ ISzAllocPtr allocTemp)+{+ UInt64 dataStartPos;+ UInt32 fo;+ CSubStreamInfo ssi;++ RINOK(SzReadStreamsInfo(p, sd, numFoldersMax, NULL, 0, &dataStartPos, &ssi, allocTemp))+ + dataStartPos += baseOffset;+ if (p->NumFolders == 0)+ return SZ_ERROR_ARCHIVE;+ + for (fo = 0; fo < p->NumFolders; fo++)+ Buf_Init(tempBufs + fo);+ + for (fo = 0; fo < p->NumFolders; fo++)+ {+ CBuf *tempBuf = tempBufs + fo;+ const UInt64 unpackSize = SzAr_GetFolderUnpackSize(p, fo);+ if ((size_t)unpackSize != unpackSize)+ return SZ_ERROR_MEM;+ if (!Buf_Create(tempBuf, (size_t)unpackSize, allocTemp))+ return SZ_ERROR_MEM;+ }+ + for (fo = 0; fo < p->NumFolders; fo++)+ {+ const CBuf *tempBuf = tempBufs + fo;+ RINOK(LookInStream_SeekTo(inStream, dataStartPos))+ RINOK(SzAr_DecodeFolder(p, fo, inStream, dataStartPos, tempBuf->data, tempBuf->size, allocTemp))+ }+ + return SZ_OK;+}++static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size_t *offsets)+{+ size_t pos = 0;+ *offsets++ = 0;+ if (numFiles == 0)+ return (size == 0) ? SZ_OK : SZ_ERROR_ARCHIVE;+ if (size < 2)+ return SZ_ERROR_ARCHIVE;+ if (data[size - 2] != 0 || data[size - 1] != 0)+ return SZ_ERROR_ARCHIVE;+ do+ {+ const Byte *p;+ if (pos == size)+ return SZ_ERROR_ARCHIVE;+ for (p = data + pos;+ #ifdef _WIN32+ *(const UInt16 *)(const void *)p != 0+ #else+ p[0] != 0 || p[1] != 0+ #endif+ ; p += 2);+ pos = (size_t)(p - data) + 2;+ *offsets++ = (pos >> 1);+ }+ while (--numFiles);+ return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;+}++static Z7_NO_INLINE SRes ReadTime(CSzBitUi64s *p, UInt32 num,+ CSzData *sd2,+ const CBuf *tempBufs, UInt32 numTempBufs,+ ISzAllocPtr alloc)+{+ CSzData sd;+ UInt32 i;+ CNtfsFileTime *vals;+ Byte *defs;+ Byte external;+ + RINOK(ReadBitVector(sd2, num, &p->Defs, alloc))+ + SZ_READ_BYTE_SD(sd2, external)+ if (external == 0)+ sd = *sd2;+ else+ {+ UInt32 index;+ RINOK(SzReadNumber32(sd2, &index))+ if (index >= numTempBufs)+ return SZ_ERROR_ARCHIVE;+ sd.Data = tempBufs[index].data;+ sd.Size = tempBufs[index].size;+ }+ + MY_ALLOC_ZE(CNtfsFileTime, p->Vals, num, alloc)+ vals = p->Vals;+ defs = p->Defs;+ for (i = 0; i < num; i++)+ if (SzBitArray_Check(defs, i))+ {+ if (sd.Size < 8)+ return SZ_ERROR_ARCHIVE;+ vals[i].Low = GetUi32(sd.Data);+ vals[i].High = GetUi32(sd.Data + 4);+ SKIP_DATA2(sd, 8)+ }+ else+ vals[i].High = vals[i].Low = 0;+ + if (external == 0)+ *sd2 = sd;+ + return SZ_OK;+}+++#define NUM_ADDITIONAL_STREAMS_MAX 8+++static SRes SzReadHeader2(+ CSzArEx *p, /* allocMain */+ CSzData *sd,+ ILookInStreamPtr inStream,+ CBuf *tempBufs, UInt32 *numTempBufs,+ ISzAllocPtr allocMain,+ ISzAllocPtr allocTemp+ )+{+ CSubStreamInfo ssi;++{+ UInt64 type;+ + SzData_CLEAR(&ssi.sdSizes)+ SzData_CLEAR(&ssi.sdCRCs)+ SzData_CLEAR(&ssi.sdNumSubStreams)++ ssi.NumSubDigests = 0;+ ssi.NumTotalSubStreams = 0;++ RINOK(ReadID(sd, &type))++ if (type == k7zIdArchiveProperties)+ {+ for (;;)+ {+ UInt64 type2;+ RINOK(ReadID(sd, &type2))+ if (type2 == k7zIdEnd)+ break;+ RINOK(SkipData(sd))+ }+ RINOK(ReadID(sd, &type))+ }++ if (type == k7zIdAdditionalStreamsInfo)+ {+ CSzAr tempAr;+ SRes res;+ + SzAr_Init(&tempAr);+ tempAr.RangeLimit = p->db.RangeLimit;++ res = SzReadAndDecodePackedStreams(inStream, sd, tempBufs, NUM_ADDITIONAL_STREAMS_MAX,+ p->startPosAfterHeader, &tempAr, allocTemp);+ *numTempBufs = tempAr.NumFolders;+ SzAr_Free(&tempAr, allocTemp);+ + if (res != SZ_OK)+ return res;+ RINOK(ReadID(sd, &type))+ }++ if (type == k7zIdMainStreamsInfo)+ {+ RINOK(SzReadStreamsInfo(&p->db, sd, (UInt32)1 << 30, tempBufs, *numTempBufs,+ &p->dataPos, &ssi, allocMain))+ p->dataPos += p->startPosAfterHeader;+ RINOK(ReadID(sd, &type))+ }++ if (type == k7zIdEnd)+ {+ return SZ_OK;+ }++ if (type != k7zIdFilesInfo)+ return SZ_ERROR_ARCHIVE;+}++{+ UInt32 numFiles = 0;+ UInt32 numEmptyStreams = 0;+ const Byte *emptyStreams = NULL;+ const Byte *emptyFiles = NULL;+ + RINOK(SzReadNumber32(sd, &numFiles))+ p->NumFiles = numFiles;++ for (;;)+ {+ UInt64 type;+ UInt64 size;+ RINOK(ReadID(sd, &type))+ if (type == k7zIdEnd)+ break;+ RINOK(ReadNumber(sd, &size))+ if (size > sd->Size)+ return SZ_ERROR_ARCHIVE;+ + if (type >= ((UInt32)1 << 8))+ {+ SKIP_DATA(sd, size)+ }+ else switch ((unsigned)type)+ {+ case k7zIdName:+ {+ size_t namesSize;+ const Byte *namesData;+ Byte external;++ SZ_READ_BYTE(external)+ if (external == 0)+ {+ namesSize = (size_t)size - 1;+ namesData = sd->Data;+ }+ else+ {+ UInt32 index;+ RINOK(SzReadNumber32(sd, &index))+ if (index >= *numTempBufs)+ return SZ_ERROR_ARCHIVE;+ namesData = (tempBufs)[index].data;+ namesSize = (tempBufs)[index].size;+ }++ if ((namesSize & 1) != 0)+ return SZ_ERROR_ARCHIVE;+ MY_ALLOC(size_t, p->FileNameOffsets, numFiles + 1, allocMain)+ MY_ALLOC_ZE_AND_CPY(p->FileNames, namesSize, namesData, allocMain)+ RINOK(SzReadFileNames(p->FileNames, namesSize, numFiles, p->FileNameOffsets))+ if (external == 0)+ {+ SKIP_DATA(sd, namesSize)+ }+ break;+ }+ case k7zIdEmptyStream:+ {+ RINOK(RememberBitVector(sd, numFiles, &emptyStreams))+ numEmptyStreams = CountDefinedBits(emptyStreams, numFiles);+ emptyFiles = NULL;+ break;+ }+ case k7zIdEmptyFile:+ {+ RINOK(RememberBitVector(sd, numEmptyStreams, &emptyFiles))+ break;+ }+ case k7zIdWinAttrib:+ {+ Byte external;+ CSzData sdSwitch;+ CSzData *sdPtr;+ SzBitUi32s_Free(&p->Attribs, allocMain);+ RINOK(ReadBitVector(sd, numFiles, &p->Attribs.Defs, allocMain))++ SZ_READ_BYTE(external)+ if (external == 0)+ sdPtr = sd;+ else+ {+ UInt32 index;+ RINOK(SzReadNumber32(sd, &index))+ if (index >= *numTempBufs)+ return SZ_ERROR_ARCHIVE;+ sdSwitch.Data = (tempBufs)[index].data;+ sdSwitch.Size = (tempBufs)[index].size;+ sdPtr = &sdSwitch;+ }+ RINOK(ReadUi32s(sdPtr, numFiles, &p->Attribs, allocMain))+ break;+ }+ /*+ case k7zParent:+ {+ SzBitUi32s_Free(&p->Parents, allocMain);+ RINOK(ReadBitVector(sd, numFiles, &p->Parents.Defs, allocMain));+ RINOK(SzReadSwitch(sd));+ RINOK(ReadUi32s(sd, numFiles, &p->Parents, allocMain));+ break;+ }+ */+ case k7zIdMTime: RINOK(ReadTime(&p->MTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)) break;+ case k7zIdCTime: RINOK(ReadTime(&p->CTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)) break;+ default:+ {+ SKIP_DATA(sd, size)+ }+ }+ }++ if (numFiles - numEmptyStreams != ssi.NumTotalSubStreams)+ return SZ_ERROR_ARCHIVE;++ for (;;)+ {+ UInt64 type;+ RINOK(ReadID(sd, &type))+ if (type == k7zIdEnd)+ break;+ RINOK(SkipData(sd))+ }++ {+ UInt32 i;+ UInt32 emptyFileIndex = 0;+ UInt32 folderIndex = 0;+ UInt32 remSubStreams = 0;+ UInt32 numSubStreams = 0;+ UInt64 unpackPos = 0;+ const Byte *digestsDefs = NULL;+ const Byte *digestsVals = NULL;+ UInt32 digestIndex = 0;+ Byte isDirMask = 0;+ Byte crcMask = 0;+ Byte mask = 0x80;+ + MY_ALLOC(UInt32, p->FolderToFile, p->db.NumFolders + 1, allocMain)+ MY_ALLOC_ZE(UInt32, p->FileToFolder, p->NumFiles, allocMain)+ MY_ALLOC(UInt64, p->UnpackPositions, p->NumFiles + 1, allocMain)+ MY_ALLOC_ZE(Byte, p->IsDirs, (p->NumFiles + 7) >> 3, allocMain)++ RINOK(SzBitUi32s_Alloc(&p->CRCs, p->NumFiles, allocMain))++ if (ssi.sdCRCs.Size != 0)+ {+ Byte allDigestsDefined = 0;+ SZ_READ_BYTE_SD_NOCHECK(&ssi.sdCRCs, allDigestsDefined)+ if (allDigestsDefined)+ digestsVals = ssi.sdCRCs.Data;+ else+ {+ const size_t numBytes = (ssi.NumSubDigests + 7) >> 3;+ digestsDefs = ssi.sdCRCs.Data;+ digestsVals = digestsDefs + numBytes;+ }+ }++ for (i = 0; i < numFiles; i++, mask >>= 1)+ {+ if (mask == 0)+ {+ const UInt32 byteIndex = (i - 1) >> 3;+ p->IsDirs[byteIndex] = isDirMask;+ p->CRCs.Defs[byteIndex] = crcMask;+ isDirMask = 0;+ crcMask = 0;+ mask = 0x80;+ }++ p->UnpackPositions[i] = unpackPos;+ p->CRCs.Vals[i] = 0;+ + if (emptyStreams && SzBitArray_Check(emptyStreams, i))+ {+ if (emptyFiles)+ {+ if (!SzBitArray_Check(emptyFiles, emptyFileIndex))+ isDirMask |= mask;+ emptyFileIndex++;+ }+ else+ isDirMask |= mask;+ if (remSubStreams == 0)+ {+ p->FileToFolder[i] = (UInt32)-1;+ continue;+ }+ }+ + if (remSubStreams == 0)+ {+ for (;;)+ {+ if (folderIndex >= p->db.NumFolders)+ return SZ_ERROR_ARCHIVE;+ p->FolderToFile[folderIndex] = i;+ numSubStreams = 1;+ if (ssi.sdNumSubStreams.Data)+ {+ RINOK(SzReadNumber32(&ssi.sdNumSubStreams, &numSubStreams))+ }+ remSubStreams = numSubStreams;+ if (numSubStreams != 0)+ break;+ {+ const UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);+ unpackPos += folderUnpackSize;+ if (unpackPos < folderUnpackSize)+ return SZ_ERROR_ARCHIVE;+ }+ folderIndex++;+ }+ }+ + p->FileToFolder[i] = folderIndex;+ + if (emptyStreams && SzBitArray_Check(emptyStreams, i))+ continue;+ + if (--remSubStreams == 0)+ {+ const UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);+ const UInt64 startFolderUnpackPos = p->UnpackPositions[p->FolderToFile[folderIndex]];+ if (folderUnpackSize < unpackPos - startFolderUnpackPos)+ return SZ_ERROR_ARCHIVE;+ unpackPos = startFolderUnpackPos + folderUnpackSize;+ if (unpackPos < folderUnpackSize)+ return SZ_ERROR_ARCHIVE;++ if (numSubStreams == 1 && SzBitWithVals_Check(&p->db.FolderCRCs, folderIndex))+ {+ p->CRCs.Vals[i] = p->db.FolderCRCs.Vals[folderIndex];+ crcMask |= mask;+ }+ folderIndex++;+ }+ else+ {+ UInt64 v;+ RINOK(ReadNumber(&ssi.sdSizes, &v))+ unpackPos += v;+ if (unpackPos < v)+ return SZ_ERROR_ARCHIVE;+ }+ if ((crcMask & mask) == 0 && digestsVals)+ {+ if (!digestsDefs || SzBitArray_Check(digestsDefs, digestIndex))+ {+ p->CRCs.Vals[i] = GetUi32(digestsVals);+ digestsVals += 4;+ crcMask |= mask;+ }+ digestIndex++;+ }+ }++ if (mask != 0x80)+ {+ const UInt32 byteIndex = (i - 1) >> 3;+ p->IsDirs[byteIndex] = isDirMask;+ p->CRCs.Defs[byteIndex] = crcMask;+ }+ + p->UnpackPositions[i] = unpackPos;++ if (remSubStreams != 0)+ return SZ_ERROR_ARCHIVE;++ for (;;)+ {+ p->FolderToFile[folderIndex] = i;+ if (folderIndex >= p->db.NumFolders)+ break;+ if (!ssi.sdNumSubStreams.Data)+ return SZ_ERROR_ARCHIVE;+ RINOK(SzReadNumber32(&ssi.sdNumSubStreams, &numSubStreams))+ if (numSubStreams != 0)+ return SZ_ERROR_ARCHIVE;+ /*+ {+ UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);+ unpackPos += folderUnpackSize;+ if (unpackPos < folderUnpackSize)+ return SZ_ERROR_ARCHIVE;+ }+ */+ folderIndex++;+ }++ if (ssi.sdNumSubStreams.Data && ssi.sdNumSubStreams.Size != 0)+ return SZ_ERROR_ARCHIVE;+ }+}+ return SZ_OK;+}+++static SRes SzReadHeader(+ CSzArEx *p,+ CSzData *sd,+ ILookInStreamPtr inStream,+ ISzAllocPtr allocMain,+ ISzAllocPtr allocTemp)+{+ UInt32 i;+ UInt32 numTempBufs = 0;+ SRes res;+ CBuf tempBufs[NUM_ADDITIONAL_STREAMS_MAX];++ for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++)+ Buf_Init(tempBufs + i);+ + res = SzReadHeader2(p, sd, inStream,+ tempBufs, &numTempBufs,+ allocMain, allocTemp);+ + for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++)+ Buf_Free(tempBufs + i, allocTemp);++ RINOK(res)++ if (sd->Size != 0)+ return SZ_ERROR_FAIL;++ return res;+}++static SRes SzArEx_Open2(+ CSzArEx *p,+ ILookInStreamPtr inStream,+ ISzAllocPtr allocMain,+ ISzAllocPtr allocTemp)+{+ Byte header[k7zStartHeaderSize];+ Int64 startArcPos;+ UInt64 nextHeaderOffset, nextHeaderSize;+ size_t nextHeaderSizeT;+ UInt32 nextHeaderCRC;+ CBuf buf;+ SRes res;++ startArcPos = 0;+ RINOK(ILookInStream_Seek(inStream, &startArcPos, SZ_SEEK_CUR))++ RINOK(LookInStream_Read2(inStream, header, k7zStartHeaderSize, SZ_ERROR_NO_ARCHIVE))++ if (!TestSignatureCandidate(header))+ return SZ_ERROR_NO_ARCHIVE;+ if (header[6] != k7zMajorVersion)+ return SZ_ERROR_UNSUPPORTED;++ nextHeaderOffset = GetUi64(header + 12);+ nextHeaderSize = GetUi64(header + 20);+ nextHeaderCRC = GetUi32(header + 28);++ p->startPosAfterHeader = (UInt64)startArcPos + k7zStartHeaderSize;+ + if (CrcCalc(header + 12, 20) != GetUi32(header + 8))+ return SZ_ERROR_CRC;++ p->db.RangeLimit = nextHeaderOffset;++ nextHeaderSizeT = (size_t)nextHeaderSize;+ if (nextHeaderSizeT != nextHeaderSize)+ return SZ_ERROR_MEM;+ if (nextHeaderSizeT == 0)+ return SZ_OK;+ if (nextHeaderOffset > nextHeaderOffset + nextHeaderSize ||+ nextHeaderOffset > nextHeaderOffset + nextHeaderSize + k7zStartHeaderSize)+ return SZ_ERROR_NO_ARCHIVE;++ {+ Int64 pos = 0;+ RINOK(ILookInStream_Seek(inStream, &pos, SZ_SEEK_END))+ if ((UInt64)pos < (UInt64)startArcPos + nextHeaderOffset ||+ (UInt64)pos < (UInt64)startArcPos + k7zStartHeaderSize + nextHeaderOffset ||+ (UInt64)pos < (UInt64)startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)+ return SZ_ERROR_INPUT_EOF;+ }++ RINOK(LookInStream_SeekTo(inStream, (UInt64)startArcPos + k7zStartHeaderSize + nextHeaderOffset))++ if (!Buf_Create(&buf, nextHeaderSizeT, allocTemp))+ return SZ_ERROR_MEM;++ res = LookInStream_Read(inStream, buf.data, nextHeaderSizeT);+ + if (res == SZ_OK)+ {+ res = SZ_ERROR_ARCHIVE;+ if (CrcCalc(buf.data, nextHeaderSizeT) == nextHeaderCRC)+ {+ CSzData sd;+ UInt64 type;+ sd.Data = buf.data;+ sd.Size = buf.size;+ + res = ReadID(&sd, &type);+ + if (res == SZ_OK && type == k7zIdEncodedHeader)+ {+ CSzAr tempAr;+ CBuf tempBuf;+ Buf_Init(&tempBuf);+ + SzAr_Init(&tempAr);+ tempAr.RangeLimit = p->db.RangeLimit;++ res = SzReadAndDecodePackedStreams(inStream, &sd, &tempBuf, 1, p->startPosAfterHeader, &tempAr, allocTemp);+ SzAr_Free(&tempAr, allocTemp);+ + if (res != SZ_OK)+ {+ Buf_Free(&tempBuf, allocTemp);+ }+ else+ {+ Buf_Free(&buf, allocTemp);+ buf.data = tempBuf.data;+ buf.size = tempBuf.size;+ sd.Data = buf.data;+ sd.Size = buf.size;+ res = ReadID(&sd, &type);+ }+ }+ + if (res == SZ_OK)+ {+ if (type == k7zIdHeader)+ {+ /*+ CSzData sd2;+ unsigned ttt;+ for (ttt = 0; ttt < 40000; ttt++)+ {+ SzArEx_Free(p, allocMain);+ sd2 = sd;+ res = SzReadHeader(p, &sd2, inStream, allocMain, allocTemp);+ if (res != SZ_OK)+ break;+ }+ */+ res = SzReadHeader(p, &sd, inStream, allocMain, allocTemp);+ }+ else+ res = SZ_ERROR_UNSUPPORTED;+ }+ }+ }+ + Buf_Free(&buf, allocTemp);+ return res;+}+++SRes SzArEx_Open(CSzArEx *p, ILookInStreamPtr inStream,+ ISzAllocPtr allocMain, ISzAllocPtr allocTemp)+{+ const SRes res = SzArEx_Open2(p, inStream, allocMain, allocTemp);+ if (res != SZ_OK)+ SzArEx_Free(p, allocMain);+ return res;+}+++SRes SzArEx_Extract(+ const CSzArEx *p,+ ILookInStreamPtr inStream,+ UInt32 fileIndex,+ UInt32 *blockIndex,+ Byte **tempBuf,+ size_t *outBufferSize,+ size_t *offset,+ size_t *outSizeProcessed,+ ISzAllocPtr allocMain,+ ISzAllocPtr allocTemp)+{+ const UInt32 folderIndex = p->FileToFolder[fileIndex];+ SRes res = SZ_OK;+ + *offset = 0;+ *outSizeProcessed = 0;+ + if (folderIndex == (UInt32)-1)+ {+ ISzAlloc_Free(allocMain, *tempBuf);+ *blockIndex = folderIndex;+ *tempBuf = NULL;+ *outBufferSize = 0;+ return SZ_OK;+ }++ if (*tempBuf == NULL || *blockIndex != folderIndex)+ {+ const UInt64 unpackSizeSpec = SzAr_GetFolderUnpackSize(&p->db, folderIndex);+ /*+ UInt64 unpackSizeSpec =+ p->UnpackPositions[p->FolderToFile[(size_t)folderIndex + 1]] -+ p->UnpackPositions[p->FolderToFile[folderIndex]];+ */+ const size_t unpackSize = (size_t)unpackSizeSpec;++ if (unpackSize != unpackSizeSpec)+ return SZ_ERROR_MEM;+ *blockIndex = folderIndex;+ ISzAlloc_Free(allocMain, *tempBuf);+ *tempBuf = NULL;+ + if (res == SZ_OK)+ {+ *outBufferSize = unpackSize;+ if (unpackSize != 0)+ {+ *tempBuf = (Byte *)ISzAlloc_Alloc(allocMain, unpackSize);+ if (*tempBuf == NULL)+ res = SZ_ERROR_MEM;+ }+ + if (res == SZ_OK)+ {+ res = SzAr_DecodeFolder(&p->db, folderIndex,+ inStream, p->dataPos, *tempBuf, unpackSize, allocTemp);+ }+ }+ }++ if (res == SZ_OK)+ {+ const UInt64 unpackPos = p->UnpackPositions[fileIndex];+ *offset = (size_t)(unpackPos - p->UnpackPositions[p->FolderToFile[folderIndex]]);+ *outSizeProcessed = (size_t)(p->UnpackPositions[(size_t)fileIndex + 1] - unpackPos);+ if (*offset + *outSizeProcessed > *outBufferSize)+ return SZ_ERROR_FAIL;+ if (SzBitWithVals_Check(&p->CRCs, fileIndex))+ if (CrcCalc(*tempBuf + *offset, *outSizeProcessed) != p->CRCs.Vals[fileIndex])+ res = SZ_ERROR_CRC;+ }++ return res;+}+++size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest)+{+ const size_t offs = p->FileNameOffsets[fileIndex];+ const size_t len = p->FileNameOffsets[fileIndex + 1] - offs;+ if (dest != 0)+ {+ size_t i;+ const Byte *src = p->FileNames + offs * 2;+ for (i = 0; i < len; i++)+ dest[i] = GetUi16(src + i * 2);+ }+ return len;+}++/*+size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex)+{+ size_t len;+ if (!p->FileNameOffsets)+ return 1;+ len = 0;+ for (;;)+ {+ UInt32 parent = (UInt32)(Int32)-1;+ len += p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];+ if SzBitWithVals_Check(&p->Parents, fileIndex)+ parent = p->Parents.Vals[fileIndex];+ if (parent == (UInt32)(Int32)-1)+ return len;+ fileIndex = parent;+ }+}++UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest)+{+ BoolInt needSlash;+ if (!p->FileNameOffsets)+ {+ *(--dest) = 0;+ return dest;+ }+ needSlash = False;+ for (;;)+ {+ UInt32 parent = (UInt32)(Int32)-1;+ size_t curLen = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];+ SzArEx_GetFileNameUtf16(p, fileIndex, dest - curLen);+ if (needSlash)+ *(dest - 1) = '/';+ needSlash = True;+ dest -= curLen;++ if SzBitWithVals_Check(&p->Parents, fileIndex)+ parent = p->Parents.Vals[fileIndex];+ if (parent == (UInt32)(Int32)-1)+ return dest;+ fileIndex = parent;+ }+}+*/
@@ -0,0 +1,36 @@+/* 7zBuf.c -- Byte Buffer+2017-04-03 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include "7zBuf.h"++void Buf_Init(CBuf *p)+{+ p->data = 0;+ p->size = 0;+}++int Buf_Create(CBuf *p, size_t size, ISzAllocPtr alloc)+{+ p->size = 0;+ if (size == 0)+ {+ p->data = 0;+ return 1;+ }+ p->data = (Byte *)ISzAlloc_Alloc(alloc, size);+ if (p->data)+ {+ p->size = size;+ return 1;+ }+ return 0;+}++void Buf_Free(CBuf *p, ISzAllocPtr alloc)+{+ ISzAlloc_Free(alloc, p->data);+ p->data = 0;+ p->size = 0;+}
@@ -0,0 +1,35 @@+/* 7zBuf.h -- Byte Buffer+2023-03-04 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_7Z_BUF_H+#define ZIP7_INC_7Z_BUF_H++#include "7zTypes.h"++EXTERN_C_BEGIN++typedef struct+{+ Byte *data;+ size_t size;+} CBuf;++void Buf_Init(CBuf *p);+int Buf_Create(CBuf *p, size_t size, ISzAllocPtr alloc);+void Buf_Free(CBuf *p, ISzAllocPtr alloc);++typedef struct+{+ Byte *data;+ size_t size;+ size_t pos;+} CDynBuf;++void DynBuf_Construct(CDynBuf *p);+void DynBuf_SeekToBeg(CDynBuf *p);+int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAllocPtr alloc);+void DynBuf_Free(CDynBuf *p, ISzAllocPtr alloc);++EXTERN_C_END++#endif
@@ -0,0 +1,52 @@+/* 7zBuf2.c -- Byte Buffer+2017-04-03 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include <string.h>++#include "7zBuf.h"++void DynBuf_Construct(CDynBuf *p)+{+ p->data = 0;+ p->size = 0;+ p->pos = 0;+}++void DynBuf_SeekToBeg(CDynBuf *p)+{+ p->pos = 0;+}++int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAllocPtr alloc)+{+ if (size > p->size - p->pos)+ {+ size_t newSize = p->pos + size;+ Byte *data;+ newSize += newSize / 4;+ data = (Byte *)ISzAlloc_Alloc(alloc, newSize);+ if (!data)+ return 0;+ p->size = newSize;+ if (p->pos != 0)+ memcpy(data, p->data, p->pos);+ ISzAlloc_Free(alloc, p->data);+ p->data = data;+ }+ if (size != 0)+ {+ memcpy(p->data + p->pos, buf, size);+ p->pos += size;+ }+ return 1;+}++void DynBuf_Free(CDynBuf *p, ISzAllocPtr alloc)+{+ ISzAlloc_Free(alloc, p->data);+ p->data = 0;+ p->size = 0;+ p->pos = 0;+}
@@ -0,0 +1,340 @@+/* 7zCrc.c -- CRC32 calculation and init+2023-04-02 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include "7zCrc.h"+#include "CpuArch.h"++#define kCrcPoly 0xEDB88320++#ifdef MY_CPU_LE+ #define CRC_NUM_TABLES 8+#else+ #define CRC_NUM_TABLES 9++ UInt32 Z7_FASTCALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table);+ UInt32 Z7_FASTCALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table);+#endif++#ifndef MY_CPU_BE+ UInt32 Z7_FASTCALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);+ UInt32 Z7_FASTCALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);+#endif++/*+extern+CRC_FUNC g_CrcUpdateT4;+CRC_FUNC g_CrcUpdateT4;+*/+extern+CRC_FUNC g_CrcUpdateT8;+CRC_FUNC g_CrcUpdateT8;+extern+CRC_FUNC g_CrcUpdateT0_32;+CRC_FUNC g_CrcUpdateT0_32;+extern+CRC_FUNC g_CrcUpdateT0_64;+CRC_FUNC g_CrcUpdateT0_64;+extern+CRC_FUNC g_CrcUpdate;+CRC_FUNC g_CrcUpdate;++UInt32 g_CrcTable[256 * CRC_NUM_TABLES];++UInt32 Z7_FASTCALL CrcUpdate(UInt32 v, const void *data, size_t size)+{+ return g_CrcUpdate(v, data, size, g_CrcTable);+}++UInt32 Z7_FASTCALL CrcCalc(const void *data, size_t size)+{+ return g_CrcUpdate(CRC_INIT_VAL, data, size, g_CrcTable) ^ CRC_INIT_VAL;+}++#if CRC_NUM_TABLES < 4 \+ || (CRC_NUM_TABLES == 4 && defined(MY_CPU_BE)) \+ || (!defined(MY_CPU_LE) && !defined(MY_CPU_BE))+#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))+UInt32 Z7_FASTCALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table);+UInt32 Z7_FASTCALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table)+{+ const Byte *p = (const Byte *)data;+ const Byte *pEnd = p + size;+ for (; p != pEnd; p++)+ v = CRC_UPDATE_BYTE_2(v, *p);+ return v;+}+#endif++/* ---------- hardware CRC ---------- */++#ifdef MY_CPU_LE++#if defined(MY_CPU_ARM_OR_ARM64)++// #pragma message("ARM*")++ #if defined(_MSC_VER)+ #if defined(MY_CPU_ARM64)+ #if (_MSC_VER >= 1910)+ #ifndef __clang__+ #define USE_ARM64_CRC+ #include <intrin.h>+ #endif+ #endif+ #endif+ #elif (defined(__clang__) && (__clang_major__ >= 3)) \+ || (defined(__GNUC__) && (__GNUC__ > 4))+ #if !defined(__ARM_FEATURE_CRC32)+ #define __ARM_FEATURE_CRC32 1+ #if defined(__clang__)+ #if defined(MY_CPU_ARM64)+ #define ATTRIB_CRC __attribute__((__target__("crc")))+ #else+ #define ATTRIB_CRC __attribute__((__target__("armv8-a,crc")))+ #endif+ #else+ #if defined(MY_CPU_ARM64)+ #define ATTRIB_CRC __attribute__((__target__("+crc")))+ #else+ #define ATTRIB_CRC __attribute__((__target__("arch=armv8-a+crc")))+ #endif+ #endif+ #endif+ #if defined(__ARM_FEATURE_CRC32)+ #define USE_ARM64_CRC+ #include <arm_acle.h>+ #endif+ #endif++#else++// no hardware CRC++// #define USE_CRC_EMU++#ifdef USE_CRC_EMU++#pragma message("ARM64 CRC emulation")++Z7_FORCE_INLINE+UInt32 __crc32b(UInt32 v, UInt32 data)+{+ const UInt32 *table = g_CrcTable;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data);+ return v;+}++Z7_FORCE_INLINE+UInt32 __crc32w(UInt32 v, UInt32 data)+{+ const UInt32 *table = g_CrcTable;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ return v;+}++Z7_FORCE_INLINE+UInt32 __crc32d(UInt32 v, UInt64 data)+{+ const UInt32 *table = g_CrcTable;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;+ return v;+}++#endif // USE_CRC_EMU++#endif // defined(MY_CPU_ARM64) && defined(MY_CPU_LE)++++#if defined(USE_ARM64_CRC) || defined(USE_CRC_EMU)++#define T0_32_UNROLL_BYTES (4 * 4)+#define T0_64_UNROLL_BYTES (4 * 8)++#ifndef ATTRIB_CRC+#define ATTRIB_CRC+#endif+// #pragma message("USE ARM HW CRC")++ATTRIB_CRC+UInt32 Z7_FASTCALL CrcUpdateT0_32(UInt32 v, const void *data, size_t size, const UInt32 *table);+ATTRIB_CRC+UInt32 Z7_FASTCALL CrcUpdateT0_32(UInt32 v, const void *data, size_t size, const UInt32 *table)+{+ const Byte *p = (const Byte *)data;+ UNUSED_VAR(table);++ for (; size != 0 && ((unsigned)(ptrdiff_t)p & (T0_32_UNROLL_BYTES - 1)) != 0; size--)+ v = __crc32b(v, *p++);++ if (size >= T0_32_UNROLL_BYTES)+ {+ const Byte *lim = p + size;+ size &= (T0_32_UNROLL_BYTES - 1);+ lim -= size;+ do+ {+ v = __crc32w(v, *(const UInt32 *)(const void *)(p));+ v = __crc32w(v, *(const UInt32 *)(const void *)(p + 4)); p += 2 * 4;+ v = __crc32w(v, *(const UInt32 *)(const void *)(p));+ v = __crc32w(v, *(const UInt32 *)(const void *)(p + 4)); p += 2 * 4;+ }+ while (p != lim);+ }+ + for (; size != 0; size--)+ v = __crc32b(v, *p++);++ return v;+}++ATTRIB_CRC+UInt32 Z7_FASTCALL CrcUpdateT0_64(UInt32 v, const void *data, size_t size, const UInt32 *table);+ATTRIB_CRC+UInt32 Z7_FASTCALL CrcUpdateT0_64(UInt32 v, const void *data, size_t size, const UInt32 *table)+{+ const Byte *p = (const Byte *)data;+ UNUSED_VAR(table);++ for (; size != 0 && ((unsigned)(ptrdiff_t)p & (T0_64_UNROLL_BYTES - 1)) != 0; size--)+ v = __crc32b(v, *p++);++ if (size >= T0_64_UNROLL_BYTES)+ {+ const Byte *lim = p + size;+ size &= (T0_64_UNROLL_BYTES - 1);+ lim -= size;+ do+ {+ v = __crc32d(v, *(const UInt64 *)(const void *)(p));+ v = __crc32d(v, *(const UInt64 *)(const void *)(p + 8)); p += 2 * 8;+ v = __crc32d(v, *(const UInt64 *)(const void *)(p));+ v = __crc32d(v, *(const UInt64 *)(const void *)(p + 8)); p += 2 * 8;+ }+ while (p != lim);+ }+ + for (; size != 0; size--)+ v = __crc32b(v, *p++);++ return v;+}++#undef T0_32_UNROLL_BYTES+#undef T0_64_UNROLL_BYTES++#endif // defined(USE_ARM64_CRC) || defined(USE_CRC_EMU)++#endif // MY_CPU_LE+++++void Z7_FASTCALL CrcGenerateTable(void)+{+ UInt32 i;+ for (i = 0; i < 256; i++)+ {+ UInt32 r = i;+ unsigned j;+ for (j = 0; j < 8; j++)+ r = (r >> 1) ^ (kCrcPoly & ((UInt32)0 - (r & 1)));+ g_CrcTable[i] = r;+ }+ for (i = 256; i < 256 * CRC_NUM_TABLES; i++)+ {+ const UInt32 r = g_CrcTable[(size_t)i - 256];+ g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);+ }++ #if CRC_NUM_TABLES < 4+ g_CrcUpdate = CrcUpdateT1;+ #elif defined(MY_CPU_LE)+ // g_CrcUpdateT4 = CrcUpdateT4;+ #if CRC_NUM_TABLES < 8+ g_CrcUpdate = CrcUpdateT4;+ #else // CRC_NUM_TABLES >= 8+ g_CrcUpdateT8 = CrcUpdateT8;+ /*+ #ifdef MY_CPU_X86_OR_AMD64+ if (!CPU_Is_InOrder())+ #endif+ */+ g_CrcUpdate = CrcUpdateT8;+ #endif+ #else+ {+ #ifndef MY_CPU_BE+ UInt32 k = 0x01020304;+ const Byte *p = (const Byte *)&k;+ if (p[0] == 4 && p[1] == 3)+ {+ #if CRC_NUM_TABLES < 8+ // g_CrcUpdateT4 = CrcUpdateT4;+ g_CrcUpdate = CrcUpdateT4;+ #else // CRC_NUM_TABLES >= 8+ g_CrcUpdateT8 = CrcUpdateT8;+ g_CrcUpdate = CrcUpdateT8;+ #endif+ }+ else if (p[0] != 1 || p[1] != 2)+ g_CrcUpdate = CrcUpdateT1;+ else+ #endif // MY_CPU_BE+ {+ for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)+ {+ const UInt32 x = g_CrcTable[(size_t)i - 256];+ g_CrcTable[i] = Z7_BSWAP32(x);+ }+ #if CRC_NUM_TABLES <= 4+ g_CrcUpdate = CrcUpdateT1;+ #elif CRC_NUM_TABLES <= 8+ // g_CrcUpdateT4 = CrcUpdateT1_BeT4;+ g_CrcUpdate = CrcUpdateT1_BeT4;+ #else // CRC_NUM_TABLES > 8+ g_CrcUpdateT8 = CrcUpdateT1_BeT8;+ g_CrcUpdate = CrcUpdateT1_BeT8;+ #endif+ }+ }+ #endif // CRC_NUM_TABLES < 4++ #ifdef MY_CPU_LE+ #ifdef USE_ARM64_CRC+ if (CPU_IsSupported_CRC32())+ {+ g_CrcUpdateT0_32 = CrcUpdateT0_32;+ g_CrcUpdateT0_64 = CrcUpdateT0_64;+ g_CrcUpdate =+ #if defined(MY_CPU_ARM)+ CrcUpdateT0_32;+ #else+ CrcUpdateT0_64;+ #endif+ }+ #endif+ + #ifdef USE_CRC_EMU+ g_CrcUpdateT0_32 = CrcUpdateT0_32;+ g_CrcUpdateT0_64 = CrcUpdateT0_64;+ g_CrcUpdate = CrcUpdateT0_64;+ #endif+ #endif+}++#undef kCrcPoly+#undef CRC64_NUM_TABLES+#undef CRC_UPDATE_BYTE_2
@@ -0,0 +1,27 @@+/* 7zCrc.h -- CRC32 calculation+2023-04-02 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_7Z_CRC_H+#define ZIP7_INC_7Z_CRC_H++#include "7zTypes.h"++EXTERN_C_BEGIN++extern UInt32 g_CrcTable[];++/* Call CrcGenerateTable one time before other CRC functions */+void Z7_FASTCALL CrcGenerateTable(void);++#define CRC_INIT_VAL 0xFFFFFFFF+#define CRC_GET_DIGEST(crc) ((crc) ^ CRC_INIT_VAL)+#define CRC_UPDATE_BYTE(crc, b) (g_CrcTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))++UInt32 Z7_FASTCALL CrcUpdate(UInt32 crc, const void *data, size_t size);+UInt32 Z7_FASTCALL CrcCalc(const void *data, size_t size);++typedef UInt32 (Z7_FASTCALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);++EXTERN_C_END++#endif
@@ -0,0 +1,117 @@+/* 7zCrcOpt.c -- CRC32 calculation+2023-04-02 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include "CpuArch.h"++#ifndef MY_CPU_BE++#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))++UInt32 Z7_FASTCALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);+UInt32 Z7_FASTCALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table)+{+ const Byte *p = (const Byte *)data;+ for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)+ v = CRC_UPDATE_BYTE_2(v, *p);+ for (; size >= 4; size -= 4, p += 4)+ {+ v ^= *(const UInt32 *)(const void *)p;+ v =+ (table + 0x300)[((v ) & 0xFF)]+ ^ (table + 0x200)[((v >> 8) & 0xFF)]+ ^ (table + 0x100)[((v >> 16) & 0xFF)]+ ^ (table + 0x000)[((v >> 24))];+ }+ for (; size > 0; size--, p++)+ v = CRC_UPDATE_BYTE_2(v, *p);+ return v;+}++UInt32 Z7_FASTCALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);+UInt32 Z7_FASTCALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table)+{+ const Byte *p = (const Byte *)data;+ for (; size > 0 && ((unsigned)(ptrdiff_t)p & 7) != 0; size--, p++)+ v = CRC_UPDATE_BYTE_2(v, *p);+ for (; size >= 8; size -= 8, p += 8)+ {+ UInt32 d;+ v ^= *(const UInt32 *)(const void *)p;+ v =+ (table + 0x700)[((v ) & 0xFF)]+ ^ (table + 0x600)[((v >> 8) & 0xFF)]+ ^ (table + 0x500)[((v >> 16) & 0xFF)]+ ^ (table + 0x400)[((v >> 24))];+ d = *((const UInt32 *)(const void *)p + 1);+ v ^=+ (table + 0x300)[((d ) & 0xFF)]+ ^ (table + 0x200)[((d >> 8) & 0xFF)]+ ^ (table + 0x100)[((d >> 16) & 0xFF)]+ ^ (table + 0x000)[((d >> 24))];+ }+ for (; size > 0; size--, p++)+ v = CRC_UPDATE_BYTE_2(v, *p);+ return v;+}++#endif+++#ifndef MY_CPU_LE++#define CRC_UINT32_SWAP(v) Z7_BSWAP32(v)++#define CRC_UPDATE_BYTE_2_BE(crc, b) (table[(((crc) >> 24) ^ (b))] ^ ((crc) << 8))++UInt32 Z7_FASTCALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table)+{+ const Byte *p = (const Byte *)data;+ table += 0x100;+ v = CRC_UINT32_SWAP(v);+ for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)+ v = CRC_UPDATE_BYTE_2_BE(v, *p);+ for (; size >= 4; size -= 4, p += 4)+ {+ v ^= *(const UInt32 *)(const void *)p;+ v =+ (table + 0x000)[((v ) & 0xFF)]+ ^ (table + 0x100)[((v >> 8) & 0xFF)]+ ^ (table + 0x200)[((v >> 16) & 0xFF)]+ ^ (table + 0x300)[((v >> 24))];+ }+ for (; size > 0; size--, p++)+ v = CRC_UPDATE_BYTE_2_BE(v, *p);+ return CRC_UINT32_SWAP(v);+}++UInt32 Z7_FASTCALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table)+{+ const Byte *p = (const Byte *)data;+ table += 0x100;+ v = CRC_UINT32_SWAP(v);+ for (; size > 0 && ((unsigned)(ptrdiff_t)p & 7) != 0; size--, p++)+ v = CRC_UPDATE_BYTE_2_BE(v, *p);+ for (; size >= 8; size -= 8, p += 8)+ {+ UInt32 d;+ v ^= *(const UInt32 *)(const void *)p;+ v =+ (table + 0x400)[((v ) & 0xFF)]+ ^ (table + 0x500)[((v >> 8) & 0xFF)]+ ^ (table + 0x600)[((v >> 16) & 0xFF)]+ ^ (table + 0x700)[((v >> 24))];+ d = *((const UInt32 *)(const void *)p + 1);+ v ^=+ (table + 0x000)[((d ) & 0xFF)]+ ^ (table + 0x100)[((d >> 8) & 0xFF)]+ ^ (table + 0x200)[((d >> 16) & 0xFF)]+ ^ (table + 0x300)[((d >> 24))];+ }+ for (; size > 0; size--, p++)+ v = CRC_UPDATE_BYTE_2_BE(v, *p);+ return CRC_UINT32_SWAP(v);+}++#endif
@@ -0,0 +1,648 @@+/* 7zDec.c -- Decoding from 7z folder+2023-04-02 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include <string.h>++/* #define Z7_PPMD_SUPPORT */++#include "7z.h"+#include "7zCrc.h"++#include "Bcj2.h"+#include "Bra.h"+#include "CpuArch.h"+#include "Delta.h"+#include "LzmaDec.h"+#include "Lzma2Dec.h"+#ifdef Z7_PPMD_SUPPORT+#include "Ppmd7.h"+#endif++#define k_Copy 0+#ifndef Z7_NO_METHOD_LZMA2+#define k_LZMA2 0x21+#endif+#define k_LZMA 0x30101+#define k_BCJ2 0x303011B++#if !defined(Z7_NO_METHODS_FILTERS)+#define Z7_USE_BRANCH_FILTER+#endif++#if !defined(Z7_NO_METHODS_FILTERS) || \+ defined(Z7_USE_NATIVE_BRANCH_FILTER) && defined(MY_CPU_ARM64)+#define Z7_USE_FILTER_ARM64+#ifndef Z7_USE_BRANCH_FILTER+#define Z7_USE_BRANCH_FILTER+#endif+#define k_ARM64 0xa+#endif++#if !defined(Z7_NO_METHODS_FILTERS) || \+ defined(Z7_USE_NATIVE_BRANCH_FILTER) && defined(MY_CPU_ARMT)+#define Z7_USE_FILTER_ARMT+#ifndef Z7_USE_BRANCH_FILTER+#define Z7_USE_BRANCH_FILTER+#endif+#define k_ARMT 0x3030701+#endif++#ifndef Z7_NO_METHODS_FILTERS+#define k_Delta 3+#define k_BCJ 0x3030103+#define k_PPC 0x3030205+#define k_IA64 0x3030401+#define k_ARM 0x3030501+#define k_SPARC 0x3030805+#endif++#ifdef Z7_PPMD_SUPPORT++#define k_PPMD 0x30401++typedef struct+{+ IByteIn vt;+ const Byte *cur;+ const Byte *end;+ const Byte *begin;+ UInt64 processed;+ BoolInt extra;+ SRes res;+ ILookInStreamPtr inStream;+} CByteInToLook;++static Byte ReadByte(IByteInPtr pp)+{+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CByteInToLook)+ if (p->cur != p->end)+ return *p->cur++;+ if (p->res == SZ_OK)+ {+ size_t size = (size_t)(p->cur - p->begin);+ p->processed += size;+ p->res = ILookInStream_Skip(p->inStream, size);+ size = (1 << 25);+ p->res = ILookInStream_Look(p->inStream, (const void **)&p->begin, &size);+ p->cur = p->begin;+ p->end = p->begin + size;+ if (size != 0)+ return *p->cur++;+ }+ p->extra = True;+ return 0;+}++static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStreamPtr inStream,+ Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)+{+ CPpmd7 ppmd;+ CByteInToLook s;+ SRes res = SZ_OK;++ s.vt.Read = ReadByte;+ s.inStream = inStream;+ s.begin = s.end = s.cur = NULL;+ s.extra = False;+ s.res = SZ_OK;+ s.processed = 0;++ if (propsSize != 5)+ return SZ_ERROR_UNSUPPORTED;++ {+ unsigned order = props[0];+ UInt32 memSize = GetUi32(props + 1);+ if (order < PPMD7_MIN_ORDER ||+ order > PPMD7_MAX_ORDER ||+ memSize < PPMD7_MIN_MEM_SIZE ||+ memSize > PPMD7_MAX_MEM_SIZE)+ return SZ_ERROR_UNSUPPORTED;+ Ppmd7_Construct(&ppmd);+ if (!Ppmd7_Alloc(&ppmd, memSize, allocMain))+ return SZ_ERROR_MEM;+ Ppmd7_Init(&ppmd, order);+ }+ {+ ppmd.rc.dec.Stream = &s.vt;+ if (!Ppmd7z_RangeDec_Init(&ppmd.rc.dec))+ res = SZ_ERROR_DATA;+ else if (!s.extra)+ {+ Byte *buf = outBuffer;+ const Byte *lim = buf + outSize;+ for (; buf != lim; buf++)+ {+ int sym = Ppmd7z_DecodeSymbol(&ppmd);+ if (s.extra || sym < 0)+ break;+ *buf = (Byte)sym;+ }+ if (buf != lim)+ res = SZ_ERROR_DATA;+ else if (!Ppmd7z_RangeDec_IsFinishedOK(&ppmd.rc.dec))+ {+ /* if (Ppmd7z_DecodeSymbol(&ppmd) != PPMD7_SYM_END || !Ppmd7z_RangeDec_IsFinishedOK(&ppmd.rc.dec)) */+ res = SZ_ERROR_DATA;+ }+ }+ if (s.extra)+ res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);+ else if (s.processed + (size_t)(s.cur - s.begin) != inSize)+ res = SZ_ERROR_DATA;+ }+ Ppmd7_Free(&ppmd, allocMain);+ return res;+}++#endif+++static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStreamPtr inStream,+ Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)+{+ CLzmaDec state;+ SRes res = SZ_OK;++ LzmaDec_CONSTRUCT(&state)+ RINOK(LzmaDec_AllocateProbs(&state, props, propsSize, allocMain))+ state.dic = outBuffer;+ state.dicBufSize = outSize;+ LzmaDec_Init(&state);++ for (;;)+ {+ const void *inBuf = NULL;+ size_t lookahead = (1 << 18);+ if (lookahead > inSize)+ lookahead = (size_t)inSize;+ res = ILookInStream_Look(inStream, &inBuf, &lookahead);+ if (res != SZ_OK)+ break;++ {+ SizeT inProcessed = (SizeT)lookahead, dicPos = state.dicPos;+ ELzmaStatus status;+ res = LzmaDec_DecodeToDic(&state, outSize, (const Byte *)inBuf, &inProcessed, LZMA_FINISH_END, &status);+ lookahead -= inProcessed;+ inSize -= inProcessed;+ if (res != SZ_OK)+ break;++ if (status == LZMA_STATUS_FINISHED_WITH_MARK)+ {+ if (outSize != state.dicPos || inSize != 0)+ res = SZ_ERROR_DATA;+ break;+ }++ if (outSize == state.dicPos && inSize == 0 && status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)+ break;++ if (inProcessed == 0 && dicPos == state.dicPos)+ {+ res = SZ_ERROR_DATA;+ break;+ }++ res = ILookInStream_Skip(inStream, inProcessed);+ if (res != SZ_OK)+ break;+ }+ }++ LzmaDec_FreeProbs(&state, allocMain);+ return res;+}+++#ifndef Z7_NO_METHOD_LZMA2++static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStreamPtr inStream,+ Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)+{+ CLzma2Dec state;+ SRes res = SZ_OK;++ Lzma2Dec_CONSTRUCT(&state)+ if (propsSize != 1)+ return SZ_ERROR_DATA;+ RINOK(Lzma2Dec_AllocateProbs(&state, props[0], allocMain))+ state.decoder.dic = outBuffer;+ state.decoder.dicBufSize = outSize;+ Lzma2Dec_Init(&state);++ for (;;)+ {+ const void *inBuf = NULL;+ size_t lookahead = (1 << 18);+ if (lookahead > inSize)+ lookahead = (size_t)inSize;+ res = ILookInStream_Look(inStream, &inBuf, &lookahead);+ if (res != SZ_OK)+ break;++ {+ SizeT inProcessed = (SizeT)lookahead, dicPos = state.decoder.dicPos;+ ELzmaStatus status;+ res = Lzma2Dec_DecodeToDic(&state, outSize, (const Byte *)inBuf, &inProcessed, LZMA_FINISH_END, &status);+ lookahead -= inProcessed;+ inSize -= inProcessed;+ if (res != SZ_OK)+ break;++ if (status == LZMA_STATUS_FINISHED_WITH_MARK)+ {+ if (outSize != state.decoder.dicPos || inSize != 0)+ res = SZ_ERROR_DATA;+ break;+ }++ if (inProcessed == 0 && dicPos == state.decoder.dicPos)+ {+ res = SZ_ERROR_DATA;+ break;+ }++ res = ILookInStream_Skip(inStream, inProcessed);+ if (res != SZ_OK)+ break;+ }+ }++ Lzma2Dec_FreeProbs(&state, allocMain);+ return res;+}++#endif+++static SRes SzDecodeCopy(UInt64 inSize, ILookInStreamPtr inStream, Byte *outBuffer)+{+ while (inSize > 0)+ {+ const void *inBuf;+ size_t curSize = (1 << 18);+ if (curSize > inSize)+ curSize = (size_t)inSize;+ RINOK(ILookInStream_Look(inStream, &inBuf, &curSize))+ if (curSize == 0)+ return SZ_ERROR_INPUT_EOF;+ memcpy(outBuffer, inBuf, curSize);+ outBuffer += curSize;+ inSize -= curSize;+ RINOK(ILookInStream_Skip(inStream, curSize))+ }+ return SZ_OK;+}++static BoolInt IS_MAIN_METHOD(UInt32 m)+{+ switch (m)+ {+ case k_Copy:+ case k_LZMA:+ #ifndef Z7_NO_METHOD_LZMA2+ case k_LZMA2:+ #endif+ #ifdef Z7_PPMD_SUPPORT+ case k_PPMD:+ #endif+ return True;+ }+ return False;+}++static BoolInt IS_SUPPORTED_CODER(const CSzCoderInfo *c)+{+ return+ c->NumStreams == 1+ /* && c->MethodID <= (UInt32)0xFFFFFFFF */+ && IS_MAIN_METHOD((UInt32)c->MethodID);+}++#define IS_BCJ2(c) ((c)->MethodID == k_BCJ2 && (c)->NumStreams == 4)++static SRes CheckSupportedFolder(const CSzFolder *f)+{+ if (f->NumCoders < 1 || f->NumCoders > 4)+ return SZ_ERROR_UNSUPPORTED;+ if (!IS_SUPPORTED_CODER(&f->Coders[0]))+ return SZ_ERROR_UNSUPPORTED;+ if (f->NumCoders == 1)+ {+ if (f->NumPackStreams != 1 || f->PackStreams[0] != 0 || f->NumBonds != 0)+ return SZ_ERROR_UNSUPPORTED;+ return SZ_OK;+ }+ + + #if defined(Z7_USE_BRANCH_FILTER)++ if (f->NumCoders == 2)+ {+ const CSzCoderInfo *c = &f->Coders[1];+ if (+ /* c->MethodID > (UInt32)0xFFFFFFFF || */+ c->NumStreams != 1+ || f->NumPackStreams != 1+ || f->PackStreams[0] != 0+ || f->NumBonds != 1+ || f->Bonds[0].InIndex != 1+ || f->Bonds[0].OutIndex != 0)+ return SZ_ERROR_UNSUPPORTED;+ switch ((UInt32)c->MethodID)+ {+ #if !defined(Z7_NO_METHODS_FILTERS)+ case k_Delta:+ case k_BCJ:+ case k_PPC:+ case k_IA64:+ case k_SPARC:+ case k_ARM:+ #endif+ #ifdef Z7_USE_FILTER_ARM64+ case k_ARM64:+ #endif+ #ifdef Z7_USE_FILTER_ARMT+ case k_ARMT:+ #endif+ break;+ default:+ return SZ_ERROR_UNSUPPORTED;+ }+ return SZ_OK;+ }++ #endif++ + if (f->NumCoders == 4)+ {+ if (!IS_SUPPORTED_CODER(&f->Coders[1])+ || !IS_SUPPORTED_CODER(&f->Coders[2])+ || !IS_BCJ2(&f->Coders[3]))+ return SZ_ERROR_UNSUPPORTED;+ if (f->NumPackStreams != 4+ || f->PackStreams[0] != 2+ || f->PackStreams[1] != 6+ || f->PackStreams[2] != 1+ || f->PackStreams[3] != 0+ || f->NumBonds != 3+ || f->Bonds[0].InIndex != 5 || f->Bonds[0].OutIndex != 0+ || f->Bonds[1].InIndex != 4 || f->Bonds[1].OutIndex != 1+ || f->Bonds[2].InIndex != 3 || f->Bonds[2].OutIndex != 2)+ return SZ_ERROR_UNSUPPORTED;+ return SZ_OK;+ }+ + return SZ_ERROR_UNSUPPORTED;+}+++++++static SRes SzFolder_Decode2(const CSzFolder *folder,+ const Byte *propsData,+ const UInt64 *unpackSizes,+ const UInt64 *packPositions,+ ILookInStreamPtr inStream, UInt64 startPos,+ Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain,+ Byte *tempBuf[])+{+ UInt32 ci;+ SizeT tempSizes[3] = { 0, 0, 0};+ SizeT tempSize3 = 0;+ Byte *tempBuf3 = 0;++ RINOK(CheckSupportedFolder(folder))++ for (ci = 0; ci < folder->NumCoders; ci++)+ {+ const CSzCoderInfo *coder = &folder->Coders[ci];++ if (IS_MAIN_METHOD((UInt32)coder->MethodID))+ {+ UInt32 si = 0;+ UInt64 offset;+ UInt64 inSize;+ Byte *outBufCur = outBuffer;+ SizeT outSizeCur = outSize;+ if (folder->NumCoders == 4)+ {+ const UInt32 indices[] = { 3, 2, 0 };+ const UInt64 unpackSize = unpackSizes[ci];+ si = indices[ci];+ if (ci < 2)+ {+ Byte *temp;+ outSizeCur = (SizeT)unpackSize;+ if (outSizeCur != unpackSize)+ return SZ_ERROR_MEM;+ temp = (Byte *)ISzAlloc_Alloc(allocMain, outSizeCur);+ if (!temp && outSizeCur != 0)+ return SZ_ERROR_MEM;+ outBufCur = tempBuf[1 - ci] = temp;+ tempSizes[1 - ci] = outSizeCur;+ }+ else if (ci == 2)+ {+ if (unpackSize > outSize) /* check it */+ return SZ_ERROR_PARAM;+ tempBuf3 = outBufCur = outBuffer + (outSize - (size_t)unpackSize);+ tempSize3 = outSizeCur = (SizeT)unpackSize;+ }+ else+ return SZ_ERROR_UNSUPPORTED;+ }+ offset = packPositions[si];+ inSize = packPositions[(size_t)si + 1] - offset;+ RINOK(LookInStream_SeekTo(inStream, startPos + offset))++ if (coder->MethodID == k_Copy)+ {+ if (inSize != outSizeCur) /* check it */+ return SZ_ERROR_DATA;+ RINOK(SzDecodeCopy(inSize, inStream, outBufCur))+ }+ else if (coder->MethodID == k_LZMA)+ {+ RINOK(SzDecodeLzma(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain))+ }+ #ifndef Z7_NO_METHOD_LZMA2+ else if (coder->MethodID == k_LZMA2)+ {+ RINOK(SzDecodeLzma2(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain))+ }+ #endif+ #ifdef Z7_PPMD_SUPPORT+ else if (coder->MethodID == k_PPMD)+ {+ RINOK(SzDecodePpmd(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain))+ }+ #endif+ else+ return SZ_ERROR_UNSUPPORTED;+ }+ else if (coder->MethodID == k_BCJ2)+ {+ const UInt64 offset = packPositions[1];+ const UInt64 s3Size = packPositions[2] - offset;+ + if (ci != 3)+ return SZ_ERROR_UNSUPPORTED;+ + tempSizes[2] = (SizeT)s3Size;+ if (tempSizes[2] != s3Size)+ return SZ_ERROR_MEM;+ tempBuf[2] = (Byte *)ISzAlloc_Alloc(allocMain, tempSizes[2]);+ if (!tempBuf[2] && tempSizes[2] != 0)+ return SZ_ERROR_MEM;+ + RINOK(LookInStream_SeekTo(inStream, startPos + offset))+ RINOK(SzDecodeCopy(s3Size, inStream, tempBuf[2]))++ if ((tempSizes[0] & 3) != 0 ||+ (tempSizes[1] & 3) != 0 ||+ tempSize3 + tempSizes[0] + tempSizes[1] != outSize)+ return SZ_ERROR_DATA;++ {+ CBcj2Dec p;+ + p.bufs[0] = tempBuf3; p.lims[0] = tempBuf3 + tempSize3;+ p.bufs[1] = tempBuf[0]; p.lims[1] = tempBuf[0] + tempSizes[0];+ p.bufs[2] = tempBuf[1]; p.lims[2] = tempBuf[1] + tempSizes[1];+ p.bufs[3] = tempBuf[2]; p.lims[3] = tempBuf[2] + tempSizes[2];+ + p.dest = outBuffer;+ p.destLim = outBuffer + outSize;+ + Bcj2Dec_Init(&p);+ RINOK(Bcj2Dec_Decode(&p))++ {+ unsigned i;+ for (i = 0; i < 4; i++)+ if (p.bufs[i] != p.lims[i])+ return SZ_ERROR_DATA;+ if (p.dest != p.destLim || !Bcj2Dec_IsMaybeFinished(&p))+ return SZ_ERROR_DATA;+ }+ }+ }+ #if defined(Z7_USE_BRANCH_FILTER)+ else if (ci == 1)+ {+ #if !defined(Z7_NO_METHODS_FILTERS)+ if (coder->MethodID == k_Delta)+ {+ if (coder->PropsSize != 1)+ return SZ_ERROR_UNSUPPORTED;+ {+ Byte state[DELTA_STATE_SIZE];+ Delta_Init(state);+ Delta_Decode(state, (unsigned)(propsData[coder->PropsOffset]) + 1, outBuffer, outSize);+ }+ continue;+ }+ #endif+ + #ifdef Z7_USE_FILTER_ARM64+ if (coder->MethodID == k_ARM64)+ {+ UInt32 pc = 0;+ if (coder->PropsSize == 4)+ pc = GetUi32(propsData + coder->PropsOffset);+ else if (coder->PropsSize != 0)+ return SZ_ERROR_UNSUPPORTED;+ z7_BranchConv_ARM64_Dec(outBuffer, outSize, pc);+ continue;+ }+ #endif+ + #if !defined(Z7_NO_METHODS_FILTERS) || defined(Z7_USE_FILTER_ARMT)+ {+ if (coder->PropsSize != 0)+ return SZ_ERROR_UNSUPPORTED;+ #define CASE_BRA_CONV(isa) case k_ ## isa: Z7_BRANCH_CONV_DEC(isa)(outBuffer, outSize, 0); break; // pc = 0;+ switch (coder->MethodID)+ {+ #if !defined(Z7_NO_METHODS_FILTERS)+ case k_BCJ:+ {+ UInt32 state = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;+ z7_BranchConvSt_X86_Dec(outBuffer, outSize, 0, &state); // pc = 0+ break;+ }+ CASE_BRA_CONV(PPC)+ CASE_BRA_CONV(IA64)+ CASE_BRA_CONV(SPARC)+ CASE_BRA_CONV(ARM)+ #endif+ #if !defined(Z7_NO_METHODS_FILTERS) || defined(Z7_USE_FILTER_ARMT)+ CASE_BRA_CONV(ARMT)+ #endif+ default:+ return SZ_ERROR_UNSUPPORTED;+ }+ continue;+ }+ #endif+ } // (c == 1)+ #endif+ else+ return SZ_ERROR_UNSUPPORTED;+ }++ return SZ_OK;+}+++SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,+ ILookInStreamPtr inStream, UInt64 startPos,+ Byte *outBuffer, size_t outSize,+ ISzAllocPtr allocMain)+{+ SRes res;+ CSzFolder folder;+ CSzData sd;+ + const Byte *data = p->CodersData + p->FoCodersOffsets[folderIndex];+ sd.Data = data;+ sd.Size = p->FoCodersOffsets[(size_t)folderIndex + 1] - p->FoCodersOffsets[folderIndex];+ + res = SzGetNextFolderItem(&folder, &sd);+ + if (res != SZ_OK)+ return res;++ if (sd.Size != 0+ || folder.UnpackStream != p->FoToMainUnpackSizeIndex[folderIndex]+ || outSize != SzAr_GetFolderUnpackSize(p, folderIndex))+ return SZ_ERROR_FAIL;+ {+ unsigned i;+ Byte *tempBuf[3] = { 0, 0, 0};++ res = SzFolder_Decode2(&folder, data,+ &p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex]],+ p->PackPositions + p->FoStartPackStreamIndex[folderIndex],+ inStream, startPos,+ outBuffer, (SizeT)outSize, allocMain, tempBuf);+ + for (i = 0; i < 3; i++)+ ISzAlloc_Free(allocMain, tempBuf[i]);++ if (res == SZ_OK)+ if (SzBitWithVals_Check(&p->FolderCRCs, folderIndex))+ if (CrcCalc(outBuffer, outSize) != p->FolderCRCs.Vals[folderIndex])+ res = SZ_ERROR_CRC;++ return res;+ }+}
@@ -0,0 +1,443 @@+/* 7zFile.c -- File IO+2023-04-02 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include "7zFile.h"++#ifndef USE_WINDOWS_FILE++ #include <errno.h>++ #ifndef USE_FOPEN+ #include <stdio.h>+ #include <fcntl.h>+ #ifdef _WIN32+ #include <io.h>+ typedef int ssize_t;+ typedef int off_t;+ #else+ #include <unistd.h>+ #endif+ #endif++#else++/*+ ReadFile and WriteFile functions in Windows have BUG:+ If you Read or Write 64MB or more (probably min_failure_size = 64MB - 32KB + 1)+ from/to Network file, it returns ERROR_NO_SYSTEM_RESOURCES+ (Insufficient system resources exist to complete the requested service).+ Probably in some version of Windows there are problems with other sizes:+ for 32 MB (maybe also for 16 MB).+ And message can be "Network connection was lost"+*/++#endif++#define kChunkSizeMax (1 << 22)++void File_Construct(CSzFile *p)+{+ #ifdef USE_WINDOWS_FILE+ p->handle = INVALID_HANDLE_VALUE;+ #elif defined(USE_FOPEN)+ p->file = NULL;+ #else+ p->fd = -1;+ #endif+}++#if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)++static WRes File_Open(CSzFile *p, const char *name, int writeMode)+{+ #ifdef USE_WINDOWS_FILE+ + p->handle = CreateFileA(name,+ writeMode ? GENERIC_WRITE : GENERIC_READ,+ FILE_SHARE_READ, NULL,+ writeMode ? CREATE_ALWAYS : OPEN_EXISTING,+ FILE_ATTRIBUTE_NORMAL, NULL);+ return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();+ + #elif defined(USE_FOPEN)+ + p->file = fopen(name, writeMode ? "wb+" : "rb");+ return (p->file != 0) ? 0 :+ #ifdef UNDER_CE+ 2; /* ENOENT */+ #else+ errno;+ #endif+ + #else++ int flags = (writeMode ? (O_CREAT | O_EXCL | O_WRONLY) : O_RDONLY);+ #ifdef O_BINARY+ flags |= O_BINARY;+ #endif+ p->fd = open(name, flags, 0666);+ return (p->fd != -1) ? 0 : errno;++ #endif+}++WRes InFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 0); }++WRes OutFile_Open(CSzFile *p, const char *name)+{+ #if defined(USE_WINDOWS_FILE) || defined(USE_FOPEN)+ return File_Open(p, name, 1);+ #else+ p->fd = creat(name, 0666);+ return (p->fd != -1) ? 0 : errno;+ #endif+}++#endif+++#ifdef USE_WINDOWS_FILE+static WRes File_OpenW(CSzFile *p, const WCHAR *name, int writeMode)+{+ p->handle = CreateFileW(name,+ writeMode ? GENERIC_WRITE : GENERIC_READ,+ FILE_SHARE_READ, NULL,+ writeMode ? CREATE_ALWAYS : OPEN_EXISTING,+ FILE_ATTRIBUTE_NORMAL, NULL);+ return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();+}+WRes InFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 0); }+WRes OutFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 1); }+#endif++WRes File_Close(CSzFile *p)+{+ #ifdef USE_WINDOWS_FILE+ + if (p->handle != INVALID_HANDLE_VALUE)+ {+ if (!CloseHandle(p->handle))+ return GetLastError();+ p->handle = INVALID_HANDLE_VALUE;+ }+ + #elif defined(USE_FOPEN)++ if (p->file != NULL)+ {+ int res = fclose(p->file);+ if (res != 0)+ {+ if (res == EOF)+ return errno;+ return res;+ }+ p->file = NULL;+ }++ #else++ if (p->fd != -1)+ {+ if (close(p->fd) != 0)+ return errno;+ p->fd = -1;+ }++ #endif++ return 0;+}+++WRes File_Read(CSzFile *p, void *data, size_t *size)+{+ size_t originalSize = *size;+ *size = 0;+ if (originalSize == 0)+ return 0;++ #ifdef USE_WINDOWS_FILE++ do+ {+ const DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;+ DWORD processed = 0;+ const BOOL res = ReadFile(p->handle, data, curSize, &processed, NULL);+ data = (void *)((Byte *)data + processed);+ originalSize -= processed;+ *size += processed;+ if (!res)+ return GetLastError();+ // debug : we can break here for partial reading mode+ if (processed == 0)+ break;+ }+ while (originalSize > 0);++ #elif defined(USE_FOPEN)++ do+ {+ const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;+ const size_t processed = fread(data, 1, curSize, p->file);+ data = (void *)((Byte *)data + (size_t)processed);+ originalSize -= processed;+ *size += processed;+ if (processed != curSize)+ return ferror(p->file);+ // debug : we can break here for partial reading mode+ if (processed == 0)+ break;+ }+ while (originalSize > 0);++ #else++ do+ {+ const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;+ const ssize_t processed = read(p->fd, data, curSize);+ if (processed == -1)+ return errno;+ if (processed == 0)+ break;+ data = (void *)((Byte *)data + (size_t)processed);+ originalSize -= (size_t)processed;+ *size += (size_t)processed;+ // debug : we can break here for partial reading mode+ // break;+ }+ while (originalSize > 0);++ #endif++ return 0;+}+++WRes File_Write(CSzFile *p, const void *data, size_t *size)+{+ size_t originalSize = *size;+ *size = 0;+ if (originalSize == 0)+ return 0;+ + #ifdef USE_WINDOWS_FILE++ do+ {+ const DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;+ DWORD processed = 0;+ const BOOL res = WriteFile(p->handle, data, curSize, &processed, NULL);+ data = (const void *)((const Byte *)data + processed);+ originalSize -= processed;+ *size += processed;+ if (!res)+ return GetLastError();+ if (processed == 0)+ break;+ }+ while (originalSize > 0);++ #elif defined(USE_FOPEN)++ do+ {+ const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;+ const size_t processed = fwrite(data, 1, curSize, p->file);+ data = (void *)((Byte *)data + (size_t)processed);+ originalSize -= processed;+ *size += processed;+ if (processed != curSize)+ return ferror(p->file);+ if (processed == 0)+ break;+ }+ while (originalSize > 0);++ #else++ do+ {+ const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;+ const ssize_t processed = write(p->fd, data, curSize);+ if (processed == -1)+ return errno;+ if (processed == 0)+ break;+ data = (const void *)((const Byte *)data + (size_t)processed);+ originalSize -= (size_t)processed;+ *size += (size_t)processed;+ }+ while (originalSize > 0);++ #endif++ return 0;+}+++WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)+{+ #ifdef USE_WINDOWS_FILE++ DWORD moveMethod;+ UInt32 low = (UInt32)*pos;+ LONG high = (LONG)((UInt64)*pos >> 16 >> 16); /* for case when UInt64 is 32-bit only */+ // (int) to eliminate clang warning+ switch ((int)origin)+ {+ case SZ_SEEK_SET: moveMethod = FILE_BEGIN; break;+ case SZ_SEEK_CUR: moveMethod = FILE_CURRENT; break;+ case SZ_SEEK_END: moveMethod = FILE_END; break;+ default: return ERROR_INVALID_PARAMETER;+ }+ low = SetFilePointer(p->handle, (LONG)low, &high, moveMethod);+ if (low == (UInt32)0xFFFFFFFF)+ {+ WRes res = GetLastError();+ if (res != NO_ERROR)+ return res;+ }+ *pos = ((Int64)high << 32) | low;+ return 0;++ #else+ + int moveMethod; // = origin;++ switch ((int)origin)+ {+ case SZ_SEEK_SET: moveMethod = SEEK_SET; break;+ case SZ_SEEK_CUR: moveMethod = SEEK_CUR; break;+ case SZ_SEEK_END: moveMethod = SEEK_END; break;+ default: return EINVAL;+ }+ + #if defined(USE_FOPEN)+ {+ int res = fseek(p->file, (long)*pos, moveMethod);+ if (res == -1)+ return errno;+ *pos = ftell(p->file);+ if (*pos == -1)+ return errno;+ return 0;+ }+ #else+ {+ off_t res = lseek(p->fd, (off_t)*pos, moveMethod);+ if (res == -1)+ return errno;+ *pos = res;+ return 0;+ }+ + #endif // USE_FOPEN+ #endif // USE_WINDOWS_FILE+}+++WRes File_GetLength(CSzFile *p, UInt64 *length)+{+ #ifdef USE_WINDOWS_FILE+ + DWORD sizeHigh;+ DWORD sizeLow = GetFileSize(p->handle, &sizeHigh);+ if (sizeLow == 0xFFFFFFFF)+ {+ DWORD res = GetLastError();+ if (res != NO_ERROR)+ return res;+ }+ *length = (((UInt64)sizeHigh) << 32) + sizeLow;+ return 0;+ + #elif defined(USE_FOPEN)+ + long pos = ftell(p->file);+ int res = fseek(p->file, 0, SEEK_END);+ *length = ftell(p->file);+ fseek(p->file, pos, SEEK_SET);+ return res;++ #else++ off_t pos;+ *length = 0;+ pos = lseek(p->fd, 0, SEEK_CUR);+ if (pos != -1)+ {+ const off_t len2 = lseek(p->fd, 0, SEEK_END);+ const off_t res2 = lseek(p->fd, pos, SEEK_SET);+ if (len2 != -1)+ {+ *length = (UInt64)len2;+ if (res2 != -1)+ return 0;+ }+ }+ return errno;+ + #endif+}+++/* ---------- FileSeqInStream ---------- */++static SRes FileSeqInStream_Read(ISeqInStreamPtr pp, void *buf, size_t *size)+{+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CFileSeqInStream)+ const WRes wres = File_Read(&p->file, buf, size);+ p->wres = wres;+ return (wres == 0) ? SZ_OK : SZ_ERROR_READ;+}++void FileSeqInStream_CreateVTable(CFileSeqInStream *p)+{+ p->vt.Read = FileSeqInStream_Read;+}+++/* ---------- FileInStream ---------- */++static SRes FileInStream_Read(ISeekInStreamPtr pp, void *buf, size_t *size)+{+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CFileInStream)+ const WRes wres = File_Read(&p->file, buf, size);+ p->wres = wres;+ return (wres == 0) ? SZ_OK : SZ_ERROR_READ;+}++static SRes FileInStream_Seek(ISeekInStreamPtr pp, Int64 *pos, ESzSeek origin)+{+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CFileInStream)+ const WRes wres = File_Seek(&p->file, pos, origin);+ p->wres = wres;+ return (wres == 0) ? SZ_OK : SZ_ERROR_READ;+}++void FileInStream_CreateVTable(CFileInStream *p)+{+ p->vt.Read = FileInStream_Read;+ p->vt.Seek = FileInStream_Seek;+}+++/* ---------- FileOutStream ---------- */++static size_t FileOutStream_Write(ISeqOutStreamPtr pp, const void *data, size_t size)+{+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CFileOutStream)+ const WRes wres = File_Write(&p->file, data, &size);+ p->wres = wres;+ return size;+}++void FileOutStream_CreateVTable(CFileOutStream *p)+{+ p->vt.Write = FileOutStream_Write;+}
@@ -0,0 +1,92 @@+/* 7zFile.h -- File IO+2023-03-05 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_FILE_H+#define ZIP7_INC_FILE_H++#ifdef _WIN32+#define USE_WINDOWS_FILE+// #include <windows.h>+#endif++#ifdef USE_WINDOWS_FILE+#include "7zWindows.h"++#else+// note: USE_FOPEN mode is limited to 32-bit file size+// #define USE_FOPEN+// #include <stdio.h>+#endif++#include "7zTypes.h"++EXTERN_C_BEGIN++/* ---------- File ---------- */++typedef struct+{+ #ifdef USE_WINDOWS_FILE+ HANDLE handle;+ #elif defined(USE_FOPEN)+ FILE *file;+ #else+ int fd;+ #endif+} CSzFile;++void File_Construct(CSzFile *p);+#if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)+WRes InFile_Open(CSzFile *p, const char *name);+WRes OutFile_Open(CSzFile *p, const char *name);+#endif+#ifdef USE_WINDOWS_FILE+WRes InFile_OpenW(CSzFile *p, const WCHAR *name);+WRes OutFile_OpenW(CSzFile *p, const WCHAR *name);+#endif+WRes File_Close(CSzFile *p);++/* reads max(*size, remain file's size) bytes */+WRes File_Read(CSzFile *p, void *data, size_t *size);++/* writes *size bytes */+WRes File_Write(CSzFile *p, const void *data, size_t *size);++WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin);+WRes File_GetLength(CSzFile *p, UInt64 *length);+++/* ---------- FileInStream ---------- */++typedef struct+{+ ISeqInStream vt;+ CSzFile file;+ WRes wres;+} CFileSeqInStream;++void FileSeqInStream_CreateVTable(CFileSeqInStream *p);+++typedef struct+{+ ISeekInStream vt;+ CSzFile file;+ WRes wres;+} CFileInStream;++void FileInStream_CreateVTable(CFileInStream *p);+++typedef struct+{+ ISeqOutStream vt;+ CSzFile file;+ WRes wres;+} CFileOutStream;++void FileOutStream_CreateVTable(CFileOutStream *p);++EXTERN_C_END++#endif
@@ -0,0 +1,199 @@+/* 7zStream.c -- 7z Stream functions+2023-04-02 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include <string.h>++#include "7zTypes.h"+++SRes SeqInStream_ReadMax(ISeqInStreamPtr stream, void *buf, size_t *processedSize)+{+ size_t size = *processedSize;+ *processedSize = 0;+ while (size != 0)+ {+ size_t cur = size;+ const SRes res = ISeqInStream_Read(stream, buf, &cur);+ *processedSize += cur;+ buf = (void *)((Byte *)buf + cur);+ size -= cur;+ if (res != SZ_OK)+ return res;+ if (cur == 0)+ return SZ_OK;+ }+ return SZ_OK;+}++/*+SRes SeqInStream_Read2(ISeqInStreamPtr stream, void *buf, size_t size, SRes errorType)+{+ while (size != 0)+ {+ size_t processed = size;+ RINOK(ISeqInStream_Read(stream, buf, &processed))+ if (processed == 0)+ return errorType;+ buf = (void *)((Byte *)buf + processed);+ size -= processed;+ }+ return SZ_OK;+}++SRes SeqInStream_Read(ISeqInStreamPtr stream, void *buf, size_t size)+{+ return SeqInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);+}+*/+++SRes SeqInStream_ReadByte(ISeqInStreamPtr stream, Byte *buf)+{+ size_t processed = 1;+ RINOK(ISeqInStream_Read(stream, buf, &processed))+ return (processed == 1) ? SZ_OK : SZ_ERROR_INPUT_EOF;+}++++SRes LookInStream_SeekTo(ILookInStreamPtr stream, UInt64 offset)+{+ Int64 t = (Int64)offset;+ return ILookInStream_Seek(stream, &t, SZ_SEEK_SET);+}++SRes LookInStream_LookRead(ILookInStreamPtr stream, void *buf, size_t *size)+{+ const void *lookBuf;+ if (*size == 0)+ return SZ_OK;+ RINOK(ILookInStream_Look(stream, &lookBuf, size))+ memcpy(buf, lookBuf, *size);+ return ILookInStream_Skip(stream, *size);+}++SRes LookInStream_Read2(ILookInStreamPtr stream, void *buf, size_t size, SRes errorType)+{+ while (size != 0)+ {+ size_t processed = size;+ RINOK(ILookInStream_Read(stream, buf, &processed))+ if (processed == 0)+ return errorType;+ buf = (void *)((Byte *)buf + processed);+ size -= processed;+ }+ return SZ_OK;+}++SRes LookInStream_Read(ILookInStreamPtr stream, void *buf, size_t size)+{+ return LookInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);+}++++#define GET_LookToRead2 Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CLookToRead2)++static SRes LookToRead2_Look_Lookahead(ILookInStreamPtr pp, const void **buf, size_t *size)+{+ SRes res = SZ_OK;+ GET_LookToRead2+ size_t size2 = p->size - p->pos;+ if (size2 == 0 && *size != 0)+ {+ p->pos = 0;+ p->size = 0;+ size2 = p->bufSize;+ res = ISeekInStream_Read(p->realStream, p->buf, &size2);+ p->size = size2;+ }+ if (*size > size2)+ *size = size2;+ *buf = p->buf + p->pos;+ return res;+}++static SRes LookToRead2_Look_Exact(ILookInStreamPtr pp, const void **buf, size_t *size)+{+ SRes res = SZ_OK;+ GET_LookToRead2+ size_t size2 = p->size - p->pos;+ if (size2 == 0 && *size != 0)+ {+ p->pos = 0;+ p->size = 0;+ if (*size > p->bufSize)+ *size = p->bufSize;+ res = ISeekInStream_Read(p->realStream, p->buf, size);+ size2 = p->size = *size;+ }+ if (*size > size2)+ *size = size2;+ *buf = p->buf + p->pos;+ return res;+}++static SRes LookToRead2_Skip(ILookInStreamPtr pp, size_t offset)+{+ GET_LookToRead2+ p->pos += offset;+ return SZ_OK;+}++static SRes LookToRead2_Read(ILookInStreamPtr pp, void *buf, size_t *size)+{+ GET_LookToRead2+ size_t rem = p->size - p->pos;+ if (rem == 0)+ return ISeekInStream_Read(p->realStream, buf, size);+ if (rem > *size)+ rem = *size;+ memcpy(buf, p->buf + p->pos, rem);+ p->pos += rem;+ *size = rem;+ return SZ_OK;+}++static SRes LookToRead2_Seek(ILookInStreamPtr pp, Int64 *pos, ESzSeek origin)+{+ GET_LookToRead2+ p->pos = p->size = 0;+ return ISeekInStream_Seek(p->realStream, pos, origin);+}++void LookToRead2_CreateVTable(CLookToRead2 *p, int lookahead)+{+ p->vt.Look = lookahead ?+ LookToRead2_Look_Lookahead :+ LookToRead2_Look_Exact;+ p->vt.Skip = LookToRead2_Skip;+ p->vt.Read = LookToRead2_Read;+ p->vt.Seek = LookToRead2_Seek;+}++++static SRes SecToLook_Read(ISeqInStreamPtr pp, void *buf, size_t *size)+{+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSecToLook)+ return LookInStream_LookRead(p->realStream, buf, size);+}++void SecToLook_CreateVTable(CSecToLook *p)+{+ p->vt.Read = SecToLook_Read;+}++static SRes SecToRead_Read(ISeqInStreamPtr pp, void *buf, size_t *size)+{+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSecToRead)+ return ILookInStream_Read(p->realStream, buf, size);+}++void SecToRead_CreateVTable(CSecToRead *p)+{+ p->vt.Read = SecToRead_Read;+}
@@ -0,0 +1,597 @@+/* 7zTypes.h -- Basic types+2023-04-02 : Igor Pavlov : Public domain */++#ifndef ZIP7_7Z_TYPES_H+#define ZIP7_7Z_TYPES_H++#ifdef _WIN32+/* #include <windows.h> */+#else+#include <errno.h>+#endif++#include <stddef.h>++#ifndef EXTERN_C_BEGIN+#ifdef __cplusplus+#define EXTERN_C_BEGIN extern "C" {+#define EXTERN_C_END }+#else+#define EXTERN_C_BEGIN+#define EXTERN_C_END+#endif+#endif++EXTERN_C_BEGIN++#define SZ_OK 0++#define SZ_ERROR_DATA 1+#define SZ_ERROR_MEM 2+#define SZ_ERROR_CRC 3+#define SZ_ERROR_UNSUPPORTED 4+#define SZ_ERROR_PARAM 5+#define SZ_ERROR_INPUT_EOF 6+#define SZ_ERROR_OUTPUT_EOF 7+#define SZ_ERROR_READ 8+#define SZ_ERROR_WRITE 9+#define SZ_ERROR_PROGRESS 10+#define SZ_ERROR_FAIL 11+#define SZ_ERROR_THREAD 12++#define SZ_ERROR_ARCHIVE 16+#define SZ_ERROR_NO_ARCHIVE 17++typedef int SRes;+++#ifdef _MSC_VER+ #if _MSC_VER > 1200+ #define MY_ALIGN(n) __declspec(align(n))+ #else+ #define MY_ALIGN(n)+ #endif+#else+ /*+ // C11/C++11:+ #include <stdalign.h>+ #define MY_ALIGN(n) alignas(n)+ */+ #define MY_ALIGN(n) __attribute__ ((aligned(n)))+#endif+++#ifdef _WIN32++/* typedef DWORD WRes; */+typedef unsigned WRes;+#define MY_SRes_HRESULT_FROM_WRes(x) HRESULT_FROM_WIN32(x)++// #define MY_HRES_ERROR_INTERNAL_ERROR MY_SRes_HRESULT_FROM_WRes(ERROR_INTERNAL_ERROR)++#else // _WIN32++// #define ENV_HAVE_LSTAT+typedef int WRes;++// (FACILITY_ERRNO = 0x800) is 7zip's FACILITY constant to represent (errno) errors in HRESULT+#define MY_FACILITY_ERRNO 0x800+#define MY_FACILITY_WIN32 7+#define MY_FACILITY_WRes MY_FACILITY_ERRNO++#define MY_HRESULT_FROM_errno_CONST_ERROR(x) ((HRESULT)( \+ ( (HRESULT)(x) & 0x0000FFFF) \+ | (MY_FACILITY_WRes << 16) \+ | (HRESULT)0x80000000 ))++#define MY_SRes_HRESULT_FROM_WRes(x) \+ ((HRESULT)(x) <= 0 ? ((HRESULT)(x)) : MY_HRESULT_FROM_errno_CONST_ERROR(x))++// we call macro HRESULT_FROM_WIN32 for system errors (WRes) that are (errno)+#define HRESULT_FROM_WIN32(x) MY_SRes_HRESULT_FROM_WRes(x)++/*+#define ERROR_FILE_NOT_FOUND 2L+#define ERROR_ACCESS_DENIED 5L+#define ERROR_NO_MORE_FILES 18L+#define ERROR_LOCK_VIOLATION 33L+#define ERROR_FILE_EXISTS 80L+#define ERROR_DISK_FULL 112L+#define ERROR_NEGATIVE_SEEK 131L+#define ERROR_ALREADY_EXISTS 183L+#define ERROR_DIRECTORY 267L+#define ERROR_TOO_MANY_POSTS 298L++#define ERROR_INTERNAL_ERROR 1359L+#define ERROR_INVALID_REPARSE_DATA 4392L+#define ERROR_REPARSE_TAG_INVALID 4393L+#define ERROR_REPARSE_TAG_MISMATCH 4394L+*/++// we use errno equivalents for some WIN32 errors:++#define ERROR_INVALID_PARAMETER EINVAL+#define ERROR_INVALID_FUNCTION EINVAL+#define ERROR_ALREADY_EXISTS EEXIST+#define ERROR_FILE_EXISTS EEXIST+#define ERROR_PATH_NOT_FOUND ENOENT+#define ERROR_FILE_NOT_FOUND ENOENT+#define ERROR_DISK_FULL ENOSPC+// #define ERROR_INVALID_HANDLE EBADF++// we use FACILITY_WIN32 for errors that has no errno equivalent+// Too many posts were made to a semaphore.+#define ERROR_TOO_MANY_POSTS ((HRESULT)0x8007012AL)+#define ERROR_INVALID_REPARSE_DATA ((HRESULT)0x80071128L)+#define ERROR_REPARSE_TAG_INVALID ((HRESULT)0x80071129L)++// if (MY_FACILITY_WRes != FACILITY_WIN32),+// we use FACILITY_WIN32 for COM errors:+#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)+#define E_INVALIDARG ((HRESULT)0x80070057L)+#define MY_E_ERROR_NEGATIVE_SEEK ((HRESULT)0x80070083L)++/*+// we can use FACILITY_ERRNO for some COM errors, that have errno equivalents:+#define E_OUTOFMEMORY MY_HRESULT_FROM_errno_CONST_ERROR(ENOMEM)+#define E_INVALIDARG MY_HRESULT_FROM_errno_CONST_ERROR(EINVAL)+#define MY_E_ERROR_NEGATIVE_SEEK MY_HRESULT_FROM_errno_CONST_ERROR(EINVAL)+*/++#define TEXT(quote) quote++#define FILE_ATTRIBUTE_READONLY 0x0001+#define FILE_ATTRIBUTE_HIDDEN 0x0002+#define FILE_ATTRIBUTE_SYSTEM 0x0004+#define FILE_ATTRIBUTE_DIRECTORY 0x0010+#define FILE_ATTRIBUTE_ARCHIVE 0x0020+#define FILE_ATTRIBUTE_DEVICE 0x0040+#define FILE_ATTRIBUTE_NORMAL 0x0080+#define FILE_ATTRIBUTE_TEMPORARY 0x0100+#define FILE_ATTRIBUTE_SPARSE_FILE 0x0200+#define FILE_ATTRIBUTE_REPARSE_POINT 0x0400+#define FILE_ATTRIBUTE_COMPRESSED 0x0800+#define FILE_ATTRIBUTE_OFFLINE 0x1000+#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x2000+#define FILE_ATTRIBUTE_ENCRYPTED 0x4000++#define FILE_ATTRIBUTE_UNIX_EXTENSION 0x8000 /* trick for Unix */++#endif+++#ifndef RINOK+#define RINOK(x) { const int _result_ = (x); if (_result_ != 0) return _result_; }+#endif++#ifndef RINOK_WRes+#define RINOK_WRes(x) { const WRes _result_ = (x); if (_result_ != 0) return _result_; }+#endif++typedef unsigned char Byte;+typedef short Int16;+typedef unsigned short UInt16;++#ifdef Z7_DECL_Int32_AS_long+typedef long Int32;+typedef unsigned long UInt32;+#else+typedef int Int32;+typedef unsigned int UInt32;+#endif+++#ifndef _WIN32++typedef int INT;+typedef Int32 INT32;+typedef unsigned int UINT;+typedef UInt32 UINT32;+typedef INT32 LONG; // LONG, ULONG and DWORD must be 32-bit for _WIN32 compatibility+typedef UINT32 ULONG;++#undef DWORD+typedef UINT32 DWORD;++#define VOID void++#define HRESULT LONG++typedef void *LPVOID;+// typedef void VOID;+// typedef ULONG_PTR DWORD_PTR, *PDWORD_PTR;+// gcc / clang on Unix : sizeof(long==sizeof(void*) in 32 or 64 bits)+typedef long INT_PTR;+typedef unsigned long UINT_PTR;+typedef long LONG_PTR;+typedef unsigned long DWORD_PTR;++typedef size_t SIZE_T;++#endif // _WIN32+++#define MY_HRES_ERROR_INTERNAL_ERROR ((HRESULT)0x8007054FL)+++#ifdef Z7_DECL_Int64_AS_long++typedef long Int64;+typedef unsigned long UInt64;++#else++#if (defined(_MSC_VER) || defined(__BORLANDC__)) && !defined(__clang__)+typedef __int64 Int64;+typedef unsigned __int64 UInt64;+#else+#if defined(__clang__) || defined(__GNUC__)+#include <stdint.h>+typedef int64_t Int64;+typedef uint64_t UInt64;+#else+typedef long long int Int64;+typedef unsigned long long int UInt64;+// #define UINT64_CONST(n) n ## ULL+#endif+#endif++#endif++#define UINT64_CONST(n) n+++#ifdef Z7_DECL_SizeT_AS_unsigned_int+typedef unsigned int SizeT;+#else+typedef size_t SizeT;+#endif++/*+#if (defined(_MSC_VER) && _MSC_VER <= 1200)+typedef size_t MY_uintptr_t;+#else+#include <stdint.h>+typedef uintptr_t MY_uintptr_t;+#endif+*/++typedef int BoolInt;+/* typedef BoolInt Bool; */+#define True 1+#define False 0+++#ifdef _WIN32+#define Z7_STDCALL __stdcall+#else+#define Z7_STDCALL+#endif++#ifdef _MSC_VER++#if _MSC_VER >= 1300+#define Z7_NO_INLINE __declspec(noinline)+#else+#define Z7_NO_INLINE+#endif++#define Z7_FORCE_INLINE __forceinline++#define Z7_CDECL __cdecl+#define Z7_FASTCALL __fastcall++#else // _MSC_VER++#if (defined(__GNUC__) && (__GNUC__ >= 4)) \+ || (defined(__clang__) && (__clang_major__ >= 4)) \+ || defined(__INTEL_COMPILER) \+ || defined(__xlC__)+#define Z7_NO_INLINE __attribute__((noinline))+#define Z7_FORCE_INLINE __attribute__((always_inline)) inline+#else+#define Z7_NO_INLINE+#define Z7_FORCE_INLINE+#endif++#define Z7_CDECL++#if defined(_M_IX86) \+ || defined(__i386__)+// #define Z7_FASTCALL __attribute__((fastcall))+// #define Z7_FASTCALL __attribute__((cdecl))+#define Z7_FASTCALL+#elif defined(MY_CPU_AMD64)+// #define Z7_FASTCALL __attribute__((ms_abi))+#define Z7_FASTCALL+#else+#define Z7_FASTCALL+#endif++#endif // _MSC_VER+++/* The following interfaces use first parameter as pointer to structure */++// #define Z7_C_IFACE_CONST_QUAL+#define Z7_C_IFACE_CONST_QUAL const++#define Z7_C_IFACE_DECL(a) \+ struct a ## _; \+ typedef Z7_C_IFACE_CONST_QUAL struct a ## _ * a ## Ptr; \+ typedef struct a ## _ a; \+ struct a ## _+++Z7_C_IFACE_DECL (IByteIn)+{+ Byte (*Read)(IByteInPtr p); /* reads one byte, returns 0 in case of EOF or error */+};+#define IByteIn_Read(p) (p)->Read(p)+++Z7_C_IFACE_DECL (IByteOut)+{+ void (*Write)(IByteOutPtr p, Byte b);+};+#define IByteOut_Write(p, b) (p)->Write(p, b)+++Z7_C_IFACE_DECL (ISeqInStream)+{+ SRes (*Read)(ISeqInStreamPtr p, void *buf, size_t *size);+ /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.+ (output(*size) < input(*size)) is allowed */+};+#define ISeqInStream_Read(p, buf, size) (p)->Read(p, buf, size)++/* try to read as much as avail in stream and limited by (*processedSize) */+SRes SeqInStream_ReadMax(ISeqInStreamPtr stream, void *buf, size_t *processedSize);+/* it can return SZ_ERROR_INPUT_EOF */+// SRes SeqInStream_Read(ISeqInStreamPtr stream, void *buf, size_t size);+// SRes SeqInStream_Read2(ISeqInStreamPtr stream, void *buf, size_t size, SRes errorType);+SRes SeqInStream_ReadByte(ISeqInStreamPtr stream, Byte *buf);+++Z7_C_IFACE_DECL (ISeqOutStream)+{+ size_t (*Write)(ISeqOutStreamPtr p, const void *buf, size_t size);+ /* Returns: result - the number of actually written bytes.+ (result < size) means error */+};+#define ISeqOutStream_Write(p, buf, size) (p)->Write(p, buf, size)++typedef enum+{+ SZ_SEEK_SET = 0,+ SZ_SEEK_CUR = 1,+ SZ_SEEK_END = 2+} ESzSeek;+++Z7_C_IFACE_DECL (ISeekInStream)+{+ SRes (*Read)(ISeekInStreamPtr p, void *buf, size_t *size); /* same as ISeqInStream::Read */+ SRes (*Seek)(ISeekInStreamPtr p, Int64 *pos, ESzSeek origin);+};+#define ISeekInStream_Read(p, buf, size) (p)->Read(p, buf, size)+#define ISeekInStream_Seek(p, pos, origin) (p)->Seek(p, pos, origin)+++Z7_C_IFACE_DECL (ILookInStream)+{+ SRes (*Look)(ILookInStreamPtr p, const void **buf, size_t *size);+ /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.+ (output(*size) > input(*size)) is not allowed+ (output(*size) < input(*size)) is allowed */+ SRes (*Skip)(ILookInStreamPtr p, size_t offset);+ /* offset must be <= output(*size) of Look */+ SRes (*Read)(ILookInStreamPtr p, void *buf, size_t *size);+ /* reads directly (without buffer). It's same as ISeqInStream::Read */+ SRes (*Seek)(ILookInStreamPtr p, Int64 *pos, ESzSeek origin);+};++#define ILookInStream_Look(p, buf, size) (p)->Look(p, buf, size)+#define ILookInStream_Skip(p, offset) (p)->Skip(p, offset)+#define ILookInStream_Read(p, buf, size) (p)->Read(p, buf, size)+#define ILookInStream_Seek(p, pos, origin) (p)->Seek(p, pos, origin)+++SRes LookInStream_LookRead(ILookInStreamPtr stream, void *buf, size_t *size);+SRes LookInStream_SeekTo(ILookInStreamPtr stream, UInt64 offset);++/* reads via ILookInStream::Read */+SRes LookInStream_Read2(ILookInStreamPtr stream, void *buf, size_t size, SRes errorType);+SRes LookInStream_Read(ILookInStreamPtr stream, void *buf, size_t size);+++typedef struct+{+ ILookInStream vt;+ ISeekInStreamPtr realStream;+ + size_t pos;+ size_t size; /* it's data size */+ + /* the following variables must be set outside */+ Byte *buf;+ size_t bufSize;+} CLookToRead2;++void LookToRead2_CreateVTable(CLookToRead2 *p, int lookahead);++#define LookToRead2_INIT(p) { (p)->pos = (p)->size = 0; }+++typedef struct+{+ ISeqInStream vt;+ ILookInStreamPtr realStream;+} CSecToLook;++void SecToLook_CreateVTable(CSecToLook *p);++++typedef struct+{+ ISeqInStream vt;+ ILookInStreamPtr realStream;+} CSecToRead;++void SecToRead_CreateVTable(CSecToRead *p);+++Z7_C_IFACE_DECL (ICompressProgress)+{+ SRes (*Progress)(ICompressProgressPtr p, UInt64 inSize, UInt64 outSize);+ /* Returns: result. (result != SZ_OK) means break.+ Value (UInt64)(Int64)-1 for size means unknown value. */+};++#define ICompressProgress_Progress(p, inSize, outSize) (p)->Progress(p, inSize, outSize)++++typedef struct ISzAlloc ISzAlloc;+typedef const ISzAlloc * ISzAllocPtr;++struct ISzAlloc+{+ void *(*Alloc)(ISzAllocPtr p, size_t size);+ void (*Free)(ISzAllocPtr p, void *address); /* address can be 0 */+};++#define ISzAlloc_Alloc(p, size) (p)->Alloc(p, size)+#define ISzAlloc_Free(p, a) (p)->Free(p, a)++/* deprecated */+#define IAlloc_Alloc(p, size) ISzAlloc_Alloc(p, size)+#define IAlloc_Free(p, a) ISzAlloc_Free(p, a)++++++#ifndef MY_offsetof+ #ifdef offsetof+ #define MY_offsetof(type, m) offsetof(type, m)+ /*+ #define MY_offsetof(type, m) FIELD_OFFSET(type, m)+ */+ #else+ #define MY_offsetof(type, m) ((size_t)&(((type *)0)->m))+ #endif+#endif++++#ifndef Z7_container_of++/*+#define Z7_container_of(ptr, type, m) container_of(ptr, type, m)+#define Z7_container_of(ptr, type, m) CONTAINING_RECORD(ptr, type, m)+#define Z7_container_of(ptr, type, m) ((type *)((char *)(ptr) - offsetof(type, m)))+#define Z7_container_of(ptr, type, m) (&((type *)0)->m == (ptr), ((type *)(((char *)(ptr)) - MY_offsetof(type, m))))+*/++/*+ GCC shows warning: "perhaps the 'offsetof' macro was used incorrectly"+ GCC 3.4.4 : classes with constructor+ GCC 4.8.1 : classes with non-public variable members"+*/++#define Z7_container_of(ptr, type, m) \+ ((type *)(void *)((char *)(void *) \+ (1 ? (ptr) : &((type *)NULL)->m) - MY_offsetof(type, m)))++#define Z7_container_of_CONST(ptr, type, m) \+ ((const type *)(const void *)((const char *)(const void *) \+ (1 ? (ptr) : &((type *)NULL)->m) - MY_offsetof(type, m)))++/*+#define Z7_container_of_NON_CONST_FROM_CONST(ptr, type, m) \+ ((type *)(void *)(const void *)((const char *)(const void *) \+ (1 ? (ptr) : &((type *)NULL)->m) - MY_offsetof(type, m)))+*/++#endif++#define Z7_CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m) ((type *)(void *)(ptr))++// #define Z7_CONTAINER_FROM_VTBL(ptr, type, m) Z7_CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)+#define Z7_CONTAINER_FROM_VTBL(ptr, type, m) Z7_container_of(ptr, type, m)+// #define Z7_CONTAINER_FROM_VTBL(ptr, type, m) Z7_container_of_NON_CONST_FROM_CONST(ptr, type, m)++#define Z7_CONTAINER_FROM_VTBL_CONST(ptr, type, m) Z7_container_of_CONST(ptr, type, m)++#define Z7_CONTAINER_FROM_VTBL_CLS(ptr, type, m) Z7_CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)+/*+#define Z7_CONTAINER_FROM_VTBL_CLS(ptr, type, m) Z7_CONTAINER_FROM_VTBL(ptr, type, m)+*/+#if defined (__clang__) || defined(__GNUC__)+#define Z7_DIAGNOSCTIC_IGNORE_BEGIN_CAST_QUAL \+ _Pragma("GCC diagnostic push") \+ _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")+#define Z7_DIAGNOSCTIC_IGNORE_END_CAST_QUAL \+ _Pragma("GCC diagnostic pop")+#else+#define Z7_DIAGNOSCTIC_IGNORE_BEGIN_CAST_QUAL+#define Z7_DIAGNOSCTIC_IGNORE_END_CAST_QUAL+#endif++#define Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR(ptr, type, m, p) \+ Z7_DIAGNOSCTIC_IGNORE_BEGIN_CAST_QUAL \+ type *p = Z7_CONTAINER_FROM_VTBL(ptr, type, m); \+ Z7_DIAGNOSCTIC_IGNORE_END_CAST_QUAL++#define Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(type) \+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR(pp, type, vt, p)+++// #define ZIP7_DECLARE_HANDLE(name) typedef void *name;+#define Z7_DECLARE_HANDLE(name) struct name##_dummy{int unused;}; typedef struct name##_dummy *name;+++#define Z7_memset_0_ARRAY(a) memset((a), 0, sizeof(a))++#ifndef Z7_ARRAY_SIZE+#define Z7_ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))+#endif+++#ifdef _WIN32++#define CHAR_PATH_SEPARATOR '\\'+#define WCHAR_PATH_SEPARATOR L'\\'+#define STRING_PATH_SEPARATOR "\\"+#define WSTRING_PATH_SEPARATOR L"\\"++#else++#define CHAR_PATH_SEPARATOR '/'+#define WCHAR_PATH_SEPARATOR L'/'+#define STRING_PATH_SEPARATOR "/"+#define WSTRING_PATH_SEPARATOR L"/"++#endif++#define k_PropVar_TimePrec_0 0+#define k_PropVar_TimePrec_Unix 1+#define k_PropVar_TimePrec_DOS 2+#define k_PropVar_TimePrec_HighPrec 3+#define k_PropVar_TimePrec_Base 16+#define k_PropVar_TimePrec_100ns (k_PropVar_TimePrec_Base + 7)+#define k_PropVar_TimePrec_1ns (k_PropVar_TimePrec_Base + 9)++EXTERN_C_END++#endif++/*+#ifndef Z7_ST+#ifdef _7ZIP_ST+#define Z7_ST+#endif+#endif+*/
@@ -0,0 +1,101 @@+/* 7zWindows.h -- StdAfx+2023-04-02 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_7Z_WINDOWS_H+#define ZIP7_INC_7Z_WINDOWS_H++#ifdef _WIN32++#if defined(__clang__)+# pragma clang diagnostic push+#endif++#if defined(_MSC_VER)++#pragma warning(push)+#pragma warning(disable : 4668) // '_WIN32_WINNT' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'++#if _MSC_VER == 1900+// for old kit10 versions+// #pragma warning(disable : 4255) // winuser.h(13979): warning C4255: 'GetThreadDpiAwarenessContext':+#endif+// win10 Windows Kit:+#endif // _MSC_VER++#if defined(_MSC_VER) && _MSC_VER <= 1200 && !defined(_WIN64)+// for msvc6 without sdk2003+#define RPC_NO_WINDOWS_H+#endif++#if defined(__MINGW32__) || defined(__MINGW64__)+// #if defined(__GNUC__) && !defined(__clang__)+#include <windows.h>+#else+#include <Windows.h>+#endif+// #include <basetsd.h>+// #include <wtypes.h>++// but if precompiled with clang-cl then we need+// #include <windows.h>+#if defined(_MSC_VER)+#pragma warning(pop)+#endif++#if defined(__clang__)+# pragma clang diagnostic pop+#endif++#if defined(_MSC_VER) && _MSC_VER <= 1200 && !defined(_WIN64)+#ifndef _W64++typedef long LONG_PTR, *PLONG_PTR;+typedef unsigned long ULONG_PTR, *PULONG_PTR;+typedef ULONG_PTR DWORD_PTR, *PDWORD_PTR;++#define Z7_OLD_WIN_SDK+#endif // _W64+#endif // _MSC_VER == 1200++#ifdef Z7_OLD_WIN_SDK++#ifndef INVALID_FILE_ATTRIBUTES+#define INVALID_FILE_ATTRIBUTES ((DWORD)-1)+#endif+#ifndef INVALID_SET_FILE_POINTER+#define INVALID_SET_FILE_POINTER ((DWORD)-1)+#endif+#ifndef FILE_SPECIAL_ACCESS+#define FILE_SPECIAL_ACCESS (FILE_ANY_ACCESS)+#endif++// ShlObj.h:+// #define BIF_NEWDIALOGSTYLE 0x0040++#pragma warning(disable : 4201)+// #pragma warning(disable : 4115)++#undef VARIANT_TRUE+#define VARIANT_TRUE ((VARIANT_BOOL)-1)+#endif++#endif // Z7_OLD_WIN_SDK++#ifdef UNDER_CE+#undef VARIANT_TRUE+#define VARIANT_TRUE ((VARIANT_BOOL)-1)+#endif+++#if defined(_MSC_VER)+#if _MSC_VER >= 1400 && _MSC_VER <= 1600+ // BaseTsd.h(148) : 'HandleToULong' : unreferenced inline function has been removed+ // string.h+ // #pragma warning(disable : 4514)+#endif+#endif+++/* #include "7zTypes.h" */++#endif
@@ -0,0 +1,290 @@+/* Bcj2.c -- BCJ2 Decoder (Converter for x86 code)+2023-03-01 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include "Bcj2.h"+#include "CpuArch.h"++#define kTopValue ((UInt32)1 << 24)+#define kNumBitModelTotalBits 11+#define kBitModelTotal (1 << kNumBitModelTotalBits)+#define kNumMoveBits 5++// UInt32 bcj2_stats[256 + 2][2];++void Bcj2Dec_Init(CBcj2Dec *p)+{+ unsigned i;+ p->state = BCJ2_STREAM_RC; // BCJ2_DEC_STATE_OK;+ p->ip = 0;+ p->temp = 0;+ p->range = 0;+ p->code = 0;+ for (i = 0; i < sizeof(p->probs) / sizeof(p->probs[0]); i++)+ p->probs[i] = kBitModelTotal >> 1;+}++SRes Bcj2Dec_Decode(CBcj2Dec *p)+{+ UInt32 v = p->temp;+ // const Byte *src;+ if (p->range <= 5)+ {+ UInt32 code = p->code;+ p->state = BCJ2_DEC_STATE_ERROR; /* for case if we return SZ_ERROR_DATA; */+ for (; p->range != 5; p->range++)+ {+ if (p->range == 1 && code != 0)+ return SZ_ERROR_DATA;+ if (p->bufs[BCJ2_STREAM_RC] == p->lims[BCJ2_STREAM_RC])+ {+ p->state = BCJ2_STREAM_RC;+ return SZ_OK;+ }+ code = (code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;+ p->code = code;+ }+ if (code == 0xffffffff)+ return SZ_ERROR_DATA;+ p->range = 0xffffffff;+ }+ // else+ {+ unsigned state = p->state;+ // we check BCJ2_IS_32BIT_STREAM() here instead of check in the main loop+ if (BCJ2_IS_32BIT_STREAM(state))+ {+ const Byte *cur = p->bufs[state];+ if (cur == p->lims[state])+ return SZ_OK;+ p->bufs[state] = cur + 4;+ {+ const UInt32 ip = p->ip + 4;+ v = GetBe32a(cur) - ip;+ p->ip = ip;+ }+ state = BCJ2_DEC_STATE_ORIG_0;+ }+ if ((unsigned)(state - BCJ2_DEC_STATE_ORIG_0) < 4)+ {+ Byte *dest = p->dest;+ for (;;)+ {+ if (dest == p->destLim)+ {+ p->state = state;+ p->temp = v;+ return SZ_OK;+ }+ *dest++ = (Byte)v;+ p->dest = dest;+ if (++state == BCJ2_DEC_STATE_ORIG_3 + 1)+ break;+ v >>= 8;+ }+ }+ }++ // src = p->bufs[BCJ2_STREAM_MAIN];+ for (;;)+ {+ /*+ if (BCJ2_IS_32BIT_STREAM(p->state))+ p->state = BCJ2_DEC_STATE_OK;+ else+ */+ {+ if (p->range < kTopValue)+ {+ if (p->bufs[BCJ2_STREAM_RC] == p->lims[BCJ2_STREAM_RC])+ {+ p->state = BCJ2_STREAM_RC;+ p->temp = v;+ return SZ_OK;+ }+ p->range <<= 8;+ p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;+ }+ {+ const Byte *src = p->bufs[BCJ2_STREAM_MAIN];+ const Byte *srcLim;+ Byte *dest = p->dest;+ {+ const SizeT rem = (SizeT)(p->lims[BCJ2_STREAM_MAIN] - src);+ SizeT num = (SizeT)(p->destLim - dest);+ if (num >= rem)+ num = rem;+ #define NUM_ITERS 4+ #if (NUM_ITERS & (NUM_ITERS - 1)) == 0+ num &= ~((SizeT)NUM_ITERS - 1); // if (NUM_ITERS == (1 << x))+ #else+ num -= num % NUM_ITERS; // if (NUM_ITERS != (1 << x))+ #endif+ srcLim = src + num;+ }++ #define NUM_SHIFT_BITS 24+ #define ONE_ITER(indx) { \+ const unsigned b = src[indx]; \+ *dest++ = (Byte)b; \+ v = (v << NUM_SHIFT_BITS) | b; \+ if (((b + (0x100 - 0xe8)) & 0xfe) == 0) break; \+ if (((v - (((UInt32)0x0f << (NUM_SHIFT_BITS)) + 0x80)) & \+ ((((UInt32)1 << (4 + NUM_SHIFT_BITS)) - 0x1) << 4)) == 0) break; \+ /* ++dest */; /* v = b; */ }+ + if (src != srcLim)+ for (;;)+ {+ /* The dependency chain of 2-cycle for (v) calculation is not big problem here.+ But we can remove dependency chain with v = b in the end of loop. */+ ONE_ITER(0)+ #if (NUM_ITERS > 1)+ ONE_ITER(1)+ #if (NUM_ITERS > 2)+ ONE_ITER(2)+ #if (NUM_ITERS > 3)+ ONE_ITER(3)+ #if (NUM_ITERS > 4)+ ONE_ITER(4)+ #if (NUM_ITERS > 5)+ ONE_ITER(5)+ #if (NUM_ITERS > 6)+ ONE_ITER(6)+ #if (NUM_ITERS > 7)+ ONE_ITER(7)+ #endif+ #endif+ #endif+ #endif+ #endif+ #endif+ #endif+ + src += NUM_ITERS;+ if (src == srcLim)+ break;+ }++ if (src == srcLim)+ #if (NUM_ITERS > 1)+ for (;;)+ #endif+ {+ #if (NUM_ITERS > 1)+ if (src == p->lims[BCJ2_STREAM_MAIN] || dest == p->destLim)+ #endif+ {+ const SizeT num = (SizeT)(src - p->bufs[BCJ2_STREAM_MAIN]);+ p->bufs[BCJ2_STREAM_MAIN] = src;+ p->dest = dest;+ p->ip += (UInt32)num;+ /* state BCJ2_STREAM_MAIN has more priority than BCJ2_STATE_ORIG */+ p->state =+ src == p->lims[BCJ2_STREAM_MAIN] ?+ (unsigned)BCJ2_STREAM_MAIN :+ (unsigned)BCJ2_DEC_STATE_ORIG;+ p->temp = v;+ return SZ_OK;+ }+ #if (NUM_ITERS > 1)+ ONE_ITER(0)+ src++;+ #endif+ }++ {+ const SizeT num = (SizeT)(dest - p->dest);+ p->dest = dest; // p->dest += num;+ p->bufs[BCJ2_STREAM_MAIN] += num; // = src;+ p->ip += (UInt32)num;+ }+ {+ UInt32 bound, ttt;+ CBcj2Prob *prob; // unsigned index;+ /*+ prob = p->probs + (unsigned)((Byte)v == 0xe8 ?+ 2 + (Byte)(v >> 8) :+ ((v >> 5) & 1)); // ((Byte)v < 0xe8 ? 0 : 1));+ */+ {+ const unsigned c = ((v + 0x17) >> 6) & 1;+ prob = p->probs + (unsigned)+ (((0 - c) & (Byte)(v >> NUM_SHIFT_BITS)) + c + ((v >> 5) & 1));+ // (Byte)+ // 8x->0 : e9->1 : xxe8->xx+2+ // 8x->0x100 : e9->0x101 : xxe8->xx+ // (((0x100 - (e & ~v)) & (0x100 | (v >> 8))) + (e & v));+ // (((0x101 + (~e | v)) & (0x100 | (v >> 8))) + (e & v));+ }+ ttt = *prob;+ bound = (p->range >> kNumBitModelTotalBits) * ttt;+ if (p->code < bound)+ {+ // bcj2_stats[prob - p->probs][0]++;+ p->range = bound;+ *prob = (CBcj2Prob)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));+ continue;+ }+ {+ // bcj2_stats[prob - p->probs][1]++;+ p->range -= bound;+ p->code -= bound;+ *prob = (CBcj2Prob)(ttt - (ttt >> kNumMoveBits));+ }+ }+ }+ }+ {+ /* (v == 0xe8 ? 0 : 1) uses setcc instruction with additional zero register usage in x64 MSVC. */+ // const unsigned cj = ((Byte)v == 0xe8) ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP;+ const unsigned cj = (((v + 0x57) >> 6) & 1) + BCJ2_STREAM_CALL;+ const Byte *cur = p->bufs[cj];+ Byte *dest;+ SizeT rem;+ if (cur == p->lims[cj])+ {+ p->state = cj;+ break;+ }+ v = GetBe32a(cur);+ p->bufs[cj] = cur + 4;+ {+ const UInt32 ip = p->ip + 4;+ v -= ip;+ p->ip = ip;+ }+ dest = p->dest;+ rem = (SizeT)(p->destLim - dest);+ if (rem < 4)+ {+ if ((unsigned)rem > 0) { dest[0] = (Byte)v; v >>= 8;+ if ((unsigned)rem > 1) { dest[1] = (Byte)v; v >>= 8;+ if ((unsigned)rem > 2) { dest[2] = (Byte)v; v >>= 8; }}}+ p->temp = v;+ p->dest = dest + rem;+ p->state = BCJ2_DEC_STATE_ORIG_0 + (unsigned)rem;+ break;+ }+ SetUi32(dest, v)+ v >>= 24;+ p->dest = dest + 4;+ }+ }++ if (p->range < kTopValue && p->bufs[BCJ2_STREAM_RC] != p->lims[BCJ2_STREAM_RC])+ {+ p->range <<= 8;+ p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;+ }+ return SZ_OK;+}++#undef NUM_ITERS+#undef ONE_ITER+#undef NUM_SHIFT_BITS+#undef kTopValue+#undef kNumBitModelTotalBits+#undef kBitModelTotal+#undef kNumMoveBits
@@ -0,0 +1,332 @@+/* Bcj2.h -- BCJ2 converter for x86 code (Branch CALL/JUMP variant2)+2023-03-02 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_BCJ2_H+#define ZIP7_INC_BCJ2_H++#include "7zTypes.h"++EXTERN_C_BEGIN++#define BCJ2_NUM_STREAMS 4++enum+{+ BCJ2_STREAM_MAIN,+ BCJ2_STREAM_CALL,+ BCJ2_STREAM_JUMP,+ BCJ2_STREAM_RC+};++enum+{+ BCJ2_DEC_STATE_ORIG_0 = BCJ2_NUM_STREAMS,+ BCJ2_DEC_STATE_ORIG_1,+ BCJ2_DEC_STATE_ORIG_2,+ BCJ2_DEC_STATE_ORIG_3,+ + BCJ2_DEC_STATE_ORIG,+ BCJ2_DEC_STATE_ERROR /* after detected data error */+};++enum+{+ BCJ2_ENC_STATE_ORIG = BCJ2_NUM_STREAMS,+ BCJ2_ENC_STATE_FINISHED /* it's state after fully encoded stream */+};+++/* #define BCJ2_IS_32BIT_STREAM(s) ((s) == BCJ2_STREAM_CALL || (s) == BCJ2_STREAM_JUMP) */+#define BCJ2_IS_32BIT_STREAM(s) ((unsigned)((unsigned)(s) - (unsigned)BCJ2_STREAM_CALL) < 2)++/*+CBcj2Dec / CBcj2Enc+bufs sizes:+ BUF_SIZE(n) = lims[n] - bufs[n]+bufs sizes for BCJ2_STREAM_CALL and BCJ2_STREAM_JUMP must be multiply of 4:+ (BUF_SIZE(BCJ2_STREAM_CALL) & 3) == 0+ (BUF_SIZE(BCJ2_STREAM_JUMP) & 3) == 0+*/++// typedef UInt32 CBcj2Prob;+typedef UInt16 CBcj2Prob;++/*+BCJ2 encoder / decoder internal requirements:+ - If last bytes of stream contain marker (e8/e8/0f8x), then+ there is also encoded symbol (0 : no conversion) in RC stream.+ - One case of overlapped instructions is supported,+ if last byte of converted instruction is (0f) and next byte is (8x):+ marker [xx xx xx 0f] 8x+ then the pair (0f 8x) is treated as marker.+*/++/* ---------- BCJ2 Decoder ---------- */++/*+CBcj2Dec:+(dest) is allowed to overlap with bufs[BCJ2_STREAM_MAIN], with the following conditions:+ bufs[BCJ2_STREAM_MAIN] >= dest &&+ bufs[BCJ2_STREAM_MAIN] - dest >=+ BUF_SIZE(BCJ2_STREAM_CALL) ++ BUF_SIZE(BCJ2_STREAM_JUMP)+ reserve = bufs[BCJ2_STREAM_MAIN] - dest -+ ( BUF_SIZE(BCJ2_STREAM_CALL) ++ BUF_SIZE(BCJ2_STREAM_JUMP) )+ and additional conditions:+ if (it's first call of Bcj2Dec_Decode() after Bcj2Dec_Init())+ {+ (reserve != 1) : if (ver < v23.00)+ }+ else // if there are more than one calls of Bcj2Dec_Decode() after Bcj2Dec_Init())+ {+ (reserve >= 6) : if (ver < v23.00)+ (reserve >= 4) : if (ver >= v23.00)+ We need that (reserve) because after first call of Bcj2Dec_Decode(),+ CBcj2Dec::temp can contain up to 4 bytes for writing to (dest).+ }+ (reserve == 0) is allowed, if we decode full stream via single call of Bcj2Dec_Decode().+ (reserve == 0) also is allowed in case of multi-call, if we use fixed buffers,+ and (reserve) is calculated from full (final) sizes of all streams before first call.+*/++typedef struct+{+ const Byte *bufs[BCJ2_NUM_STREAMS];+ const Byte *lims[BCJ2_NUM_STREAMS];+ Byte *dest;+ const Byte *destLim;++ unsigned state; /* BCJ2_STREAM_MAIN has more priority than BCJ2_STATE_ORIG */++ UInt32 ip; /* property of starting base for decoding */+ UInt32 temp; /* Byte temp[4]; */+ UInt32 range;+ UInt32 code;+ CBcj2Prob probs[2 + 256];+} CBcj2Dec;+++/* Note:+ Bcj2Dec_Init() sets (CBcj2Dec::ip = 0)+ if (ip != 0) property is required, the caller must set CBcj2Dec::ip after Bcj2Dec_Init()+*/+void Bcj2Dec_Init(CBcj2Dec *p);+++/* Bcj2Dec_Decode():+ returns:+ SZ_OK+ SZ_ERROR_DATA : if data in 5 starting bytes of BCJ2_STREAM_RC stream are not correct+*/+SRes Bcj2Dec_Decode(CBcj2Dec *p);++/* To check that decoding was finished you can compare+ sizes of processed streams with sizes known from another sources.+ You must do at least one mandatory check from the two following options:+ - the check for size of processed output (ORIG) stream.+ - the check for size of processed input (MAIN) stream.+ additional optional checks:+ - the checks for processed sizes of all input streams (MAIN, CALL, JUMP, RC)+ - the checks Bcj2Dec_IsMaybeFinished*()+ also before actual decoding you can check that the+ following condition is met for stream sizes:+ ( size(ORIG) == size(MAIN) + size(CALL) + size(JUMP) )+*/++/* (state == BCJ2_STREAM_MAIN) means that decoder is ready for+ additional input data in BCJ2_STREAM_MAIN stream.+ Note that (state == BCJ2_STREAM_MAIN) is allowed for non-finished decoding.+*/+#define Bcj2Dec_IsMaybeFinished_state_MAIN(_p_) ((_p_)->state == BCJ2_STREAM_MAIN)++/* if the stream decoding was finished correctly, then range decoder+ part of CBcj2Dec also was finished, and then (CBcj2Dec::code == 0).+ Note that (CBcj2Dec::code == 0) is allowed for non-finished decoding.+*/+#define Bcj2Dec_IsMaybeFinished_code(_p_) ((_p_)->code == 0)++/* use Bcj2Dec_IsMaybeFinished() only as additional check+ after at least one mandatory check from the two following options:+ - the check for size of processed output (ORIG) stream.+ - the check for size of processed input (MAIN) stream.+*/+#define Bcj2Dec_IsMaybeFinished(_p_) ( \+ Bcj2Dec_IsMaybeFinished_state_MAIN(_p_) && \+ Bcj2Dec_IsMaybeFinished_code(_p_))++++/* ---------- BCJ2 Encoder ---------- */++typedef enum+{+ BCJ2_ENC_FINISH_MODE_CONTINUE,+ BCJ2_ENC_FINISH_MODE_END_BLOCK,+ BCJ2_ENC_FINISH_MODE_END_STREAM+} EBcj2Enc_FinishMode;++/*+ BCJ2_ENC_FINISH_MODE_CONTINUE:+ process non finished encoding.+ It notifies the encoder that additional further calls+ can provide more input data (src) than provided by current call.+ In that case the CBcj2Enc encoder still can move (src) pointer+ up to (srcLim), but CBcj2Enc encoder can store some of the last+ processed bytes (up to 4 bytes) from src to internal CBcj2Enc::temp[] buffer.+ at return:+ (CBcj2Enc::src will point to position that includes+ processed data and data copied to (temp[]) buffer)+ That data from (temp[]) buffer will be used in further calls.+ + BCJ2_ENC_FINISH_MODE_END_BLOCK:+ finish encoding of current block (ended at srcLim) without RC flushing.+ at return: if (CBcj2Enc::state == BCJ2_ENC_STATE_ORIG) &&+ CBcj2Enc::src == CBcj2Enc::srcLim)+ : it shows that block encoding was finished. And the encoder is+ ready for new (src) data or for stream finish operation.+ finished block means+ {+ CBcj2Enc has completed block encoding up to (srcLim).+ (1 + 4 bytes) or (2 + 4 bytes) CALL/JUMP cortages will+ not cross block boundary at (srcLim).+ temporary CBcj2Enc buffer for (ORIG) src data is empty.+ 3 output uncompressed streams (MAIN, CALL, JUMP) were flushed.+ RC stream was not flushed. And RC stream will cross block boundary.+ }+ Note: some possible implementation of BCJ2 encoder could+ write branch marker (e8/e8/0f8x) in one call of Bcj2Enc_Encode(),+ and it could calculate symbol for RC in another call of Bcj2Enc_Encode().+ BCJ2 encoder uses ip/fileIp/fileSize/relatLimit values to calculate RC symbol.+ And these CBcj2Enc variables can have different values in different Bcj2Enc_Encode() calls.+ So caller must finish each block with BCJ2_ENC_FINISH_MODE_END_BLOCK+ to ensure that RC symbol is calculated and written in proper block.+ + BCJ2_ENC_FINISH_MODE_END_STREAM+ finish encoding of stream (ended at srcLim) fully including RC flushing.+ at return: if (CBcj2Enc::state == BCJ2_ENC_STATE_FINISHED)+ : it shows that stream encoding was finished fully,+ and all output streams were flushed fully.+ also Bcj2Enc_IsFinished() can be called.+*/+++/*+ 32-bit relative offset in JUMP/CALL commands is+ - (mod 4 GiB) for 32-bit x86 code+ - signed Int32 for 64-bit x86-64 code+ BCJ2 encoder also does internal relative to absolute address conversions.+ And there are 2 possible ways to do it:+ before v23: we used 32-bit variables and (mod 4 GiB) conversion+ since v23: we use 64-bit variables and (signed Int32 offset) conversion.+ The absolute address condition for conversion in v23:+ ((UInt64)((Int64)ip64 - (Int64)fileIp64 + 5 + (Int32)offset) < (UInt64)fileSize64)+ note that if (fileSize64 > 2 GiB). there is difference between+ old (mod 4 GiB) way (v22) and new (signed Int32 offset) way (v23).+ And new (v23) way is more suitable to encode 64-bit x86-64 code for (fileSize64 > 2 GiB) cases.+*/++/*+// for old (v22) way for conversion:+typedef UInt32 CBcj2Enc_ip_unsigned;+typedef Int32 CBcj2Enc_ip_signed;+#define BCJ2_ENC_FileSize_MAX ((UInt32)1 << 31)+*/+typedef UInt64 CBcj2Enc_ip_unsigned;+typedef Int64 CBcj2Enc_ip_signed;++/* maximum size of file that can be used for conversion condition */+#define BCJ2_ENC_FileSize_MAX ((CBcj2Enc_ip_unsigned)0 - 2)++/* default value of fileSize64_minus1 variable that means+ that absolute address limitation will not be used */+#define BCJ2_ENC_FileSizeField_UNLIMITED ((CBcj2Enc_ip_unsigned)0 - 1)++/* calculate value that later can be set to CBcj2Enc::fileSize64_minus1 */+#define BCJ2_ENC_GET_FileSizeField_VAL_FROM_FileSize(fileSize) \+ ((CBcj2Enc_ip_unsigned)(fileSize) - 1)++/* set CBcj2Enc::fileSize64_minus1 variable from size of file */+#define Bcj2Enc_SET_FileSize(p, fileSize) \+ (p)->fileSize64_minus1 = BCJ2_ENC_GET_FileSizeField_VAL_FROM_FileSize(fileSize);+++typedef struct+{+ Byte *bufs[BCJ2_NUM_STREAMS];+ const Byte *lims[BCJ2_NUM_STREAMS];+ const Byte *src;+ const Byte *srcLim;++ unsigned state;+ EBcj2Enc_FinishMode finishMode;++ Byte context;+ Byte flushRem;+ Byte isFlushState;++ Byte cache;+ UInt32 range;+ UInt64 low;+ UInt64 cacheSize;+ + // UInt32 context; // for marker version, it can include marker flag.++ /* (ip64) and (fileIp64) correspond to virtual source stream position+ that doesn't include data in temp[] */+ CBcj2Enc_ip_unsigned ip64; /* current (ip) position */+ CBcj2Enc_ip_unsigned fileIp64; /* start (ip) position of current file */+ CBcj2Enc_ip_unsigned fileSize64_minus1; /* size of current file (for conversion limitation) */+ UInt32 relatLimit; /* (relatLimit <= ((UInt32)1 << 31)) : 0 means disable_conversion */+ // UInt32 relatExcludeBits;++ UInt32 tempTarget;+ unsigned tempPos; /* the number of bytes that were copied to temp[] buffer+ (tempPos <= 4) outside of Bcj2Enc_Encode() */+ // Byte temp[4]; // for marker version+ Byte temp[8];+ CBcj2Prob probs[2 + 256];+} CBcj2Enc;++void Bcj2Enc_Init(CBcj2Enc *p);+++/*+Bcj2Enc_Encode(): at exit:+ p->State < BCJ2_NUM_STREAMS : we need more buffer space for output stream+ (bufs[p->State] == lims[p->State])+ p->State == BCJ2_ENC_STATE_ORIG : we need more data in input src stream+ (src == srcLim)+ p->State == BCJ2_ENC_STATE_FINISHED : after fully encoded stream+*/+void Bcj2Enc_Encode(CBcj2Enc *p);++/* Bcj2Enc encoder can look ahead for up 4 bytes of source stream.+ CBcj2Enc::tempPos : is the number of bytes that were copied from input stream to temp[] buffer.+ (CBcj2Enc::src) after Bcj2Enc_Encode() is starting position after+ fully processed data and after data copied to temp buffer.+ So if the caller needs to get real number of fully processed input+ bytes (without look ahead data in temp buffer),+ the caller must subtruct (CBcj2Enc::tempPos) value from processed size+ value that is calculated based on current (CBcj2Enc::src):+ cur_processed_pos = Calc_Big_Processed_Pos(enc.src)) -+ Bcj2Enc_Get_AvailInputSize_in_Temp(&enc);+*/+/* get the size of input data that was stored in temp[] buffer: */+#define Bcj2Enc_Get_AvailInputSize_in_Temp(p) ((p)->tempPos)++#define Bcj2Enc_IsFinished(p) ((p)->flushRem == 0)++/* Note : the decoder supports overlapping of marker (0f 80).+ But we can eliminate such overlapping cases by setting+ the limit for relative offset conversion as+ CBcj2Enc::relatLimit <= (0x0f << 24) == (240 MiB)+*/+/* default value for CBcj2Enc::relatLimit */+#define BCJ2_ENC_RELAT_LIMIT_DEFAULT ((UInt32)0x0f << 24)+#define BCJ2_ENC_RELAT_LIMIT_MAX ((UInt32)1 << 31)+// #define BCJ2_RELAT_EXCLUDE_NUM_BITS 5++EXTERN_C_END++#endif
@@ -0,0 +1,420 @@+/* Bra.c -- Branch converters for RISC code+2023-04-02 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include "Bra.h"+#include "CpuArch.h"+#include "RotateDefs.h"++#if defined(MY_CPU_SIZEOF_POINTER) \+ && ( MY_CPU_SIZEOF_POINTER == 4 \+ || MY_CPU_SIZEOF_POINTER == 8)+ #define BR_CONV_USE_OPT_PC_PTR+#endif++#ifdef BR_CONV_USE_OPT_PC_PTR+#define BR_PC_INIT pc -= (UInt32)(SizeT)p;+#define BR_PC_GET (pc + (UInt32)(SizeT)p)+#else+#define BR_PC_INIT pc += (UInt32)size;+#define BR_PC_GET (pc - (UInt32)(SizeT)(lim - p))+// #define BR_PC_INIT+// #define BR_PC_GET (pc + (UInt32)(SizeT)(p - data))+#endif++#define BR_CONVERT_VAL(v, c) if (encoding) v += c; else v -= c;+// #define BR_CONVERT_VAL(v, c) if (!encoding) c = (UInt32)0 - c; v += c;++#define Z7_BRANCH_CONV(name) z7_BranchConv_ ## name++#define Z7_BRANCH_FUNC_MAIN(name) \+static \+Z7_FORCE_INLINE \+Z7_ATTRIB_NO_VECTOR \+Byte *Z7_BRANCH_CONV(name)(Byte *p, SizeT size, UInt32 pc, int encoding)++#define Z7_BRANCH_FUNC_IMP(name, m, encoding) \+Z7_NO_INLINE \+Z7_ATTRIB_NO_VECTOR \+Byte *m(name)(Byte *data, SizeT size, UInt32 pc) \+ { return Z7_BRANCH_CONV(name)(data, size, pc, encoding); } \++#ifdef Z7_EXTRACT_ONLY+#define Z7_BRANCH_FUNCS_IMP(name) \+ Z7_BRANCH_FUNC_IMP(name, Z7_BRANCH_CONV_DEC, 0)+#else+#define Z7_BRANCH_FUNCS_IMP(name) \+ Z7_BRANCH_FUNC_IMP(name, Z7_BRANCH_CONV_DEC, 0) \+ Z7_BRANCH_FUNC_IMP(name, Z7_BRANCH_CONV_ENC, 1)+#endif++#if defined(__clang__)+#define BR_EXTERNAL_FOR+#define BR_NEXT_ITERATION continue;+#else+#define BR_EXTERNAL_FOR for (;;)+#define BR_NEXT_ITERATION break;+#endif++#if defined(__clang__) && (__clang_major__ >= 8) \+ || defined(__GNUC__) && (__GNUC__ >= 1000) \+ // GCC is not good for __builtin_expect() here+ /* || defined(_MSC_VER) && (_MSC_VER >= 1920) */+ // #define Z7_unlikely [[unlikely]]+ // #define Z7_LIKELY(x) (__builtin_expect((x), 1))+ #define Z7_UNLIKELY(x) (__builtin_expect((x), 0))+ // #define Z7_likely [[likely]]+#else+ // #define Z7_LIKELY(x) (x)+ #define Z7_UNLIKELY(x) (x)+ // #define Z7_likely+#endif+++Z7_BRANCH_FUNC_MAIN(ARM64)+{+ // Byte *p = data;+ const Byte *lim;+ const UInt32 flag = (UInt32)1 << (24 - 4);+ const UInt32 mask = ((UInt32)1 << 24) - (flag << 1);+ size &= ~(SizeT)3;+ // if (size == 0) return p;+ lim = p + size;+ BR_PC_INIT+ pc -= 4; // because (p) will point to next instruction+ + BR_EXTERNAL_FOR+ {+ // Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE+ for (;;)+ {+ UInt32 v;+ if Z7_UNLIKELY(p == lim)+ return p;+ v = GetUi32a(p);+ p += 4;+ if Z7_UNLIKELY(((v - 0x94000000) & 0xfc000000) == 0)+ {+ UInt32 c = BR_PC_GET >> 2;+ BR_CONVERT_VAL(v, c)+ v &= 0x03ffffff;+ v |= 0x94000000;+ SetUi32a(p - 4, v)+ BR_NEXT_ITERATION+ }+ // v = rotlFixed(v, 8); v += (flag << 8) - 0x90; if Z7_UNLIKELY((v & ((mask << 8) + 0x9f)) == 0)+ v -= 0x90000000; if Z7_UNLIKELY((v & 0x9f000000) == 0)+ {+ UInt32 z, c;+ // v = rotrFixed(v, 8);+ v += flag; if Z7_UNLIKELY(v & mask) continue;+ z = (v & 0xffffffe0) | (v >> 26);+ c = (BR_PC_GET >> (12 - 3)) & ~(UInt32)7;+ BR_CONVERT_VAL(z, c)+ v &= 0x1f;+ v |= 0x90000000;+ v |= z << 26;+ v |= 0x00ffffe0 & ((z & (((flag << 1) - 1))) - flag);+ SetUi32a(p - 4, v)+ }+ }+ }+}+Z7_BRANCH_FUNCS_IMP(ARM64)+++Z7_BRANCH_FUNC_MAIN(ARM)+{+ // Byte *p = data;+ const Byte *lim;+ size &= ~(SizeT)3;+ lim = p + size;+ BR_PC_INIT+ /* in ARM: branch offset is relative to the +2 instructions from current instruction.+ (p) will point to next instruction */+ pc += 8 - 4;+ + for (;;)+ {+ for (;;)+ {+ if Z7_UNLIKELY(p >= lim) { return p; } p += 4; if Z7_UNLIKELY(p[-1] == 0xeb) break;+ if Z7_UNLIKELY(p >= lim) { return p; } p += 4; if Z7_UNLIKELY(p[-1] == 0xeb) break;+ }+ {+ UInt32 v = GetUi32a(p - 4);+ UInt32 c = BR_PC_GET >> 2;+ BR_CONVERT_VAL(v, c)+ v &= 0x00ffffff;+ v |= 0xeb000000;+ SetUi32a(p - 4, v)+ }+ }+}+Z7_BRANCH_FUNCS_IMP(ARM)+++Z7_BRANCH_FUNC_MAIN(PPC)+{+ // Byte *p = data;+ const Byte *lim;+ size &= ~(SizeT)3;+ lim = p + size;+ BR_PC_INIT+ pc -= 4; // because (p) will point to next instruction+ + for (;;)+ {+ UInt32 v;+ for (;;)+ {+ if Z7_UNLIKELY(p == lim)+ return p;+ // v = GetBe32a(p);+ v = *(UInt32 *)(void *)p;+ p += 4;+ // if ((v & 0xfc000003) == 0x48000001) break;+ // if ((p[-4] & 0xFC) == 0x48 && (p[-1] & 3) == 1) break;+ if Z7_UNLIKELY(+ ((v - Z7_CONV_BE_TO_NATIVE_CONST32(0x48000001))+ & Z7_CONV_BE_TO_NATIVE_CONST32(0xfc000003)) == 0) break;+ }+ {+ v = Z7_CONV_NATIVE_TO_BE_32(v);+ {+ UInt32 c = BR_PC_GET;+ BR_CONVERT_VAL(v, c)+ }+ v &= 0x03ffffff;+ v |= 0x48000000;+ SetBe32a(p - 4, v)+ }+ }+}+Z7_BRANCH_FUNCS_IMP(PPC)+++#ifdef Z7_CPU_FAST_ROTATE_SUPPORTED+#define BR_SPARC_USE_ROTATE+#endif++Z7_BRANCH_FUNC_MAIN(SPARC)+{+ // Byte *p = data;+ const Byte *lim;+ const UInt32 flag = (UInt32)1 << 22;+ size &= ~(SizeT)3;+ lim = p + size;+ BR_PC_INIT+ pc -= 4; // because (p) will point to next instruction+ for (;;)+ {+ UInt32 v;+ for (;;)+ {+ if Z7_UNLIKELY(p == lim)+ return p;+ /* // the code without GetBe32a():+ { const UInt32 v = GetUi16a(p) & 0xc0ff; p += 4; if (v == 0x40 || v == 0xc07f) break; }+ */+ v = GetBe32a(p);+ p += 4;+ #ifdef BR_SPARC_USE_ROTATE+ v = rotlFixed(v, 2);+ v += (flag << 2) - 1;+ if Z7_UNLIKELY((v & (3 - (flag << 3))) == 0)+ #else+ v += (UInt32)5 << 29;+ v ^= (UInt32)7 << 29;+ v += flag;+ if Z7_UNLIKELY((v & (0 - (flag << 1))) == 0)+ #endif+ break;+ }+ {+ // UInt32 v = GetBe32a(p - 4);+ #ifndef BR_SPARC_USE_ROTATE+ v <<= 2;+ #endif+ {+ UInt32 c = BR_PC_GET;+ BR_CONVERT_VAL(v, c)+ }+ v &= (flag << 3) - 1;+ #ifdef BR_SPARC_USE_ROTATE+ v -= (flag << 2) - 1;+ v = rotrFixed(v, 2);+ #else+ v -= (flag << 2);+ v >>= 2;+ v |= (UInt32)1 << 30;+ #endif+ SetBe32a(p - 4, v)+ }+ }+}+Z7_BRANCH_FUNCS_IMP(SPARC)+++Z7_BRANCH_FUNC_MAIN(ARMT)+{+ // Byte *p = data;+ Byte *lim;+ size &= ~(SizeT)1;+ // if (size == 0) return p;+ if (size <= 2) return p;+ size -= 2;+ lim = p + size;+ BR_PC_INIT+ /* in ARM: branch offset is relative to the +2 instructions from current instruction.+ (p) will point to the +2 instructions from current instruction */+ // pc += 4 - 4;+ // if (encoding) pc -= 0xf800 << 1; else pc += 0xf800 << 1;+ // #define ARMT_TAIL_PROC { goto armt_tail; }+ #define ARMT_TAIL_PROC { return p; }+ + do+ {+ /* in MSVC 32-bit x86 compilers:+ UInt32 version : it loads value from memory with movzx+ Byte version : it loads value to 8-bit register (AL/CL)+ movzx version is slightly faster in some cpus+ */+ unsigned b1;+ // Byte / unsigned+ b1 = p[1];+ // optimized version to reduce one (p >= lim) check:+ // unsigned a1 = p[1]; b1 = p[3]; p += 2; if Z7_LIKELY((b1 & (a1 ^ 8)) < 0xf8)+ for (;;)+ {+ unsigned b3; // Byte / UInt32+ /* (Byte)(b3) normalization can use low byte computations in MSVC.+ It gives smaller code, and no loss of speed in some compilers/cpus.+ But new MSVC 32-bit x86 compilers use more slow load+ from memory to low byte register in that case.+ So we try to use full 32-bit computations for faster code.+ */+ // if (p >= lim) { ARMT_TAIL_PROC } b3 = b1 + 8; b1 = p[3]; p += 2; if ((b3 & b1) >= 0xf8) break;+ if Z7_UNLIKELY(p >= lim) { ARMT_TAIL_PROC } b3 = p[3]; p += 2; if Z7_UNLIKELY((b3 & (b1 ^ 8)) >= 0xf8) break;+ if Z7_UNLIKELY(p >= lim) { ARMT_TAIL_PROC } b1 = p[3]; p += 2; if Z7_UNLIKELY((b1 & (b3 ^ 8)) >= 0xf8) break;+ }+ {+ /* we can adjust pc for (0xf800) to rid of (& 0x7FF) operation.+ But gcc/clang for arm64 can use bfi instruction for full code here */+ UInt32 v =+ ((UInt32)GetUi16a(p - 2) << 11) |+ ((UInt32)GetUi16a(p) & 0x7FF);+ /*+ UInt32 v =+ ((UInt32)p[1 - 2] << 19)+ + (((UInt32)p[1] & 0x7) << 8)+ + (((UInt32)p[-2] << 11))+ + (p[0]);+ */+ p += 2;+ {+ UInt32 c = BR_PC_GET >> 1;+ BR_CONVERT_VAL(v, c)+ }+ SetUi16a(p - 4, (UInt16)(((v >> 11) & 0x7ff) | 0xf000))+ SetUi16a(p - 2, (UInt16)(v | 0xf800))+ /*+ p[-4] = (Byte)(v >> 11);+ p[-3] = (Byte)(0xf0 | ((v >> 19) & 0x7));+ p[-2] = (Byte)v;+ p[-1] = (Byte)(0xf8 | (v >> 8));+ */+ }+ }+ while (p < lim);+ return p;+ // armt_tail:+ // if ((Byte)((lim[1] & 0xf8)) != 0xf0) { lim += 2; } return lim;+ // return (Byte *)(lim + ((Byte)((lim[1] ^ 0xf0) & 0xf8) == 0 ? 0 : 2));+ // return (Byte *)(lim + (((lim[1] ^ ~0xfu) & ~7u) == 0 ? 0 : 2));+ // return (Byte *)(lim + 2 - (((((unsigned)lim[1] ^ 8) + 8) >> 7) & 2));+}+Z7_BRANCH_FUNCS_IMP(ARMT)+++// #define BR_IA64_NO_INLINE++Z7_BRANCH_FUNC_MAIN(IA64)+{+ // Byte *p = data;+ const Byte *lim;+ size &= ~(SizeT)15;+ lim = p + size;+ pc -= 1 << 4;+ pc >>= 4 - 1;+ // pc -= 1 << 1;+ + for (;;)+ {+ unsigned m;+ for (;;)+ {+ if Z7_UNLIKELY(p == lim)+ return p;+ m = (unsigned)((UInt32)0x334b0000 >> (*p & 0x1e));+ p += 16;+ pc += 1 << 1;+ if (m &= 3)+ break;+ }+ {+ p += (ptrdiff_t)m * 5 - 20; // negative value is expected here.+ do+ {+ const UInt32 t =+ #if defined(MY_CPU_X86_OR_AMD64)+ // we use 32-bit load here to reduce code size on x86:+ GetUi32(p);+ #else+ GetUi16(p);+ #endif+ UInt32 z = GetUi32(p + 1) >> m;+ p += 5;+ if (((t >> m) & (0x70 << 1)) == 0+ && ((z - (0x5000000 << 1)) & (0xf000000 << 1)) == 0)+ {+ UInt32 v = (UInt32)((0x8fffff << 1) | 1) & z;+ z ^= v;+ #ifdef BR_IA64_NO_INLINE+ v |= (v & ((UInt32)1 << (23 + 1))) >> 3;+ {+ UInt32 c = pc;+ BR_CONVERT_VAL(v, c)+ }+ v &= (0x1fffff << 1) | 1;+ #else+ {+ if (encoding)+ {+ // pc &= ~(0xc00000 << 1); // we just need to clear at least 2 bits+ pc &= (0x1fffff << 1) | 1;+ v += pc;+ }+ else+ {+ // pc |= 0xc00000 << 1; // we need to set at least 2 bits+ pc |= ~(UInt32)((0x1fffff << 1) | 1);+ v -= pc;+ }+ }+ v &= ~(UInt32)(0x600000 << 1);+ #endif+ v += (0x700000 << 1);+ v &= (0x8fffff << 1) | 1;+ z |= v;+ z <<= m;+ SetUi32(p + 1 - 5, z)+ }+ m++;+ }+ while (m &= 3); // while (m < 4);+ }+ }+}+Z7_BRANCH_FUNCS_IMP(IA64)
@@ -0,0 +1,99 @@+/* Bra.h -- Branch converters for executables+2023-04-02 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_BRA_H+#define ZIP7_INC_BRA_H++#include "7zTypes.h"++EXTERN_C_BEGIN++#define Z7_BRANCH_CONV_DEC(name) z7_BranchConv_ ## name ## _Dec+#define Z7_BRANCH_CONV_ENC(name) z7_BranchConv_ ## name ## _Enc+#define Z7_BRANCH_CONV_ST_DEC(name) z7_BranchConvSt_ ## name ## _Dec+#define Z7_BRANCH_CONV_ST_ENC(name) z7_BranchConvSt_ ## name ## _Enc++#define Z7_BRANCH_CONV_DECL(name) Byte * name(Byte *data, SizeT size, UInt32 pc)+#define Z7_BRANCH_CONV_ST_DECL(name) Byte * name(Byte *data, SizeT size, UInt32 pc, UInt32 *state)++typedef Z7_BRANCH_CONV_DECL( (*z7_Func_BranchConv));+typedef Z7_BRANCH_CONV_ST_DECL((*z7_Func_BranchConvSt));++#define Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL 0+Z7_BRANCH_CONV_ST_DECL(Z7_BRANCH_CONV_ST_DEC(X86));+Z7_BRANCH_CONV_ST_DECL(Z7_BRANCH_CONV_ST_ENC(X86));++#define Z7_BRANCH_FUNCS_DECL(name) \+Z7_BRANCH_CONV_DECL(Z7_BRANCH_CONV_DEC(name)); \+Z7_BRANCH_CONV_DECL(Z7_BRANCH_CONV_ENC(name));++Z7_BRANCH_FUNCS_DECL(ARM64)+Z7_BRANCH_FUNCS_DECL(ARM)+Z7_BRANCH_FUNCS_DECL(ARMT)+Z7_BRANCH_FUNCS_DECL(PPC)+Z7_BRANCH_FUNCS_DECL(SPARC)+Z7_BRANCH_FUNCS_DECL(IA64)++/*+These functions convert data that contain CPU instructions.+Each such function converts relative addresses to absolute addresses in some+branch instructions: CALL (in all converters) and JUMP (X86 converter only).+Such conversion allows to increase compression ratio, if we compress that data.++There are 2 types of converters:+ Byte * Conv_RISC (Byte *data, SizeT size, UInt32 pc);+ Byte * ConvSt_X86(Byte *data, SizeT size, UInt32 pc, UInt32 *state);+Each Converter supports 2 versions: one for encoding+and one for decoding (_Enc/_Dec postfixes in function name).++In params:+ data : data buffer+ size : size of data+ pc : current virtual Program Counter (Instruction Pinter) value+In/Out param:+ state : pointer to state variable (for X86 converter only)++Return:+ The pointer to position in (data) buffer after last byte that was processed.+ If the caller calls converter again, it must call it starting with that position.+ But the caller is allowed to move data in buffer. so pointer to+ current processed position also will be changed for next call.+ Also the caller must increase internal (pc) value for next call.+ +Each converter has some characteristics: Endian, Alignment, LookAhead.+ Type Endian Alignment LookAhead+ + X86 little 1 4+ ARMT little 2 2+ ARM little 4 0+ ARM64 little 4 0+ PPC big 4 0+ SPARC big 4 0+ IA64 little 16 0++ (data) must be aligned for (Alignment).+ processed size can be calculated as:+ SizeT processed = Conv(data, size, pc) - data;+ if (processed == 0)+ it means that converter needs more data for processing.+ If (size < Alignment + LookAhead)+ then (processed == 0) is allowed.++Example code for conversion in loop:+ UInt32 pc = 0;+ size = 0;+ for (;;)+ {+ size += Load_more_input_data(data + size);+ SizeT processed = Conv(data, size, pc) - data;+ if (processed == 0 && no_more_input_data_after_size)+ break; // we stop convert loop+ data += processed;+ size -= processed;+ pc += processed;+ }+*/++EXTERN_C_END++#endif
@@ -0,0 +1,187 @@+/* Bra86.c -- Branch converter for X86 code (BCJ)+2023-04-02 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include "Bra.h"+#include "CpuArch.h"+++#if defined(MY_CPU_SIZEOF_POINTER) \+ && ( MY_CPU_SIZEOF_POINTER == 4 \+ || MY_CPU_SIZEOF_POINTER == 8)+ #define BR_CONV_USE_OPT_PC_PTR+#endif++#ifdef BR_CONV_USE_OPT_PC_PTR+#define BR_PC_INIT pc -= (UInt32)(SizeT)p; // (MY_uintptr_t)+#define BR_PC_GET (pc + (UInt32)(SizeT)p)+#else+#define BR_PC_INIT pc += (UInt32)size;+#define BR_PC_GET (pc - (UInt32)(SizeT)(lim - p))+// #define BR_PC_INIT+// #define BR_PC_GET (pc + (UInt32)(SizeT)(p - data))+#endif++#define BR_CONVERT_VAL(v, c) if (encoding) v += c; else v -= c;+// #define BR_CONVERT_VAL(v, c) if (!encoding) c = (UInt32)0 - c; v += c;++#define Z7_BRANCH_CONV_ST(name) z7_BranchConvSt_ ## name++#define BR86_NEED_CONV_FOR_MS_BYTE(b) ((((b) + 1) & 0xfe) == 0)++#ifdef MY_CPU_LE_UNALIGN+ #define BR86_PREPARE_BCJ_SCAN const UInt32 v = GetUi32(p) ^ 0xe8e8e8e8;+ #define BR86_IS_BCJ_BYTE(n) ((v & ((UInt32)0xfe << (n) * 8)) == 0)+#else+ #define BR86_PREPARE_BCJ_SCAN+ // bad for MSVC X86 (partial write to byte reg):+ #define BR86_IS_BCJ_BYTE(n) ((p[n - 4] & 0xfe) == 0xe8)+ // bad for old MSVC (partial write to byte reg):+ // #define BR86_IS_BCJ_BYTE(n) (((*p ^ 0xe8) & 0xfe) == 0)+#endif+ +static+Z7_FORCE_INLINE+Z7_ATTRIB_NO_VECTOR+Byte *Z7_BRANCH_CONV_ST(X86)(Byte *p, SizeT size, UInt32 pc, UInt32 *state, int encoding)+{+ if (size < 5)+ return p;+ {+ // Byte *p = data;+ const Byte *lim = p + size - 4;+ unsigned mask = (unsigned)*state; // & 7;+#ifdef BR_CONV_USE_OPT_PC_PTR+ /* if BR_CONV_USE_OPT_PC_PTR is defined: we need to adjust (pc) for (+4),+ because call/jump offset is relative to the next instruction.+ if BR_CONV_USE_OPT_PC_PTR is not defined : we don't need to adjust (pc) for (+4),+ because BR_PC_GET uses (pc - (lim - p)), and lim was adjusted for (-4) before.+ */+ pc += 4;+#endif+ BR_PC_INIT+ goto start;++ for (;; mask |= 4)+ {+ // cont: mask |= 4;+ start:+ if (p >= lim)+ goto fin;+ {+ BR86_PREPARE_BCJ_SCAN+ p += 4;+ if (BR86_IS_BCJ_BYTE(0)) { goto m0; } mask >>= 1;+ if (BR86_IS_BCJ_BYTE(1)) { goto m1; } mask >>= 1;+ if (BR86_IS_BCJ_BYTE(2)) { goto m2; } mask = 0;+ if (BR86_IS_BCJ_BYTE(3)) { goto a3; }+ }+ goto main_loop;++ m0: p--;+ m1: p--;+ m2: p--;+ if (mask == 0)+ goto a3;+ if (p > lim)+ goto fin_p;+ + // if (((0x17u >> mask) & 1) == 0)+ if (mask > 4 || mask == 3)+ {+ mask >>= 1;+ continue; // goto cont;+ }+ mask >>= 1;+ if (BR86_NEED_CONV_FOR_MS_BYTE(p[mask]))+ continue; // goto cont;+ // if (!BR86_NEED_CONV_FOR_MS_BYTE(p[3])) continue; // goto cont;+ {+ UInt32 v = GetUi32(p);+ UInt32 c;+ v += (1 << 24); if (v & 0xfe000000) continue; // goto cont;+ c = BR_PC_GET;+ BR_CONVERT_VAL(v, c)+ {+ mask <<= 3;+ if (BR86_NEED_CONV_FOR_MS_BYTE(v >> mask))+ {+ v ^= (((UInt32)0x100 << mask) - 1);+ #ifdef MY_CPU_X86+ // for X86 : we can recalculate (c) to reduce register pressure+ c = BR_PC_GET;+ #endif+ BR_CONVERT_VAL(v, c)+ }+ mask = 0;+ }+ // v = (v & ((1 << 24) - 1)) - (v & (1 << 24));+ v &= (1 << 25) - 1; v -= (1 << 24);+ SetUi32(p, v)+ p += 4;+ goto main_loop;+ }++ main_loop:+ if (p >= lim)+ goto fin;+ for (;;)+ {+ BR86_PREPARE_BCJ_SCAN+ p += 4;+ if (BR86_IS_BCJ_BYTE(0)) { goto a0; }+ if (BR86_IS_BCJ_BYTE(1)) { goto a1; }+ if (BR86_IS_BCJ_BYTE(2)) { goto a2; }+ if (BR86_IS_BCJ_BYTE(3)) { goto a3; }+ if (p >= lim)+ goto fin;+ }+ + a0: p--;+ a1: p--;+ a2: p--;+ a3:+ if (p > lim)+ goto fin_p;+ // if (!BR86_NEED_CONV_FOR_MS_BYTE(p[3])) continue; // goto cont;+ {+ UInt32 v = GetUi32(p);+ UInt32 c;+ v += (1 << 24); if (v & 0xfe000000) continue; // goto cont;+ c = BR_PC_GET;+ BR_CONVERT_VAL(v, c)+ // v = (v & ((1 << 24) - 1)) - (v & (1 << 24));+ v &= (1 << 25) - 1; v -= (1 << 24);+ SetUi32(p, v)+ p += 4;+ goto main_loop;+ }+ }++fin_p:+ p--;+fin:+ // the following processing for tail is optional and can be commented+ /*+ lim += 4;+ for (; p < lim; p++, mask >>= 1)+ if ((*p & 0xfe) == 0xe8)+ break;+ */+ *state = (UInt32)mask;+ return p;+ }+}+++#define Z7_BRANCH_CONV_ST_FUNC_IMP(name, m, encoding) \+Z7_NO_INLINE \+Z7_ATTRIB_NO_VECTOR \+Byte *m(name)(Byte *data, SizeT size, UInt32 pc, UInt32 *state) \+ { return Z7_BRANCH_CONV_ST(name)(data, size, pc, state, encoding); }++Z7_BRANCH_CONV_ST_FUNC_IMP(X86, Z7_BRANCH_CONV_ST_DEC, 0)+#ifndef Z7_EXTRACT_ONLY+Z7_BRANCH_CONV_ST_FUNC_IMP(X86, Z7_BRANCH_CONV_ST_ENC, 1)+#endif
@@ -0,0 +1,14 @@+/* BraIA64.c -- Converter for IA-64 code+2023-02-20 : Igor Pavlov : Public domain */++#include "Precomp.h"++// the code was moved to Bra.c++#ifdef _MSC_VER+#pragma warning(disable : 4206) // nonstandard extension used : translation unit is empty+#endif++#if defined(__clang__)+#pragma GCC diagnostic ignored "-Wempty-translation-unit"+#endif
@@ -0,0 +1,159 @@+/* Compiler.h : Compiler specific defines and pragmas+2023-04-02 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_COMPILER_H+#define ZIP7_INC_COMPILER_H++#if defined(__clang__)+# define Z7_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)+#endif+#if defined(__clang__) && defined(__apple_build_version__)+# define Z7_APPLE_CLANG_VERSION Z7_CLANG_VERSION+#elif defined(__clang__)+# define Z7_LLVM_CLANG_VERSION Z7_CLANG_VERSION+#elif defined(__GNUC__)+# define Z7_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)+#endif++#ifdef _MSC_VER+#if !defined(__clang__) && !defined(__GNUC__)+#define Z7_MSC_VER_ORIGINAL _MSC_VER+#endif+#endif++#if defined(__MINGW32__) || defined(__MINGW64__)+#define Z7_MINGW+#endif++// #pragma GCC diagnostic ignored "-Wunknown-pragmas"++#ifdef __clang__+// padding size of '' with 4 bytes to alignment boundary+#pragma GCC diagnostic ignored "-Wpadded"+#endif+++#ifdef _MSC_VER++ #ifdef UNDER_CE+ #define RPC_NO_WINDOWS_H+ /* #pragma warning(disable : 4115) // '_RPC_ASYNC_STATE' : named type definition in parentheses */+ #pragma warning(disable : 4201) // nonstandard extension used : nameless struct/union+ #pragma warning(disable : 4214) // nonstandard extension used : bit field types other than int+ #endif++#if defined(_MSC_VER) && _MSC_VER >= 1800+#pragma warning(disable : 4464) // relative include path contains '..'+#endif++// == 1200 : -O1 : for __forceinline+// >= 1900 : -O1 : for printf+#pragma warning(disable : 4710) // function not inlined++#if _MSC_VER < 1900+// winnt.h: 'Int64ShllMod32'+#pragma warning(disable : 4514) // unreferenced inline function has been removed+#endif+ +#if _MSC_VER < 1300+// #pragma warning(disable : 4702) // unreachable code+// Bra.c : -O1:+#pragma warning(disable : 4714) // function marked as __forceinline not inlined+#endif++/*+#if _MSC_VER > 1400 && _MSC_VER <= 1900+// strcat: This function or variable may be unsafe+// sysinfoapi.h: kit10: GetVersion was declared deprecated+#pragma warning(disable : 4996)+#endif+*/++#if _MSC_VER > 1200+// -Wall warnings++#pragma warning(disable : 4711) // function selected for automatic inline expansion+#pragma warning(disable : 4820) // '2' bytes padding added after data member++#if _MSC_VER >= 1400 && _MSC_VER < 1920+// 1400: string.h: _DBG_MEMCPY_INLINE_+// 1600 - 191x : smmintrin.h __cplusplus'+// is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'+#pragma warning(disable : 4668)++// 1400 - 1600 : WinDef.h : 'FARPROC' :+// 1900 - 191x : immintrin.h: _readfsbase_u32+// no function prototype given : converting '()' to '(void)'+#pragma warning(disable : 4255)+#endif++#if _MSC_VER >= 1914+// Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified+#pragma warning(disable : 5045)+#endif++#endif // _MSC_VER > 1200+#endif // _MSC_VER+++#if defined(__clang__) && (__clang_major__ >= 4)+ #define Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE \+ _Pragma("clang loop unroll(disable)") \+ _Pragma("clang loop vectorize(disable)")+ #define Z7_ATTRIB_NO_VECTORIZE+#elif defined(__GNUC__) && (__GNUC__ >= 5)+ #define Z7_ATTRIB_NO_VECTORIZE __attribute__((optimize("no-tree-vectorize")))+ // __attribute__((optimize("no-unroll-loops")));+ #define Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE+#elif defined(_MSC_VER) && (_MSC_VER >= 1920)+ #define Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE \+ _Pragma("loop( no_vector )")+ #define Z7_ATTRIB_NO_VECTORIZE+#else+ #define Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE+ #define Z7_ATTRIB_NO_VECTORIZE+#endif++#if defined(MY_CPU_X86_OR_AMD64) && ( \+ defined(__clang__) && (__clang_major__ >= 4) \+ || defined(__GNUC__) && (__GNUC__ >= 5))+ #define Z7_ATTRIB_NO_SSE __attribute__((__target__("no-sse")))+#else+ #define Z7_ATTRIB_NO_SSE+#endif++#define Z7_ATTRIB_NO_VECTOR \+ Z7_ATTRIB_NO_VECTORIZE \+ Z7_ATTRIB_NO_SSE+++#if defined(__clang__) && (__clang_major__ >= 8) \+ || defined(__GNUC__) && (__GNUC__ >= 1000) \+ /* || defined(_MSC_VER) && (_MSC_VER >= 1920) */+ // GCC is not good for __builtin_expect()+ #define Z7_LIKELY(x) (__builtin_expect((x), 1))+ #define Z7_UNLIKELY(x) (__builtin_expect((x), 0))+ // #define Z7_unlikely [[unlikely]]+ // #define Z7_likely [[likely]]+#else+ #define Z7_LIKELY(x) (x)+ #define Z7_UNLIKELY(x) (x)+ // #define Z7_likely+#endif+++#if (defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 36000))+#define Z7_DIAGNOSCTIC_IGNORE_BEGIN_RESERVED_MACRO_IDENTIFIER \+ _Pragma("GCC diagnostic push") \+ _Pragma("GCC diagnostic ignored \"-Wreserved-macro-identifier\"")+#define Z7_DIAGNOSCTIC_IGNORE_END_RESERVED_MACRO_IDENTIFIER \+ _Pragma("GCC diagnostic pop")+#else+#define Z7_DIAGNOSCTIC_IGNORE_BEGIN_RESERVED_MACRO_IDENTIFIER+#define Z7_DIAGNOSCTIC_IGNORE_END_RESERVED_MACRO_IDENTIFIER+#endif++#define UNUSED_VAR(x) (void)x;+/* #define UNUSED_VAR(x) x=x; */++#endif
@@ -0,0 +1,823 @@+/* CpuArch.c -- CPU specific code+2023-05-18 : Igor Pavlov : Public domain */++#include "Precomp.h"++// #include <stdio.h>++#include "CpuArch.h"++#ifdef MY_CPU_X86_OR_AMD64++#undef NEED_CHECK_FOR_CPUID+#if !defined(MY_CPU_AMD64)+#define NEED_CHECK_FOR_CPUID+#endif++/*+ cpuid instruction supports (subFunction) parameter in ECX,+ that is used only with some specific (function) parameter values.+ But we always use only (subFunction==0).+*/+/*+ __cpuid(): MSVC and GCC/CLANG use same function/macro name+ but parameters are different.+ We use MSVC __cpuid() parameters style for our z7_x86_cpuid() function.+*/++#if defined(__GNUC__) /* && (__GNUC__ >= 10) */ \+ || defined(__clang__) /* && (__clang_major__ >= 10) */++/* there was some CLANG/GCC compilers that have issues with+ rbx(ebx) handling in asm blocks in -fPIC mode (__PIC__ is defined).+ compiler's <cpuid.h> contains the macro __cpuid() that is similar to our code.+ The history of __cpuid() changes in CLANG/GCC:+ GCC:+ 2007: it preserved ebx for (__PIC__ && __i386__)+ 2013: it preserved rbx and ebx for __PIC__+ 2014: it doesn't preserves rbx and ebx anymore+ we suppose that (__GNUC__ >= 5) fixed that __PIC__ ebx/rbx problem.+ CLANG:+ 2014+: it preserves rbx, but only for 64-bit code. No __PIC__ check.+ Why CLANG cares about 64-bit mode only, and doesn't care about ebx (in 32-bit)?+ Do we need __PIC__ test for CLANG or we must care about rbx even if+ __PIC__ is not defined?+*/++#define ASM_LN "\n"+ +#if defined(MY_CPU_AMD64) && defined(__PIC__) \+ && ((defined (__GNUC__) && (__GNUC__ < 5)) || defined(__clang__))++#define x86_cpuid_MACRO(p, func) { \+ __asm__ __volatile__ ( \+ ASM_LN "mov %%rbx, %q1" \+ ASM_LN "cpuid" \+ ASM_LN "xchg %%rbx, %q1" \+ : "=a" ((p)[0]), "=&r" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(0)); }++ /* "=&r" selects free register. It can select even rbx, if that register is free.+ "=&D" for (RDI) also works, but the code can be larger with "=&D"+ "2"(0) means (subFunction = 0),+ 2 is (zero-based) index in the output constraint list "=c" (ECX). */++#elif defined(MY_CPU_X86) && defined(__PIC__) \+ && ((defined (__GNUC__) && (__GNUC__ < 5)) || defined(__clang__))++#define x86_cpuid_MACRO(p, func) { \+ __asm__ __volatile__ ( \+ ASM_LN "mov %%ebx, %k1" \+ ASM_LN "cpuid" \+ ASM_LN "xchg %%ebx, %k1" \+ : "=a" ((p)[0]), "=&r" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(0)); }++#else++#define x86_cpuid_MACRO(p, func) { \+ __asm__ __volatile__ ( \+ ASM_LN "cpuid" \+ : "=a" ((p)[0]), "=b" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(0)); }++#endif+++void Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)+{+ x86_cpuid_MACRO(p, func)+}+++Z7_NO_INLINE+UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)+{+ #if defined(NEED_CHECK_FOR_CPUID)+ #define EFALGS_CPUID_BIT 21+ UInt32 a;+ __asm__ __volatile__ (+ ASM_LN "pushf"+ ASM_LN "pushf"+ ASM_LN "pop %0"+ // ASM_LN "movl %0, %1"+ // ASM_LN "xorl $0x200000, %0"+ ASM_LN "btc %1, %0"+ ASM_LN "push %0"+ ASM_LN "popf"+ ASM_LN "pushf"+ ASM_LN "pop %0"+ ASM_LN "xorl (%%esp), %0"++ ASM_LN "popf"+ ASM_LN+ : "=&r" (a) // "=a"+ : "i" (EFALGS_CPUID_BIT)+ );+ if ((a & (1 << EFALGS_CPUID_BIT)) == 0)+ return 0;+ #endif+ {+ UInt32 p[4];+ x86_cpuid_MACRO(p, 0)+ return p[0];+ }+}++#undef ASM_LN++#elif !defined(_MSC_VER)++/*+// for gcc/clang and other: we can try to use __cpuid macro:+#include <cpuid.h>+void Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)+{+ __cpuid(func, p[0], p[1], p[2], p[3]);+}+UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)+{+ return (UInt32)__get_cpuid_max(0, NULL);+}+*/+// for unsupported cpuid:+void Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)+{+ UNUSED_VAR(func)+ p[0] = p[1] = p[2] = p[3] = 0;+}+UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)+{+ return 0;+}++#else // _MSC_VER++#if !defined(MY_CPU_AMD64)++UInt32 __declspec(naked) Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)+{+ #if defined(NEED_CHECK_FOR_CPUID)+ #define EFALGS_CPUID_BIT 21+ __asm pushfd+ __asm pushfd+ /*+ __asm pop eax+ // __asm mov edx, eax+ __asm btc eax, EFALGS_CPUID_BIT+ __asm push eax+ */+ __asm btc dword ptr [esp], EFALGS_CPUID_BIT+ __asm popfd+ __asm pushfd+ __asm pop eax+ // __asm xor eax, edx+ __asm xor eax, [esp]+ // __asm push edx+ __asm popfd+ __asm and eax, (1 shl EFALGS_CPUID_BIT)+ __asm jz end_func+ #endif+ __asm push ebx+ __asm xor eax, eax // func+ __asm xor ecx, ecx // subFunction (optional) for (func == 0)+ __asm cpuid+ __asm pop ebx+ #if defined(NEED_CHECK_FOR_CPUID)+ end_func:+ #endif+ __asm ret 0+}++void __declspec(naked) Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)+{+ UNUSED_VAR(p)+ UNUSED_VAR(func)+ __asm push ebx+ __asm push edi+ __asm mov edi, ecx // p+ __asm mov eax, edx // func+ __asm xor ecx, ecx // subfunction (optional) for (func == 0)+ __asm cpuid+ __asm mov [edi ], eax+ __asm mov [edi + 4], ebx+ __asm mov [edi + 8], ecx+ __asm mov [edi + 12], edx+ __asm pop edi+ __asm pop ebx+ __asm ret 0+}++#else // MY_CPU_AMD64++ #if _MSC_VER >= 1600+ #include <intrin.h>+ #define MY_cpuidex __cpuidex+ #else+/*+ __cpuid (func == (0 or 7)) requires subfunction number in ECX.+ MSDN: The __cpuid intrinsic clears the ECX register before calling the cpuid instruction.+ __cpuid() in new MSVC clears ECX.+ __cpuid() in old MSVC (14.00) x64 doesn't clear ECX+ We still can use __cpuid for low (func) values that don't require ECX,+ but __cpuid() in old MSVC will be incorrect for some func values: (func == 7).+ So here we use the hack for old MSVC to send (subFunction) in ECX register to cpuid instruction,+ where ECX value is first parameter for FASTCALL / NO_INLINE func,+ So the caller of MY_cpuidex_HACK() sets ECX as subFunction, and+ old MSVC for __cpuid() doesn't change ECX and cpuid instruction gets (subFunction) value.+ +DON'T remove Z7_NO_INLINE and Z7_FASTCALL for MY_cpuidex_HACK(): !!!+*/+static+Z7_NO_INLINE void Z7_FASTCALL MY_cpuidex_HACK(UInt32 subFunction, UInt32 func, int *CPUInfo)+{+ UNUSED_VAR(subFunction)+ __cpuid(CPUInfo, func);+}+ #define MY_cpuidex(info, func, func2) MY_cpuidex_HACK(func2, func, info)+ #pragma message("======== MY_cpuidex_HACK WAS USED ========")+ #endif // _MSC_VER >= 1600++#if !defined(MY_CPU_AMD64)+/* inlining for __cpuid() in MSVC x86 (32-bit) produces big ineffective code,+ so we disable inlining here */+Z7_NO_INLINE+#endif+void Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)+{+ MY_cpuidex((int *)p, (int)func, 0);+}++Z7_NO_INLINE+UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)+{+ int a[4];+ MY_cpuidex(a, 0, 0);+ return a[0];+}++#endif // MY_CPU_AMD64+#endif // _MSC_VER++#if defined(NEED_CHECK_FOR_CPUID)+#define CHECK_CPUID_IS_SUPPORTED { if (z7_x86_cpuid_GetMaxFunc() == 0) return 0; }+#else+#define CHECK_CPUID_IS_SUPPORTED+#endif+#undef NEED_CHECK_FOR_CPUID+++static+BoolInt x86cpuid_Func_1(UInt32 *p)+{+ CHECK_CPUID_IS_SUPPORTED+ z7_x86_cpuid(p, 1);+ return True;+}++/*+static const UInt32 kVendors[][1] =+{+ { 0x756E6547 }, // , 0x49656E69, 0x6C65746E },+ { 0x68747541 }, // , 0x69746E65, 0x444D4163 },+ { 0x746E6543 } // , 0x48727561, 0x736C7561 }+};+*/++/*+typedef struct+{+ UInt32 maxFunc;+ UInt32 vendor[3];+ UInt32 ver;+ UInt32 b;+ UInt32 c;+ UInt32 d;+} Cx86cpuid;++enum+{+ CPU_FIRM_INTEL,+ CPU_FIRM_AMD,+ CPU_FIRM_VIA+};+int x86cpuid_GetFirm(const Cx86cpuid *p);+#define x86cpuid_ver_GetFamily(ver) (((ver >> 16) & 0xff0) | ((ver >> 8) & 0xf))+#define x86cpuid_ver_GetModel(ver) (((ver >> 12) & 0xf0) | ((ver >> 4) & 0xf))+#define x86cpuid_ver_GetStepping(ver) (ver & 0xf)++int x86cpuid_GetFirm(const Cx86cpuid *p)+{+ unsigned i;+ for (i = 0; i < sizeof(kVendors) / sizeof(kVendors[0]); i++)+ {+ const UInt32 *v = kVendors[i];+ if (v[0] == p->vendor[0]+ // && v[1] == p->vendor[1]+ // && v[2] == p->vendor[2]+ )+ return (int)i;+ }+ return -1;+}++BoolInt CPU_Is_InOrder()+{+ Cx86cpuid p;+ UInt32 family, model;+ if (!x86cpuid_CheckAndRead(&p))+ return True;++ family = x86cpuid_ver_GetFamily(p.ver);+ model = x86cpuid_ver_GetModel(p.ver);++ switch (x86cpuid_GetFirm(&p))+ {+ case CPU_FIRM_INTEL: return (family < 6 || (family == 6 && (+ // In-Order Atom CPU+ model == 0x1C // 45 nm, N4xx, D4xx, N5xx, D5xx, 230, 330+ || model == 0x26 // 45 nm, Z6xx+ || model == 0x27 // 32 nm, Z2460+ || model == 0x35 // 32 nm, Z2760+ || model == 0x36 // 32 nm, N2xxx, D2xxx+ )));+ case CPU_FIRM_AMD: return (family < 5 || (family == 5 && (model < 6 || model == 0xA)));+ case CPU_FIRM_VIA: return (family < 6 || (family == 6 && model < 0xF));+ }+ return False; // v23 : unknown processors are not In-Order+}+*/++#ifdef _WIN32+#include "7zWindows.h"+#endif++#if !defined(MY_CPU_AMD64) && defined(_WIN32)++/* for legacy SSE ia32: there is no user-space cpu instruction to check+ that OS supports SSE register storing/restoring on context switches.+ So we need some OS-specific function to check that it's safe to use SSE registers.+*/++Z7_FORCE_INLINE+static BoolInt CPU_Sys_Is_SSE_Supported(void)+{+#ifdef _MSC_VER+ #pragma warning(push)+ #pragma warning(disable : 4996) // `GetVersion': was declared deprecated+#endif+ /* low byte is major version of Windows+ We suppose that any Windows version since+ Windows2000 (major == 5) supports SSE registers */+ return (Byte)GetVersion() >= 5;+#if defined(_MSC_VER)+ #pragma warning(pop)+#endif+}+#define CHECK_SYS_SSE_SUPPORT if (!CPU_Sys_Is_SSE_Supported()) return False;+#else+#define CHECK_SYS_SSE_SUPPORT+#endif+++#if !defined(MY_CPU_AMD64)++BoolInt CPU_IsSupported_CMOV(void)+{+ UInt32 a[4];+ if (!x86cpuid_Func_1(&a[0]))+ return 0;+ return (a[3] >> 15) & 1;+}++BoolInt CPU_IsSupported_SSE(void)+{+ UInt32 a[4];+ CHECK_SYS_SSE_SUPPORT+ if (!x86cpuid_Func_1(&a[0]))+ return 0;+ return (a[3] >> 25) & 1;+}++BoolInt CPU_IsSupported_SSE2(void)+{+ UInt32 a[4];+ CHECK_SYS_SSE_SUPPORT+ if (!x86cpuid_Func_1(&a[0]))+ return 0;+ return (a[3] >> 26) & 1;+}++#endif+++static UInt32 x86cpuid_Func_1_ECX(void)+{+ UInt32 a[4];+ CHECK_SYS_SSE_SUPPORT+ if (!x86cpuid_Func_1(&a[0]))+ return 0;+ return a[2];+}++BoolInt CPU_IsSupported_AES(void)+{+ return (x86cpuid_Func_1_ECX() >> 25) & 1;+}++BoolInt CPU_IsSupported_SSSE3(void)+{+ return (x86cpuid_Func_1_ECX() >> 9) & 1;+}++BoolInt CPU_IsSupported_SSE41(void)+{+ return (x86cpuid_Func_1_ECX() >> 19) & 1;+}++BoolInt CPU_IsSupported_SHA(void)+{+ CHECK_SYS_SSE_SUPPORT++ if (z7_x86_cpuid_GetMaxFunc() < 7)+ return False;+ {+ UInt32 d[4];+ z7_x86_cpuid(d, 7);+ return (d[1] >> 29) & 1;+ }+}++/*+MSVC: _xgetbv() intrinsic is available since VS2010SP1.+ MSVC also defines (_XCR_XFEATURE_ENABLED_MASK) macro in+ <immintrin.h> that we can use or check.+ For any 32-bit x86 we can use asm code in MSVC,+ but MSVC asm code is huge after compilation.+ So _xgetbv() is better++ICC: _xgetbv() intrinsic is available (in what version of ICC?)+ ICC defines (__GNUC___) and it supports gnu assembler+ also ICC supports MASM style code with -use-msasm switch.+ but ICC doesn't support __attribute__((__target__))++GCC/CLANG 9:+ _xgetbv() is macro that works via __builtin_ia32_xgetbv()+ and we need __attribute__((__target__("xsave")).+ But with __target__("xsave") the function will be not+ inlined to function that has no __target__("xsave") attribute.+ If we want _xgetbv() call inlining, then we should use asm version+ instead of calling _xgetbv().+ Note:intrinsic is broke before GCC 8.2:+ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85684+*/++#if defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100) \+ || defined(_MSC_VER) && (_MSC_VER >= 1600) && (_MSC_FULL_VER >= 160040219) \+ || defined(__GNUC__) && (__GNUC__ >= 9) \+ || defined(__clang__) && (__clang_major__ >= 9)+// we define ATTRIB_XGETBV, if we want to use predefined _xgetbv() from compiler+#if defined(__INTEL_COMPILER)+#define ATTRIB_XGETBV+#elif defined(__GNUC__) || defined(__clang__)+// we don't define ATTRIB_XGETBV here, because asm version is better for inlining.+// #define ATTRIB_XGETBV __attribute__((__target__("xsave")))+#else+#define ATTRIB_XGETBV+#endif+#endif++#if defined(ATTRIB_XGETBV)+#include <immintrin.h>+#endif+++// XFEATURE_ENABLED_MASK/XCR0+#define MY_XCR_XFEATURE_ENABLED_MASK 0++#if defined(ATTRIB_XGETBV)+ATTRIB_XGETBV+#endif+static UInt64 x86_xgetbv_0(UInt32 num)+{+#if defined(ATTRIB_XGETBV)+ {+ return+ #if (defined(_MSC_VER))+ _xgetbv(num);+ #else+ __builtin_ia32_xgetbv(+ #if !defined(__clang__)+ (int)+ #endif+ num);+ #endif+ }++#elif defined(__GNUC__) || defined(__clang__) || defined(__SUNPRO_CC)++ UInt32 a, d;+ #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))+ __asm__+ (+ "xgetbv"+ : "=a"(a), "=d"(d) : "c"(num) : "cc"+ );+ #else // is old gcc+ __asm__+ (+ ".byte 0x0f, 0x01, 0xd0" "\n\t"+ : "=a"(a), "=d"(d) : "c"(num) : "cc"+ );+ #endif+ return ((UInt64)d << 32) | a;+ // return a;++#elif defined(_MSC_VER) && !defined(MY_CPU_AMD64)+ + UInt32 a, d;+ __asm {+ push eax+ push edx+ push ecx+ mov ecx, num;+ // xor ecx, ecx // = MY_XCR_XFEATURE_ENABLED_MASK+ _emit 0x0f+ _emit 0x01+ _emit 0xd0+ mov a, eax+ mov d, edx+ pop ecx+ pop edx+ pop eax+ }+ return ((UInt64)d << 32) | a;+ // return a;++#else // it's unknown compiler+ // #error "Need xgetbv function"+ UNUSED_VAR(num)+ // for MSVC-X64 we could call external function from external file.+ /* Actually we had checked OSXSAVE/AVX in cpuid before.+ So it's expected that OS supports at least AVX and below. */+ // if (num != MY_XCR_XFEATURE_ENABLED_MASK) return 0; // if not XCR0+ return+ // (1 << 0) | // x87+ (1 << 1) // SSE+ | (1 << 2); // AVX+ +#endif+}++#ifdef _WIN32+/*+ Windows versions do not know about new ISA extensions that+ can be introduced. But we still can use new extensions,+ even if Windows doesn't report about supporting them,+ But we can use new extensions, only if Windows knows about new ISA extension+ that changes the number or size of registers: SSE, AVX/XSAVE, AVX512+ So it's enough to check+ MY_PF_AVX_INSTRUCTIONS_AVAILABLE+ instead of+ MY_PF_AVX2_INSTRUCTIONS_AVAILABLE+*/+#define MY_PF_XSAVE_ENABLED 17+// #define MY_PF_SSSE3_INSTRUCTIONS_AVAILABLE 36+// #define MY_PF_SSE4_1_INSTRUCTIONS_AVAILABLE 37+// #define MY_PF_SSE4_2_INSTRUCTIONS_AVAILABLE 38+// #define MY_PF_AVX_INSTRUCTIONS_AVAILABLE 39+// #define MY_PF_AVX2_INSTRUCTIONS_AVAILABLE 40+// #define MY_PF_AVX512F_INSTRUCTIONS_AVAILABLE 41+#endif++BoolInt CPU_IsSupported_AVX(void)+{+ #ifdef _WIN32+ if (!IsProcessorFeaturePresent(MY_PF_XSAVE_ENABLED))+ return False;+ /* PF_AVX_INSTRUCTIONS_AVAILABLE probably is supported starting from+ some latest Win10 revisions. But we need AVX in older Windows also.+ So we don't use the following check: */+ /*+ if (!IsProcessorFeaturePresent(MY_PF_AVX_INSTRUCTIONS_AVAILABLE))+ return False;+ */+ #endif++ /*+ OS must use new special XSAVE/XRSTOR instructions to save+ AVX registers when it required for context switching.+ At OS statring:+ OS sets CR4.OSXSAVE flag to signal the processor that OS supports the XSAVE extensions.+ Also OS sets bitmask in XCR0 register that defines what+ registers will be processed by XSAVE instruction:+ XCR0.SSE[bit 0] - x87 registers and state+ XCR0.SSE[bit 1] - SSE registers and state+ XCR0.AVX[bit 2] - AVX registers and state+ CR4.OSXSAVE is reflected to CPUID.1:ECX.OSXSAVE[bit 27].+ So we can read that bit in user-space.+ XCR0 is available for reading in user-space by new XGETBV instruction.+ */+ {+ const UInt32 c = x86cpuid_Func_1_ECX();+ if (0 == (1+ & (c >> 28) // AVX instructions are supported by hardware+ & (c >> 27))) // OSXSAVE bit: XSAVE and related instructions are enabled by OS.+ return False;+ }++ /* also we can check+ CPUID.1:ECX.XSAVE [bit 26] : that shows that+ XSAVE, XRESTOR, XSETBV, XGETBV instructions are supported by hardware.+ But that check is redundant, because if OSXSAVE bit is set, then XSAVE is also set */++ /* If OS have enabled XSAVE extension instructions (OSXSAVE == 1),+ in most cases we expect that OS also will support storing/restoring+ for AVX and SSE states at least.+ But to be ensure for that we call user-space instruction+ XGETBV(0) to get XCR0 value that contains bitmask that defines+ what exact states(registers) OS have enabled for storing/restoring.+ */++ {+ const UInt32 bm = (UInt32)x86_xgetbv_0(MY_XCR_XFEATURE_ENABLED_MASK);+ // printf("\n=== XGetBV=%d\n", bm);+ return 1+ & (bm >> 1) // SSE state is supported (set by OS) for storing/restoring+ & (bm >> 2); // AVX state is supported (set by OS) for storing/restoring+ }+ // since Win7SP1: we can use GetEnabledXStateFeatures();+}+++BoolInt CPU_IsSupported_AVX2(void)+{+ if (!CPU_IsSupported_AVX())+ return False;+ if (z7_x86_cpuid_GetMaxFunc() < 7)+ return False;+ {+ UInt32 d[4];+ z7_x86_cpuid(d, 7);+ // printf("\ncpuid(7): ebx=%8x ecx=%8x\n", d[1], d[2]);+ return 1+ & (d[1] >> 5); // avx2+ }+}++BoolInt CPU_IsSupported_VAES_AVX2(void)+{+ if (!CPU_IsSupported_AVX())+ return False;+ if (z7_x86_cpuid_GetMaxFunc() < 7)+ return False;+ {+ UInt32 d[4];+ z7_x86_cpuid(d, 7);+ // printf("\ncpuid(7): ebx=%8x ecx=%8x\n", d[1], d[2]);+ return 1+ & (d[1] >> 5) // avx2+ // & (d[1] >> 31) // avx512vl+ & (d[2] >> 9); // vaes // VEX-256/EVEX+ }+}++BoolInt CPU_IsSupported_PageGB(void)+{+ CHECK_CPUID_IS_SUPPORTED+ {+ UInt32 d[4];+ z7_x86_cpuid(d, 0x80000000);+ if (d[0] < 0x80000001)+ return False;+ z7_x86_cpuid(d, 0x80000001);+ return (d[3] >> 26) & 1;+ }+}+++#elif defined(MY_CPU_ARM_OR_ARM64)++#ifdef _WIN32++#include "7zWindows.h"++BoolInt CPU_IsSupported_CRC32(void) { return IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }+BoolInt CPU_IsSupported_CRYPTO(void) { return IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }+BoolInt CPU_IsSupported_NEON(void) { return IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }++#else++#if defined(__APPLE__)++/*+#include <stdio.h>+#include <string.h>+static void Print_sysctlbyname(const char *name)+{+ size_t bufSize = 256;+ char buf[256];+ int res = sysctlbyname(name, &buf, &bufSize, NULL, 0);+ {+ int i;+ printf("\nres = %d : %s : '%s' : bufSize = %d, numeric", res, name, buf, (unsigned)bufSize);+ for (i = 0; i < 20; i++)+ printf(" %2x", (unsigned)(Byte)buf[i]);++ }+}+*/+/*+ Print_sysctlbyname("hw.pagesize");+ Print_sysctlbyname("machdep.cpu.brand_string");+*/++static BoolInt z7_sysctlbyname_Get_BoolInt(const char *name)+{+ UInt32 val = 0;+ if (z7_sysctlbyname_Get_UInt32(name, &val) == 0 && val == 1)+ return 1;+ return 0;+}++BoolInt CPU_IsSupported_CRC32(void)+{+ return z7_sysctlbyname_Get_BoolInt("hw.optional.armv8_crc32");+}++BoolInt CPU_IsSupported_NEON(void)+{+ return z7_sysctlbyname_Get_BoolInt("hw.optional.neon");+}++#ifdef MY_CPU_ARM64+#define APPLE_CRYPTO_SUPPORT_VAL 1+#else+#define APPLE_CRYPTO_SUPPORT_VAL 0+#endif++BoolInt CPU_IsSupported_SHA1(void) { return APPLE_CRYPTO_SUPPORT_VAL; }+BoolInt CPU_IsSupported_SHA2(void) { return APPLE_CRYPTO_SUPPORT_VAL; }+BoolInt CPU_IsSupported_AES (void) { return APPLE_CRYPTO_SUPPORT_VAL; }+++#else // __APPLE__++#include <sys/auxv.h>++#define USE_HWCAP++#ifdef USE_HWCAP++#include <asm/hwcap.h>++ #define MY_HWCAP_CHECK_FUNC_2(name1, name2) \+ BoolInt CPU_IsSupported_ ## name1() { return (getauxval(AT_HWCAP) & (HWCAP_ ## name2)) ? 1 : 0; }++#ifdef MY_CPU_ARM64+ #define MY_HWCAP_CHECK_FUNC(name) \+ MY_HWCAP_CHECK_FUNC_2(name, name)+ MY_HWCAP_CHECK_FUNC_2(NEON, ASIMD)+// MY_HWCAP_CHECK_FUNC (ASIMD)+#elif defined(MY_CPU_ARM)+ #define MY_HWCAP_CHECK_FUNC(name) \+ BoolInt CPU_IsSupported_ ## name() { return (getauxval(AT_HWCAP2) & (HWCAP2_ ## name)) ? 1 : 0; }+ MY_HWCAP_CHECK_FUNC_2(NEON, NEON)+#endif++#else // USE_HWCAP++ #define MY_HWCAP_CHECK_FUNC(name) \+ BoolInt CPU_IsSupported_ ## name() { return 0; }+ MY_HWCAP_CHECK_FUNC(NEON)++#endif // USE_HWCAP++MY_HWCAP_CHECK_FUNC (CRC32)+MY_HWCAP_CHECK_FUNC (SHA1)+MY_HWCAP_CHECK_FUNC (SHA2)+MY_HWCAP_CHECK_FUNC (AES)++#endif // __APPLE__+#endif // _WIN32++#endif // MY_CPU_ARM_OR_ARM64++++#ifdef __APPLE__++#include <sys/sysctl.h>++int z7_sysctlbyname_Get(const char *name, void *buf, size_t *bufSize)+{+ return sysctlbyname(name, buf, bufSize, NULL, 0);+}++int z7_sysctlbyname_Get_UInt32(const char *name, UInt32 *val)+{+ size_t bufSize = sizeof(*val);+ const int res = z7_sysctlbyname_Get(name, val, &bufSize);+ if (res == 0 && bufSize != sizeof(*val))+ return EFAULT;+ return res;+}++#endif
@@ -0,0 +1,523 @@+/* CpuArch.h -- CPU specific code+2023-04-02 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_CPU_ARCH_H+#define ZIP7_INC_CPU_ARCH_H++#include "7zTypes.h"++EXTERN_C_BEGIN++/*+MY_CPU_LE means that CPU is LITTLE ENDIAN.+MY_CPU_BE means that CPU is BIG ENDIAN.+If MY_CPU_LE and MY_CPU_BE are not defined, we don't know about ENDIANNESS of platform.++MY_CPU_LE_UNALIGN means that CPU is LITTLE ENDIAN and CPU supports unaligned memory accesses.++MY_CPU_64BIT means that processor can work with 64-bit registers.+ MY_CPU_64BIT can be used to select fast code branch+ MY_CPU_64BIT doesn't mean that (sizeof(void *) == 8)+*/++#if defined(_M_X64) \+ || defined(_M_AMD64) \+ || defined(__x86_64__) \+ || defined(__AMD64__) \+ || defined(__amd64__)+ #define MY_CPU_AMD64+ #ifdef __ILP32__+ #define MY_CPU_NAME "x32"+ #define MY_CPU_SIZEOF_POINTER 4+ #else+ #define MY_CPU_NAME "x64"+ #define MY_CPU_SIZEOF_POINTER 8+ #endif+ #define MY_CPU_64BIT+#endif+++#if defined(_M_IX86) \+ || defined(__i386__)+ #define MY_CPU_X86+ #define MY_CPU_NAME "x86"+ /* #define MY_CPU_32BIT */+ #define MY_CPU_SIZEOF_POINTER 4+#endif+++#if defined(_M_ARM64) \+ || defined(__AARCH64EL__) \+ || defined(__AARCH64EB__) \+ || defined(__aarch64__)+ #define MY_CPU_ARM64+ #ifdef __ILP32__+ #define MY_CPU_NAME "arm64-32"+ #define MY_CPU_SIZEOF_POINTER 4+ #else+ #define MY_CPU_NAME "arm64"+ #define MY_CPU_SIZEOF_POINTER 8+ #endif+ #define MY_CPU_64BIT+#endif+++#if defined(_M_ARM) \+ || defined(_M_ARM_NT) \+ || defined(_M_ARMT) \+ || defined(__arm__) \+ || defined(__thumb__) \+ || defined(__ARMEL__) \+ || defined(__ARMEB__) \+ || defined(__THUMBEL__) \+ || defined(__THUMBEB__)+ #define MY_CPU_ARM++ #if defined(__thumb__) || defined(__THUMBEL__) || defined(_M_ARMT)+ #define MY_CPU_ARMT+ #define MY_CPU_NAME "armt"+ #else+ #define MY_CPU_ARM32+ #define MY_CPU_NAME "arm"+ #endif+ /* #define MY_CPU_32BIT */+ #define MY_CPU_SIZEOF_POINTER 4+#endif+++#if defined(_M_IA64) \+ || defined(__ia64__)+ #define MY_CPU_IA64+ #define MY_CPU_NAME "ia64"+ #define MY_CPU_64BIT+#endif+++#if defined(__mips64) \+ || defined(__mips64__) \+ || (defined(__mips) && (__mips == 64 || __mips == 4 || __mips == 3))+ #define MY_CPU_NAME "mips64"+ #define MY_CPU_64BIT+#elif defined(__mips__)+ #define MY_CPU_NAME "mips"+ /* #define MY_CPU_32BIT */+#endif+++#if defined(__ppc64__) \+ || defined(__powerpc64__) \+ || defined(__ppc__) \+ || defined(__powerpc__) \+ || defined(__PPC__) \+ || defined(_POWER)++#define MY_CPU_PPC_OR_PPC64++#if defined(__ppc64__) \+ || defined(__powerpc64__) \+ || defined(_LP64) \+ || defined(__64BIT__)+ #ifdef __ILP32__+ #define MY_CPU_NAME "ppc64-32"+ #define MY_CPU_SIZEOF_POINTER 4+ #else+ #define MY_CPU_NAME "ppc64"+ #define MY_CPU_SIZEOF_POINTER 8+ #endif+ #define MY_CPU_64BIT+#else+ #define MY_CPU_NAME "ppc"+ #define MY_CPU_SIZEOF_POINTER 4+ /* #define MY_CPU_32BIT */+#endif+#endif+++#if defined(__riscv) \+ || defined(__riscv__)+ #if __riscv_xlen == 32+ #define MY_CPU_NAME "riscv32"+ #elif __riscv_xlen == 64+ #define MY_CPU_NAME "riscv64"+ #else+ #define MY_CPU_NAME "riscv"+ #endif+#endif+++#if defined(MY_CPU_X86) || defined(MY_CPU_AMD64)+#define MY_CPU_X86_OR_AMD64+#endif++#if defined(MY_CPU_ARM) || defined(MY_CPU_ARM64)+#define MY_CPU_ARM_OR_ARM64+#endif+++#ifdef _WIN32++ #ifdef MY_CPU_ARM+ #define MY_CPU_ARM_LE+ #endif++ #ifdef MY_CPU_ARM64+ #define MY_CPU_ARM64_LE+ #endif++ #ifdef _M_IA64+ #define MY_CPU_IA64_LE+ #endif++#endif+++#if defined(MY_CPU_X86_OR_AMD64) \+ || defined(MY_CPU_ARM_LE) \+ || defined(MY_CPU_ARM64_LE) \+ || defined(MY_CPU_IA64_LE) \+ || defined(__LITTLE_ENDIAN__) \+ || defined(__ARMEL__) \+ || defined(__THUMBEL__) \+ || defined(__AARCH64EL__) \+ || defined(__MIPSEL__) \+ || defined(__MIPSEL) \+ || defined(_MIPSEL) \+ || defined(__BFIN__) \+ || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))+ #define MY_CPU_LE+#endif++#if defined(__BIG_ENDIAN__) \+ || defined(__ARMEB__) \+ || defined(__THUMBEB__) \+ || defined(__AARCH64EB__) \+ || defined(__MIPSEB__) \+ || defined(__MIPSEB) \+ || defined(_MIPSEB) \+ || defined(__m68k__) \+ || defined(__s390__) \+ || defined(__s390x__) \+ || defined(__zarch__) \+ || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))+ #define MY_CPU_BE+#endif+++#if defined(MY_CPU_LE) && defined(MY_CPU_BE)+ #error Stop_Compiling_Bad_Endian+#endif++#if !defined(MY_CPU_LE) && !defined(MY_CPU_BE)+ #error Stop_Compiling_CPU_ENDIAN_must_be_detected_at_compile_time+#endif++#if defined(MY_CPU_32BIT) && defined(MY_CPU_64BIT)+ #error Stop_Compiling_Bad_32_64_BIT+#endif++#ifdef __SIZEOF_POINTER__+ #ifdef MY_CPU_SIZEOF_POINTER+ #if MY_CPU_SIZEOF_POINTER != __SIZEOF_POINTER__+ #error Stop_Compiling_Bad_MY_CPU_PTR_SIZE+ #endif+ #else+ #define MY_CPU_SIZEOF_POINTER __SIZEOF_POINTER__+ #endif+#endif++#if defined(MY_CPU_SIZEOF_POINTER) && (MY_CPU_SIZEOF_POINTER == 4)+#if defined (_LP64)+ #error Stop_Compiling_Bad_MY_CPU_PTR_SIZE+#endif+#endif++#ifdef _MSC_VER+ #if _MSC_VER >= 1300+ #define MY_CPU_pragma_pack_push_1 __pragma(pack(push, 1))+ #define MY_CPU_pragma_pop __pragma(pack(pop))+ #else+ #define MY_CPU_pragma_pack_push_1+ #define MY_CPU_pragma_pop+ #endif+#else+ #ifdef __xlC__+ #define MY_CPU_pragma_pack_push_1 _Pragma("pack(1)")+ #define MY_CPU_pragma_pop _Pragma("pack()")+ #else+ #define MY_CPU_pragma_pack_push_1 _Pragma("pack(push, 1)")+ #define MY_CPU_pragma_pop _Pragma("pack(pop)")+ #endif+#endif+++#ifndef MY_CPU_NAME+ #ifdef MY_CPU_LE+ #define MY_CPU_NAME "LE"+ #elif defined(MY_CPU_BE)+ #define MY_CPU_NAME "BE"+ #else+ /*+ #define MY_CPU_NAME ""+ */+ #endif+#endif++++++#ifdef __has_builtin+ #define Z7_has_builtin(x) __has_builtin(x)+#else+ #define Z7_has_builtin(x) 0+#endif+++#define Z7_BSWAP32_CONST(v) \+ ( (((UInt32)(v) << 24) ) \+ | (((UInt32)(v) << 8) & (UInt32)0xff0000) \+ | (((UInt32)(v) >> 8) & (UInt32)0xff00 ) \+ | (((UInt32)(v) >> 24) ))+++#if defined(_MSC_VER) && (_MSC_VER >= 1300)++#include <stdlib.h>++/* Note: these macros will use bswap instruction (486), that is unsupported in 386 cpu */++#pragma intrinsic(_byteswap_ushort)+#pragma intrinsic(_byteswap_ulong)+#pragma intrinsic(_byteswap_uint64)++#define Z7_BSWAP16(v) _byteswap_ushort(v)+#define Z7_BSWAP32(v) _byteswap_ulong (v)+#define Z7_BSWAP64(v) _byteswap_uint64(v)+#define Z7_CPU_FAST_BSWAP_SUPPORTED++#elif (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) \+ || (defined(__clang__) && Z7_has_builtin(__builtin_bswap16))+ +#define Z7_BSWAP16(v) __builtin_bswap16(v)+#define Z7_BSWAP32(v) __builtin_bswap32(v)+#define Z7_BSWAP64(v) __builtin_bswap64(v)+#define Z7_CPU_FAST_BSWAP_SUPPORTED++#else++#define Z7_BSWAP16(v) ((UInt16) \+ ( ((UInt32)(v) << 8) \+ | ((UInt32)(v) >> 8) \+ ))++#define Z7_BSWAP32(v) Z7_BSWAP32_CONST(v)++#define Z7_BSWAP64(v) \+ ( ( ( (UInt64)(v) ) << 8 * 7 ) \+ | ( ( (UInt64)(v) & ((UInt32)0xff << 8 * 1) ) << 8 * 5 ) \+ | ( ( (UInt64)(v) & ((UInt32)0xff << 8 * 2) ) << 8 * 3 ) \+ | ( ( (UInt64)(v) & ((UInt32)0xff << 8 * 3) ) << 8 * 1 ) \+ | ( ( (UInt64)(v) >> 8 * 1 ) & ((UInt32)0xff << 8 * 3) ) \+ | ( ( (UInt64)(v) >> 8 * 3 ) & ((UInt32)0xff << 8 * 2) ) \+ | ( ( (UInt64)(v) >> 8 * 5 ) & ((UInt32)0xff << 8 * 1) ) \+ | ( ( (UInt64)(v) >> 8 * 7 ) ) \+ )++#endif++++#ifdef MY_CPU_LE+ #if defined(MY_CPU_X86_OR_AMD64) \+ || defined(MY_CPU_ARM64)+ #define MY_CPU_LE_UNALIGN+ #define MY_CPU_LE_UNALIGN_64+ #elif defined(__ARM_FEATURE_UNALIGNED)+ /* gcc9 for 32-bit arm can use LDRD instruction that requires 32-bit alignment.+ So we can't use unaligned 64-bit operations. */+ #define MY_CPU_LE_UNALIGN+ #endif+#endif+++#ifdef MY_CPU_LE_UNALIGN++#define GetUi16(p) (*(const UInt16 *)(const void *)(p))+#define GetUi32(p) (*(const UInt32 *)(const void *)(p))+#ifdef MY_CPU_LE_UNALIGN_64+#define GetUi64(p) (*(const UInt64 *)(const void *)(p))+#define SetUi64(p, v) { *(UInt64 *)(void *)(p) = (v); }+#endif++#define SetUi16(p, v) { *(UInt16 *)(void *)(p) = (v); }+#define SetUi32(p, v) { *(UInt32 *)(void *)(p) = (v); }++#else++#define GetUi16(p) ( (UInt16) ( \+ ((const Byte *)(p))[0] | \+ ((UInt16)((const Byte *)(p))[1] << 8) ))++#define GetUi32(p) ( \+ ((const Byte *)(p))[0] | \+ ((UInt32)((const Byte *)(p))[1] << 8) | \+ ((UInt32)((const Byte *)(p))[2] << 16) | \+ ((UInt32)((const Byte *)(p))[3] << 24))++#define SetUi16(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \+ _ppp_[0] = (Byte)_vvv_; \+ _ppp_[1] = (Byte)(_vvv_ >> 8); }++#define SetUi32(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \+ _ppp_[0] = (Byte)_vvv_; \+ _ppp_[1] = (Byte)(_vvv_ >> 8); \+ _ppp_[2] = (Byte)(_vvv_ >> 16); \+ _ppp_[3] = (Byte)(_vvv_ >> 24); }++#endif+++#ifndef GetUi64+#define GetUi64(p) (GetUi32(p) | ((UInt64)GetUi32(((const Byte *)(p)) + 4) << 32))+#endif++#ifndef SetUi64+#define SetUi64(p, v) { Byte *_ppp2_ = (Byte *)(p); UInt64 _vvv2_ = (v); \+ SetUi32(_ppp2_ , (UInt32)_vvv2_) \+ SetUi32(_ppp2_ + 4, (UInt32)(_vvv2_ >> 32)) }+#endif+++#if defined(MY_CPU_LE_UNALIGN) && defined(Z7_CPU_FAST_BSWAP_SUPPORTED)++#define GetBe32(p) Z7_BSWAP32 (*(const UInt32 *)(const void *)(p))+#define SetBe32(p, v) { (*(UInt32 *)(void *)(p)) = Z7_BSWAP32(v); }++#if defined(MY_CPU_LE_UNALIGN_64)+#define GetBe64(p) Z7_BSWAP64 (*(const UInt64 *)(const void *)(p))+#endif++#else++#define GetBe32(p) ( \+ ((UInt32)((const Byte *)(p))[0] << 24) | \+ ((UInt32)((const Byte *)(p))[1] << 16) | \+ ((UInt32)((const Byte *)(p))[2] << 8) | \+ ((const Byte *)(p))[3] )++#define SetBe32(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \+ _ppp_[0] = (Byte)(_vvv_ >> 24); \+ _ppp_[1] = (Byte)(_vvv_ >> 16); \+ _ppp_[2] = (Byte)(_vvv_ >> 8); \+ _ppp_[3] = (Byte)_vvv_; }++#endif++#ifndef GetBe64+#define GetBe64(p) (((UInt64)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4))+#endif++#ifndef GetBe16+#define GetBe16(p) ( (UInt16) ( \+ ((UInt16)((const Byte *)(p))[0] << 8) | \+ ((const Byte *)(p))[1] ))+#endif+++#if defined(MY_CPU_BE)+#define Z7_CONV_BE_TO_NATIVE_CONST32(v) (v)+#define Z7_CONV_LE_TO_NATIVE_CONST32(v) Z7_BSWAP32_CONST(v)+#define Z7_CONV_NATIVE_TO_BE_32(v) (v)+#elif defined(MY_CPU_LE)+#define Z7_CONV_BE_TO_NATIVE_CONST32(v) Z7_BSWAP32_CONST(v)+#define Z7_CONV_LE_TO_NATIVE_CONST32(v) (v)+#define Z7_CONV_NATIVE_TO_BE_32(v) Z7_BSWAP32(v)+#else+#error Stop_Compiling_Unknown_Endian_CONV+#endif+++#if defined(MY_CPU_BE)++#define GetBe32a(p) (*(const UInt32 *)(const void *)(p))+#define GetBe16a(p) (*(const UInt16 *)(const void *)(p))+#define SetBe32a(p, v) { *(UInt32 *)(void *)(p) = (v); }+#define SetBe16a(p, v) { *(UInt16 *)(void *)(p) = (v); }++#define GetUi32a(p) GetUi32(p)+#define GetUi16a(p) GetUi16(p)+#define SetUi32a(p, v) SetUi32(p, v)+#define SetUi16a(p, v) SetUi16(p, v)++#elif defined(MY_CPU_LE)++#define GetUi32a(p) (*(const UInt32 *)(const void *)(p))+#define GetUi16a(p) (*(const UInt16 *)(const void *)(p))+#define SetUi32a(p, v) { *(UInt32 *)(void *)(p) = (v); }+#define SetUi16a(p, v) { *(UInt16 *)(void *)(p) = (v); }++#define GetBe32a(p) GetBe32(p)+#define GetBe16a(p) GetBe16(p)+#define SetBe32a(p, v) SetBe32(p, v)+#define SetBe16a(p, v) SetBe16(p, v)++#else+#error Stop_Compiling_Unknown_Endian_CPU_a+#endif+++#if defined(MY_CPU_X86_OR_AMD64) \+ || defined(MY_CPU_ARM_OR_ARM64) \+ || defined(MY_CPU_PPC_OR_PPC64)+ #define Z7_CPU_FAST_ROTATE_SUPPORTED+#endif+++#ifdef MY_CPU_X86_OR_AMD64++void Z7_FASTCALL z7_x86_cpuid(UInt32 a[4], UInt32 function);+UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void);+#if defined(MY_CPU_AMD64)+#define Z7_IF_X86_CPUID_SUPPORTED+#else+#define Z7_IF_X86_CPUID_SUPPORTED if (z7_x86_cpuid_GetMaxFunc())+#endif++BoolInt CPU_IsSupported_AES(void);+BoolInt CPU_IsSupported_AVX(void);+BoolInt CPU_IsSupported_AVX2(void);+BoolInt CPU_IsSupported_VAES_AVX2(void);+BoolInt CPU_IsSupported_CMOV(void);+BoolInt CPU_IsSupported_SSE(void);+BoolInt CPU_IsSupported_SSE2(void);+BoolInt CPU_IsSupported_SSSE3(void);+BoolInt CPU_IsSupported_SSE41(void);+BoolInt CPU_IsSupported_SHA(void);+BoolInt CPU_IsSupported_PageGB(void);++#elif defined(MY_CPU_ARM_OR_ARM64)++BoolInt CPU_IsSupported_CRC32(void);+BoolInt CPU_IsSupported_NEON(void);++#if defined(_WIN32)+BoolInt CPU_IsSupported_CRYPTO(void);+#define CPU_IsSupported_SHA1 CPU_IsSupported_CRYPTO+#define CPU_IsSupported_SHA2 CPU_IsSupported_CRYPTO+#define CPU_IsSupported_AES CPU_IsSupported_CRYPTO+#else+BoolInt CPU_IsSupported_SHA1(void);+BoolInt CPU_IsSupported_SHA2(void);+BoolInt CPU_IsSupported_AES(void);+#endif++#endif++#if defined(__APPLE__)+int z7_sysctlbyname_Get(const char *name, void *buf, size_t *bufSize);+int z7_sysctlbyname_Get_UInt32(const char *name, UInt32 *val);+#endif++EXTERN_C_END++#endif
@@ -0,0 +1,169 @@+/* Delta.c -- Delta converter+2021-02-09 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include "Delta.h"++void Delta_Init(Byte *state)+{+ unsigned i;+ for (i = 0; i < DELTA_STATE_SIZE; i++)+ state[i] = 0;+}+++void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size)+{+ Byte temp[DELTA_STATE_SIZE];++ if (size == 0)+ return;++ {+ unsigned i = 0;+ do+ temp[i] = state[i];+ while (++i != delta);+ }++ if (size <= delta)+ {+ unsigned i = 0, k;+ do+ {+ Byte b = *data;+ *data++ = (Byte)(b - temp[i]);+ temp[i] = b;+ }+ while (++i != size);+ + k = 0;+ + do+ {+ if (i == delta)+ i = 0;+ state[k] = temp[i++];+ }+ while (++k != delta);+ + return;+ }+ + {+ Byte *p = data + size - delta;+ {+ unsigned i = 0;+ do+ state[i] = *p++;+ while (++i != delta);+ }+ {+ const Byte *lim = data + delta;+ ptrdiff_t dif = -(ptrdiff_t)delta;+ + if (((ptrdiff_t)size + dif) & 1)+ {+ --p; *p = (Byte)(*p - p[dif]);+ }++ while (p != lim)+ {+ --p; *p = (Byte)(*p - p[dif]);+ --p; *p = (Byte)(*p - p[dif]);+ }+ + dif = -dif;+ + do+ {+ --p; *p = (Byte)(*p - temp[--dif]);+ }+ while (dif != 0);+ }+ }+}+++void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size)+{+ unsigned i;+ const Byte *lim;++ if (size == 0)+ return;+ + i = 0;+ lim = data + size;+ + if (size <= delta)+ {+ do+ *data = (Byte)(*data + state[i++]);+ while (++data != lim);++ for (; delta != i; state++, delta--)+ *state = state[i];+ data -= i;+ }+ else+ {+ /*+ #define B(n) b ## n+ #define I(n) Byte B(n) = state[n];+ #define U(n) { B(n) = (Byte)((B(n)) + *data++); data[-1] = (B(n)); }+ #define F(n) if (data != lim) { U(n) }++ if (delta == 1)+ {+ I(0)+ if ((lim - data) & 1) { U(0) }+ while (data != lim) { U(0) U(0) }+ data -= 1;+ }+ else if (delta == 2)+ {+ I(0) I(1)+ lim -= 1; while (data < lim) { U(0) U(1) }+ lim += 1; F(0)+ data -= 2;+ }+ else if (delta == 3)+ {+ I(0) I(1) I(2)+ lim -= 2; while (data < lim) { U(0) U(1) U(2) }+ lim += 2; F(0) F(1)+ data -= 3;+ }+ else if (delta == 4)+ {+ I(0) I(1) I(2) I(3)+ lim -= 3; while (data < lim) { U(0) U(1) U(2) U(3) }+ lim += 3; F(0) F(1) F(2)+ data -= 4;+ }+ else+ */+ {+ do+ {+ *data = (Byte)(*data + state[i++]);+ data++;+ }+ while (i != delta);+ + {+ ptrdiff_t dif = -(ptrdiff_t)delta;+ do+ *data = (Byte)(*data + data[dif]);+ while (++data != lim);+ data += dif;+ }+ }+ }++ do+ *state++ = *data;+ while (++data != lim);+}
@@ -0,0 +1,19 @@+/* Delta.h -- Delta converter+2023-03-03 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_DELTA_H+#define ZIP7_INC_DELTA_H++#include "7zTypes.h"++EXTERN_C_BEGIN++#define DELTA_STATE_SIZE 256++void Delta_Init(Byte *state);+void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size);+void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size);++EXTERN_C_END++#endif
@@ -0,0 +1,491 @@+/* Lzma2Dec.c -- LZMA2 Decoder+2023-03-03 : Igor Pavlov : Public domain */++/* #define SHOW_DEBUG_INFO */++#include "Precomp.h"++#ifdef SHOW_DEBUG_INFO+#include <stdio.h>+#endif++#include <string.h>++#include "Lzma2Dec.h"++/*+00000000 - End of data+00000001 U U - Uncompressed, reset dic, need reset state and set new prop+00000010 U U - Uncompressed, no reset+100uuuuu U U P P - LZMA, no reset+101uuuuu U U P P - LZMA, reset state+110uuuuu U U P P S - LZMA, reset state + set new prop+111uuuuu U U P P S - LZMA, reset state + set new prop, reset dic++ u, U - Unpack Size+ P - Pack Size+ S - Props+*/++#define LZMA2_CONTROL_COPY_RESET_DIC 1++#define LZMA2_IS_UNCOMPRESSED_STATE(p) (((p)->control & (1 << 7)) == 0)++#define LZMA2_LCLP_MAX 4+#define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))++#ifdef SHOW_DEBUG_INFO+#define PRF(x) x+#else+#define PRF(x)+#endif++typedef enum+{+ LZMA2_STATE_CONTROL,+ LZMA2_STATE_UNPACK0,+ LZMA2_STATE_UNPACK1,+ LZMA2_STATE_PACK0,+ LZMA2_STATE_PACK1,+ LZMA2_STATE_PROP,+ LZMA2_STATE_DATA,+ LZMA2_STATE_DATA_CONT,+ LZMA2_STATE_FINISHED,+ LZMA2_STATE_ERROR+} ELzma2State;++static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props)+{+ UInt32 dicSize;+ if (prop > 40)+ return SZ_ERROR_UNSUPPORTED;+ dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop);+ props[0] = (Byte)LZMA2_LCLP_MAX;+ props[1] = (Byte)(dicSize);+ props[2] = (Byte)(dicSize >> 8);+ props[3] = (Byte)(dicSize >> 16);+ props[4] = (Byte)(dicSize >> 24);+ return SZ_OK;+}++SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc)+{+ Byte props[LZMA_PROPS_SIZE];+ RINOK(Lzma2Dec_GetOldProps(prop, props))+ return LzmaDec_AllocateProbs(&p->decoder, props, LZMA_PROPS_SIZE, alloc);+}++SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc)+{+ Byte props[LZMA_PROPS_SIZE];+ RINOK(Lzma2Dec_GetOldProps(prop, props))+ return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc);+}++void Lzma2Dec_Init(CLzma2Dec *p)+{+ p->state = LZMA2_STATE_CONTROL;+ p->needInitLevel = 0xE0;+ p->isExtraMode = False;+ p->unpackSize = 0;+ + // p->decoder.dicPos = 0; // we can use it instead of full init+ LzmaDec_Init(&p->decoder);+}++// ELzma2State+static unsigned Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)+{+ switch (p->state)+ {+ case LZMA2_STATE_CONTROL:+ p->isExtraMode = False;+ p->control = b;+ PRF(printf("\n %8X", (unsigned)p->decoder.dicPos));+ PRF(printf(" %02X", (unsigned)b));+ if (b == 0)+ return LZMA2_STATE_FINISHED;+ if (LZMA2_IS_UNCOMPRESSED_STATE(p))+ {+ if (b == LZMA2_CONTROL_COPY_RESET_DIC)+ p->needInitLevel = 0xC0;+ else if (b > 2 || p->needInitLevel == 0xE0)+ return LZMA2_STATE_ERROR;+ }+ else+ {+ if (b < p->needInitLevel)+ return LZMA2_STATE_ERROR;+ p->needInitLevel = 0;+ p->unpackSize = (UInt32)(b & 0x1F) << 16;+ }+ return LZMA2_STATE_UNPACK0;+ + case LZMA2_STATE_UNPACK0:+ p->unpackSize |= (UInt32)b << 8;+ return LZMA2_STATE_UNPACK1;+ + case LZMA2_STATE_UNPACK1:+ p->unpackSize |= (UInt32)b;+ p->unpackSize++;+ PRF(printf(" %7u", (unsigned)p->unpackSize));+ return LZMA2_IS_UNCOMPRESSED_STATE(p) ? LZMA2_STATE_DATA : LZMA2_STATE_PACK0;+ + case LZMA2_STATE_PACK0:+ p->packSize = (UInt32)b << 8;+ return LZMA2_STATE_PACK1;++ case LZMA2_STATE_PACK1:+ p->packSize |= (UInt32)b;+ p->packSize++;+ // if (p->packSize < 5) return LZMA2_STATE_ERROR;+ PRF(printf(" %5u", (unsigned)p->packSize));+ return (p->control & 0x40) ? LZMA2_STATE_PROP : LZMA2_STATE_DATA;++ case LZMA2_STATE_PROP:+ {+ unsigned lc, lp;+ if (b >= (9 * 5 * 5))+ return LZMA2_STATE_ERROR;+ lc = b % 9;+ b /= 9;+ p->decoder.prop.pb = (Byte)(b / 5);+ lp = b % 5;+ if (lc + lp > LZMA2_LCLP_MAX)+ return LZMA2_STATE_ERROR;+ p->decoder.prop.lc = (Byte)lc;+ p->decoder.prop.lp = (Byte)lp;+ return LZMA2_STATE_DATA;+ }+ }+ return LZMA2_STATE_ERROR;+}++static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT size)+{+ memcpy(p->dic + p->dicPos, src, size);+ p->dicPos += size;+ if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size)+ p->checkDicSize = p->prop.dicSize;+ p->processedPos += (UInt32)size;+}++void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState);+++SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,+ const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)+{+ SizeT inSize = *srcLen;+ *srcLen = 0;+ *status = LZMA_STATUS_NOT_SPECIFIED;++ while (p->state != LZMA2_STATE_ERROR)+ {+ SizeT dicPos;++ if (p->state == LZMA2_STATE_FINISHED)+ {+ *status = LZMA_STATUS_FINISHED_WITH_MARK;+ return SZ_OK;+ }+ + dicPos = p->decoder.dicPos;+ + if (dicPos == dicLimit && finishMode == LZMA_FINISH_ANY)+ {+ *status = LZMA_STATUS_NOT_FINISHED;+ return SZ_OK;+ }++ if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT)+ {+ if (*srcLen == inSize)+ {+ *status = LZMA_STATUS_NEEDS_MORE_INPUT;+ return SZ_OK;+ }+ (*srcLen)++;+ p->state = Lzma2Dec_UpdateState(p, *src++);+ if (dicPos == dicLimit && p->state != LZMA2_STATE_FINISHED)+ break;+ continue;+ }+ + {+ SizeT inCur = inSize - *srcLen;+ SizeT outCur = dicLimit - dicPos;+ ELzmaFinishMode curFinishMode = LZMA_FINISH_ANY;+ + if (outCur >= p->unpackSize)+ {+ outCur = (SizeT)p->unpackSize;+ curFinishMode = LZMA_FINISH_END;+ }++ if (LZMA2_IS_UNCOMPRESSED_STATE(p))+ {+ if (inCur == 0)+ {+ *status = LZMA_STATUS_NEEDS_MORE_INPUT;+ return SZ_OK;+ }++ if (p->state == LZMA2_STATE_DATA)+ {+ BoolInt initDic = (p->control == LZMA2_CONTROL_COPY_RESET_DIC);+ LzmaDec_InitDicAndState(&p->decoder, initDic, False);+ }++ if (inCur > outCur)+ inCur = outCur;+ if (inCur == 0)+ break;++ LzmaDec_UpdateWithUncompressed(&p->decoder, src, inCur);++ src += inCur;+ *srcLen += inCur;+ p->unpackSize -= (UInt32)inCur;+ p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;+ }+ else+ {+ SRes res;++ if (p->state == LZMA2_STATE_DATA)+ {+ BoolInt initDic = (p->control >= 0xE0);+ BoolInt initState = (p->control >= 0xA0);+ LzmaDec_InitDicAndState(&p->decoder, initDic, initState);+ p->state = LZMA2_STATE_DATA_CONT;+ }+ + if (inCur > p->packSize)+ inCur = (SizeT)p->packSize;+ + res = LzmaDec_DecodeToDic(&p->decoder, dicPos + outCur, src, &inCur, curFinishMode, status);++ src += inCur;+ *srcLen += inCur;+ p->packSize -= (UInt32)inCur;+ outCur = p->decoder.dicPos - dicPos;+ p->unpackSize -= (UInt32)outCur;++ if (res != 0)+ break;+ + if (*status == LZMA_STATUS_NEEDS_MORE_INPUT)+ {+ if (p->packSize == 0)+ break;+ return SZ_OK;+ }++ if (inCur == 0 && outCur == 0)+ {+ if (*status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK+ || p->unpackSize != 0+ || p->packSize != 0)+ break;+ p->state = LZMA2_STATE_CONTROL;+ }+ + *status = LZMA_STATUS_NOT_SPECIFIED;+ }+ }+ }+ + *status = LZMA_STATUS_NOT_SPECIFIED;+ p->state = LZMA2_STATE_ERROR;+ return SZ_ERROR_DATA;+}+++++ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p,+ SizeT outSize,+ const Byte *src, SizeT *srcLen,+ int checkFinishBlock)+{+ SizeT inSize = *srcLen;+ *srcLen = 0;++ while (p->state != LZMA2_STATE_ERROR)+ {+ if (p->state == LZMA2_STATE_FINISHED)+ return (ELzma2ParseStatus)LZMA_STATUS_FINISHED_WITH_MARK;++ if (outSize == 0 && !checkFinishBlock)+ return (ELzma2ParseStatus)LZMA_STATUS_NOT_FINISHED;+ + if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT)+ {+ if (*srcLen == inSize)+ return (ELzma2ParseStatus)LZMA_STATUS_NEEDS_MORE_INPUT;+ (*srcLen)++;++ p->state = Lzma2Dec_UpdateState(p, *src++);++ if (p->state == LZMA2_STATE_UNPACK0)+ {+ // if (p->decoder.dicPos != 0)+ if (p->control == LZMA2_CONTROL_COPY_RESET_DIC || p->control >= 0xE0)+ return LZMA2_PARSE_STATUS_NEW_BLOCK;+ // if (outSize == 0) return LZMA_STATUS_NOT_FINISHED;+ }++ // The following code can be commented.+ // It's not big problem, if we read additional input bytes.+ // It will be stopped later in LZMA2_STATE_DATA / LZMA2_STATE_DATA_CONT state.++ if (outSize == 0 && p->state != LZMA2_STATE_FINISHED)+ {+ // checkFinishBlock is true. So we expect that block must be finished,+ // We can return LZMA_STATUS_NOT_SPECIFIED or LZMA_STATUS_NOT_FINISHED here+ // break;+ return (ELzma2ParseStatus)LZMA_STATUS_NOT_FINISHED;+ }++ if (p->state == LZMA2_STATE_DATA)+ return LZMA2_PARSE_STATUS_NEW_CHUNK;++ continue;+ }++ if (outSize == 0)+ return (ELzma2ParseStatus)LZMA_STATUS_NOT_FINISHED;++ {+ SizeT inCur = inSize - *srcLen;++ if (LZMA2_IS_UNCOMPRESSED_STATE(p))+ {+ if (inCur == 0)+ return (ELzma2ParseStatus)LZMA_STATUS_NEEDS_MORE_INPUT;+ if (inCur > p->unpackSize)+ inCur = p->unpackSize;+ if (inCur > outSize)+ inCur = outSize;+ p->decoder.dicPos += inCur;+ src += inCur;+ *srcLen += inCur;+ outSize -= inCur;+ p->unpackSize -= (UInt32)inCur;+ p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;+ }+ else+ {+ p->isExtraMode = True;++ if (inCur == 0)+ {+ if (p->packSize != 0)+ return (ELzma2ParseStatus)LZMA_STATUS_NEEDS_MORE_INPUT;+ }+ else if (p->state == LZMA2_STATE_DATA)+ {+ p->state = LZMA2_STATE_DATA_CONT;+ if (*src != 0)+ {+ // first byte of lzma chunk must be Zero+ *srcLen += 1;+ p->packSize--;+ break;+ }+ }+ + if (inCur > p->packSize)+ inCur = (SizeT)p->packSize;++ src += inCur;+ *srcLen += inCur;+ p->packSize -= (UInt32)inCur;++ if (p->packSize == 0)+ {+ SizeT rem = outSize;+ if (rem > p->unpackSize)+ rem = p->unpackSize;+ p->decoder.dicPos += rem;+ p->unpackSize -= (UInt32)rem;+ outSize -= rem;+ if (p->unpackSize == 0)+ p->state = LZMA2_STATE_CONTROL;+ }+ }+ }+ }+ + p->state = LZMA2_STATE_ERROR;+ return (ELzma2ParseStatus)LZMA_STATUS_NOT_SPECIFIED;+}+++++SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)+{+ SizeT outSize = *destLen, inSize = *srcLen;+ *srcLen = *destLen = 0;+ + for (;;)+ {+ SizeT inCur = inSize, outCur, dicPos;+ ELzmaFinishMode curFinishMode;+ SRes res;+ + if (p->decoder.dicPos == p->decoder.dicBufSize)+ p->decoder.dicPos = 0;+ dicPos = p->decoder.dicPos;+ curFinishMode = LZMA_FINISH_ANY;+ outCur = p->decoder.dicBufSize - dicPos;+ + if (outCur >= outSize)+ {+ outCur = outSize;+ curFinishMode = finishMode;+ }++ res = Lzma2Dec_DecodeToDic(p, dicPos + outCur, src, &inCur, curFinishMode, status);+ + src += inCur;+ inSize -= inCur;+ *srcLen += inCur;+ outCur = p->decoder.dicPos - dicPos;+ memcpy(dest, p->decoder.dic + dicPos, outCur);+ dest += outCur;+ outSize -= outCur;+ *destLen += outCur;+ if (res != 0)+ return res;+ if (outCur == 0 || outSize == 0)+ return SZ_OK;+ }+}+++SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,+ Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAllocPtr alloc)+{+ CLzma2Dec p;+ SRes res;+ SizeT outSize = *destLen, inSize = *srcLen;+ *destLen = *srcLen = 0;+ *status = LZMA_STATUS_NOT_SPECIFIED;+ Lzma2Dec_CONSTRUCT(&p)+ RINOK(Lzma2Dec_AllocateProbs(&p, prop, alloc))+ p.decoder.dic = dest;+ p.decoder.dicBufSize = outSize;+ Lzma2Dec_Init(&p);+ *srcLen = inSize;+ res = Lzma2Dec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);+ *destLen = p.decoder.dicPos;+ if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)+ res = SZ_ERROR_INPUT_EOF;+ Lzma2Dec_FreeProbs(&p, alloc);+ return res;+}++#undef PRF
@@ -0,0 +1,121 @@+/* Lzma2Dec.h -- LZMA2 Decoder+2023-03-03 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_LZMA2_DEC_H+#define ZIP7_INC_LZMA2_DEC_H++#include "LzmaDec.h"++EXTERN_C_BEGIN++/* ---------- State Interface ---------- */++typedef struct+{+ unsigned state;+ Byte control;+ Byte needInitLevel;+ Byte isExtraMode;+ Byte _pad_;+ UInt32 packSize;+ UInt32 unpackSize;+ CLzmaDec decoder;+} CLzma2Dec;++#define Lzma2Dec_CONSTRUCT(p) LzmaDec_CONSTRUCT(&(p)->decoder)+#define Lzma2Dec_Construct(p) Lzma2Dec_CONSTRUCT(p)+#define Lzma2Dec_FreeProbs(p, alloc) LzmaDec_FreeProbs(&(p)->decoder, alloc)+#define Lzma2Dec_Free(p, alloc) LzmaDec_Free(&(p)->decoder, alloc)++SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc);+SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc);+void Lzma2Dec_Init(CLzma2Dec *p);++/*+finishMode:+ It has meaning only if the decoding reaches output limit (*destLen or dicLimit).+ LZMA_FINISH_ANY - use smallest number of input bytes+ LZMA_FINISH_END - read EndOfStream marker after decoding++Returns:+ SZ_OK+ status:+ LZMA_STATUS_FINISHED_WITH_MARK+ LZMA_STATUS_NOT_FINISHED+ LZMA_STATUS_NEEDS_MORE_INPUT+ SZ_ERROR_DATA - Data error+*/++SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,+ const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);++SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen,+ const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);+++/* ---------- LZMA2 block and chunk parsing ---------- */++/*+Lzma2Dec_Parse() parses compressed data stream up to next independent block or next chunk data.+It can return LZMA_STATUS_* code or LZMA2_PARSE_STATUS_* code:+ - LZMA2_PARSE_STATUS_NEW_BLOCK - there is new block, and 1 additional byte (control byte of next block header) was read from input.+ - LZMA2_PARSE_STATUS_NEW_CHUNK - there is new chunk, and only lzma2 header of new chunk was read.+ CLzma2Dec::unpackSize contains unpack size of that chunk+*/++typedef enum+{+/*+ LZMA_STATUS_NOT_SPECIFIED // data error+ LZMA_STATUS_FINISHED_WITH_MARK+ LZMA_STATUS_NOT_FINISHED //+ LZMA_STATUS_NEEDS_MORE_INPUT+ LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK // unused+*/+ LZMA2_PARSE_STATUS_NEW_BLOCK = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK + 1,+ LZMA2_PARSE_STATUS_NEW_CHUNK+} ELzma2ParseStatus;++ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p,+ SizeT outSize, // output size+ const Byte *src, SizeT *srcLen,+ int checkFinishBlock // set (checkFinishBlock = 1), if it must read full input data, if decoder.dicPos reaches blockMax position.+ );++/*+LZMA2 parser doesn't decode LZMA chunks, so we must read+ full input LZMA chunk to decode some part of LZMA chunk.++Lzma2Dec_GetUnpackExtra() returns the value that shows+ max possible number of output bytes that can be output by decoder+ at current input positon.+*/++#define Lzma2Dec_GetUnpackExtra(p) ((p)->isExtraMode ? (p)->unpackSize : 0)+++/* ---------- One Call Interface ---------- */++/*+finishMode:+ It has meaning only if the decoding reaches output limit (*destLen).+ LZMA_FINISH_ANY - use smallest number of input bytes+ LZMA_FINISH_END - read EndOfStream marker after decoding++Returns:+ SZ_OK+ status:+ LZMA_STATUS_FINISHED_WITH_MARK+ LZMA_STATUS_NOT_FINISHED+ SZ_ERROR_DATA - Data error+ SZ_ERROR_MEM - Memory allocation error+ SZ_ERROR_UNSUPPORTED - Unsupported properties+ SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).+*/++SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,+ Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAllocPtr alloc);++EXTERN_C_END++#endif
@@ -0,0 +1,1363 @@+/* LzmaDec.c -- LZMA Decoder+2023-04-07 : Igor Pavlov : Public domain */++#include "Precomp.h"++#include <string.h>++/* #include "CpuArch.h" */+#include "LzmaDec.h"++// #define kNumTopBits 24+#define kTopValue ((UInt32)1 << 24)++#define kNumBitModelTotalBits 11+#define kBitModelTotal (1 << kNumBitModelTotalBits)++#define RC_INIT_SIZE 5++#ifndef Z7_LZMA_DEC_OPT++#define kNumMoveBits 5+#define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }++#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound)+#define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));+#define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits));+#define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \+ { UPDATE_0(p) i = (i + i); A0; } else \+ { UPDATE_1(p) i = (i + i) + 1; A1; }++#define TREE_GET_BIT(probs, i) { GET_BIT2(probs + i, i, ;, ;); }++#define REV_BIT(p, i, A0, A1) IF_BIT_0(p + i) \+ { UPDATE_0(p + i) A0; } else \+ { UPDATE_1(p + i) A1; }+#define REV_BIT_VAR( p, i, m) REV_BIT(p, i, i += m; m += m, m += m; i += m; )+#define REV_BIT_CONST(p, i, m) REV_BIT(p, i, i += m; , i += m * 2; )+#define REV_BIT_LAST( p, i, m) REV_BIT(p, i, i -= m , ; )++#define TREE_DECODE(probs, limit, i) \+ { i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; }++/* #define Z7_LZMA_SIZE_OPT */++#ifdef Z7_LZMA_SIZE_OPT+#define TREE_6_DECODE(probs, i) TREE_DECODE(probs, (1 << 6), i)+#else+#define TREE_6_DECODE(probs, i) \+ { i = 1; \+ TREE_GET_BIT(probs, i) \+ TREE_GET_BIT(probs, i) \+ TREE_GET_BIT(probs, i) \+ TREE_GET_BIT(probs, i) \+ TREE_GET_BIT(probs, i) \+ TREE_GET_BIT(probs, i) \+ i -= 0x40; }+#endif++#define NORMAL_LITER_DEC TREE_GET_BIT(prob, symbol)+#define MATCHED_LITER_DEC \+ matchByte += matchByte; \+ bit = offs; \+ offs &= matchByte; \+ probLit = prob + (offs + bit + symbol); \+ GET_BIT2(probLit, symbol, offs ^= bit; , ;)++#endif // Z7_LZMA_DEC_OPT+++#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_INPUT_EOF; range <<= 8; code = (code << 8) | (*buf++); }++#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK bound = (range >> kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound)+#define UPDATE_0_CHECK range = bound;+#define UPDATE_1_CHECK range -= bound; code -= bound;+#define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \+ { UPDATE_0_CHECK i = (i + i); A0; } else \+ { UPDATE_1_CHECK i = (i + i) + 1; A1; }+#define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;)+#define TREE_DECODE_CHECK(probs, limit, i) \+ { i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; }+++#define REV_BIT_CHECK(p, i, m) IF_BIT_0_CHECK(p + i) \+ { UPDATE_0_CHECK i += m; m += m; } else \+ { UPDATE_1_CHECK m += m; i += m; }+++#define kNumPosBitsMax 4+#define kNumPosStatesMax (1 << kNumPosBitsMax)++#define kLenNumLowBits 3+#define kLenNumLowSymbols (1 << kLenNumLowBits)+#define kLenNumHighBits 8+#define kLenNumHighSymbols (1 << kLenNumHighBits)++#define LenLow 0+#define LenHigh (LenLow + 2 * (kNumPosStatesMax << kLenNumLowBits))+#define kNumLenProbs (LenHigh + kLenNumHighSymbols)++#define LenChoice LenLow+#define LenChoice2 (LenLow + (1 << kLenNumLowBits))++#define kNumStates 12+#define kNumStates2 16+#define kNumLitStates 7++#define kStartPosModelIndex 4+#define kEndPosModelIndex 14+#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))++#define kNumPosSlotBits 6+#define kNumLenToPosStates 4++#define kNumAlignBits 4+#define kAlignTableSize (1 << kNumAlignBits)++#define kMatchMinLen 2+#define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols * 2 + kLenNumHighSymbols)++#define kMatchSpecLen_Error_Data (1 << 9)+#define kMatchSpecLen_Error_Fail (kMatchSpecLen_Error_Data - 1)++/* External ASM code needs same CLzmaProb array layout. So don't change it. */++/* (probs_1664) is faster and better for code size at some platforms */+/*+#ifdef MY_CPU_X86_OR_AMD64+*/+#define kStartOffset 1664+#define GET_PROBS p->probs_1664+/*+#define GET_PROBS p->probs + kStartOffset+#else+#define kStartOffset 0+#define GET_PROBS p->probs+#endif+*/++#define SpecPos (-kStartOffset)+#define IsRep0Long (SpecPos + kNumFullDistances)+#define RepLenCoder (IsRep0Long + (kNumStates2 << kNumPosBitsMax))+#define LenCoder (RepLenCoder + kNumLenProbs)+#define IsMatch (LenCoder + kNumLenProbs)+#define Align (IsMatch + (kNumStates2 << kNumPosBitsMax))+#define IsRep (Align + kAlignTableSize)+#define IsRepG0 (IsRep + kNumStates)+#define IsRepG1 (IsRepG0 + kNumStates)+#define IsRepG2 (IsRepG1 + kNumStates)+#define PosSlot (IsRepG2 + kNumStates)+#define Literal (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))+#define NUM_BASE_PROBS (Literal + kStartOffset)++#if Align != 0 && kStartOffset != 0+ #error Stop_Compiling_Bad_LZMA_kAlign+#endif++#if NUM_BASE_PROBS != 1984+ #error Stop_Compiling_Bad_LZMA_PROBS+#endif+++#define LZMA_LIT_SIZE 0x300++#define LzmaProps_GetNumProbs(p) (NUM_BASE_PROBS + ((UInt32)LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))+++#define CALC_POS_STATE(processedPos, pbMask) (((processedPos) & (pbMask)) << 4)+#define COMBINED_PS_STATE (posState + state)+#define GET_LEN_STATE (posState)++#define LZMA_DIC_MIN (1 << 12)++/*+p->remainLen : shows status of LZMA decoder:+ < kMatchSpecLenStart : the number of bytes to be copied with (p->rep0) offset+ = kMatchSpecLenStart : the LZMA stream was finished with end mark+ = kMatchSpecLenStart + 1 : need init range coder+ = kMatchSpecLenStart + 2 : need init range coder and state+ = kMatchSpecLen_Error_Fail : Internal Code Failure+ = kMatchSpecLen_Error_Data + [0 ... 273] : LZMA Data Error+*/++/* ---------- LZMA_DECODE_REAL ---------- */+/*+LzmaDec_DecodeReal_3() can be implemented in external ASM file.+3 - is the code compatibility version of that function for check at link time.+*/++#define LZMA_DECODE_REAL LzmaDec_DecodeReal_3++/*+LZMA_DECODE_REAL()+In:+ RangeCoder is normalized+ if (p->dicPos == limit)+ {+ LzmaDec_TryDummy() was called before to exclude LITERAL and MATCH-REP cases.+ So first symbol can be only MATCH-NON-REP. And if that MATCH-NON-REP symbol+ is not END_OF_PAYALOAD_MARKER, then the function doesn't write any byte to dictionary,+ the function returns SZ_OK, and the caller can use (p->remainLen) and (p->reps[0]) later.+ }++Processing:+ The first LZMA symbol will be decoded in any case.+ All main checks for limits are at the end of main loop,+ It decodes additional LZMA-symbols while (p->buf < bufLimit && dicPos < limit),+ RangeCoder is still without last normalization when (p->buf < bufLimit) is being checked.+ But if (p->buf < bufLimit), the caller provided at least (LZMA_REQUIRED_INPUT_MAX + 1) bytes for+ next iteration before limit (bufLimit + LZMA_REQUIRED_INPUT_MAX),+ that is enough for worst case LZMA symbol with one additional RangeCoder normalization for one bit.+ So that function never reads bufLimit [LZMA_REQUIRED_INPUT_MAX] byte.++Out:+ RangeCoder is normalized+ Result:+ SZ_OK - OK+ p->remainLen:+ < kMatchSpecLenStart : the number of bytes to be copied with (p->reps[0]) offset+ = kMatchSpecLenStart : the LZMA stream was finished with end mark++ SZ_ERROR_DATA - error, when the MATCH-Symbol refers out of dictionary+ p->remainLen : undefined+ p->reps[*] : undefined+*/+++#ifdef Z7_LZMA_DEC_OPT++int Z7_FASTCALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit);++#else++static+int Z7_FASTCALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit)+{+ CLzmaProb *probs = GET_PROBS;+ unsigned state = (unsigned)p->state;+ UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];+ unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;+ unsigned lc = p->prop.lc;+ unsigned lpMask = ((unsigned)0x100 << p->prop.lp) - ((unsigned)0x100 >> lc);++ Byte *dic = p->dic;+ SizeT dicBufSize = p->dicBufSize;+ SizeT dicPos = p->dicPos;+ + UInt32 processedPos = p->processedPos;+ UInt32 checkDicSize = p->checkDicSize;+ unsigned len = 0;++ const Byte *buf = p->buf;+ UInt32 range = p->range;+ UInt32 code = p->code;++ do+ {+ CLzmaProb *prob;+ UInt32 bound;+ unsigned ttt;+ unsigned posState = CALC_POS_STATE(processedPos, pbMask);++ prob = probs + IsMatch + COMBINED_PS_STATE;+ IF_BIT_0(prob)+ {+ unsigned symbol;+ UPDATE_0(prob)+ prob = probs + Literal;+ if (processedPos != 0 || checkDicSize != 0)+ prob += (UInt32)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);+ processedPos++;++ if (state < kNumLitStates)+ {+ state -= (state < 4) ? state : 3;+ symbol = 1;+ #ifdef Z7_LZMA_SIZE_OPT+ do { NORMAL_LITER_DEC } while (symbol < 0x100);+ #else+ NORMAL_LITER_DEC+ NORMAL_LITER_DEC+ NORMAL_LITER_DEC+ NORMAL_LITER_DEC+ NORMAL_LITER_DEC+ NORMAL_LITER_DEC+ NORMAL_LITER_DEC+ NORMAL_LITER_DEC+ #endif+ }+ else+ {+ unsigned matchByte = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];+ unsigned offs = 0x100;+ state -= (state < 10) ? 3 : 6;+ symbol = 1;+ #ifdef Z7_LZMA_SIZE_OPT+ do+ {+ unsigned bit;+ CLzmaProb *probLit;+ MATCHED_LITER_DEC+ }+ while (symbol < 0x100);+ #else+ {+ unsigned bit;+ CLzmaProb *probLit;+ MATCHED_LITER_DEC+ MATCHED_LITER_DEC+ MATCHED_LITER_DEC+ MATCHED_LITER_DEC+ MATCHED_LITER_DEC+ MATCHED_LITER_DEC+ MATCHED_LITER_DEC+ MATCHED_LITER_DEC+ }+ #endif+ }++ dic[dicPos++] = (Byte)symbol;+ continue;+ }+ + {+ UPDATE_1(prob)+ prob = probs + IsRep + state;+ IF_BIT_0(prob)+ {+ UPDATE_0(prob)+ state += kNumStates;+ prob = probs + LenCoder;+ }+ else+ {+ UPDATE_1(prob)+ prob = probs + IsRepG0 + state;+ IF_BIT_0(prob)+ {+ UPDATE_0(prob)+ prob = probs + IsRep0Long + COMBINED_PS_STATE;+ IF_BIT_0(prob)+ {+ UPDATE_0(prob)+ + // that case was checked before with kBadRepCode+ // if (checkDicSize == 0 && processedPos == 0) { len = kMatchSpecLen_Error_Data + 1; break; }+ // The caller doesn't allow (dicPos == limit) case here+ // so we don't need the following check:+ // if (dicPos == limit) { state = state < kNumLitStates ? 9 : 11; len = 1; break; }+ + dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];+ dicPos++;+ processedPos++;+ state = state < kNumLitStates ? 9 : 11;+ continue;+ }+ UPDATE_1(prob)+ }+ else+ {+ UInt32 distance;+ UPDATE_1(prob)+ prob = probs + IsRepG1 + state;+ IF_BIT_0(prob)+ {+ UPDATE_0(prob)+ distance = rep1;+ }+ else+ {+ UPDATE_1(prob)+ prob = probs + IsRepG2 + state;+ IF_BIT_0(prob)+ {+ UPDATE_0(prob)+ distance = rep2;+ }+ else+ {+ UPDATE_1(prob)+ distance = rep3;+ rep3 = rep2;+ }+ rep2 = rep1;+ }+ rep1 = rep0;+ rep0 = distance;+ }+ state = state < kNumLitStates ? 8 : 11;+ prob = probs + RepLenCoder;+ }+ + #ifdef Z7_LZMA_SIZE_OPT+ {+ unsigned lim, offset;+ CLzmaProb *probLen = prob + LenChoice;+ IF_BIT_0(probLen)+ {+ UPDATE_0(probLen)+ probLen = prob + LenLow + GET_LEN_STATE;+ offset = 0;+ lim = (1 << kLenNumLowBits);+ }+ else+ {+ UPDATE_1(probLen)+ probLen = prob + LenChoice2;+ IF_BIT_0(probLen)+ {+ UPDATE_0(probLen)+ probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);+ offset = kLenNumLowSymbols;+ lim = (1 << kLenNumLowBits);+ }+ else+ {+ UPDATE_1(probLen)+ probLen = prob + LenHigh;+ offset = kLenNumLowSymbols * 2;+ lim = (1 << kLenNumHighBits);+ }+ }+ TREE_DECODE(probLen, lim, len)+ len += offset;+ }+ #else+ {+ CLzmaProb *probLen = prob + LenChoice;+ IF_BIT_0(probLen)+ {+ UPDATE_0(probLen)+ probLen = prob + LenLow + GET_LEN_STATE;+ len = 1;+ TREE_GET_BIT(probLen, len)+ TREE_GET_BIT(probLen, len)+ TREE_GET_BIT(probLen, len)+ len -= 8;+ }+ else+ {+ UPDATE_1(probLen)+ probLen = prob + LenChoice2;+ IF_BIT_0(probLen)+ {+ UPDATE_0(probLen)+ probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);+ len = 1;+ TREE_GET_BIT(probLen, len)+ TREE_GET_BIT(probLen, len)+ TREE_GET_BIT(probLen, len)+ }+ else+ {+ UPDATE_1(probLen)+ probLen = prob + LenHigh;+ TREE_DECODE(probLen, (1 << kLenNumHighBits), len)+ len += kLenNumLowSymbols * 2;+ }+ }+ }+ #endif++ if (state >= kNumStates)+ {+ UInt32 distance;+ prob = probs + PosSlot ++ ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);+ TREE_6_DECODE(prob, distance)+ if (distance >= kStartPosModelIndex)+ {+ unsigned posSlot = (unsigned)distance;+ unsigned numDirectBits = (unsigned)(((distance >> 1) - 1));+ distance = (2 | (distance & 1));+ if (posSlot < kEndPosModelIndex)+ {+ distance <<= numDirectBits;+ prob = probs + SpecPos;+ {+ UInt32 m = 1;+ distance++;+ do+ {+ REV_BIT_VAR(prob, distance, m)+ }+ while (--numDirectBits);+ distance -= m;+ }+ }+ else+ {+ numDirectBits -= kNumAlignBits;+ do+ {+ NORMALIZE+ range >>= 1;+ + {+ UInt32 t;+ code -= range;+ t = (0 - ((UInt32)code >> 31)); /* (UInt32)((Int32)code >> 31) */+ distance = (distance << 1) + (t + 1);+ code += range & t;+ }+ /*+ distance <<= 1;+ if (code >= range)+ {+ code -= range;+ distance |= 1;+ }+ */+ }+ while (--numDirectBits);+ prob = probs + Align;+ distance <<= kNumAlignBits;+ {+ unsigned i = 1;+ REV_BIT_CONST(prob, i, 1)+ REV_BIT_CONST(prob, i, 2)+ REV_BIT_CONST(prob, i, 4)+ REV_BIT_LAST (prob, i, 8)+ distance |= i;+ }+ if (distance == (UInt32)0xFFFFFFFF)+ {+ len = kMatchSpecLenStart;+ state -= kNumStates;+ break;+ }+ }+ }+ + rep3 = rep2;+ rep2 = rep1;+ rep1 = rep0;+ rep0 = distance + 1;+ state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;+ if (distance >= (checkDicSize == 0 ? processedPos: checkDicSize))+ {+ len += kMatchSpecLen_Error_Data + kMatchMinLen;+ // len = kMatchSpecLen_Error_Data;+ // len += kMatchMinLen;+ break;+ }+ }++ len += kMatchMinLen;++ {+ SizeT rem;+ unsigned curLen;+ SizeT pos;+ + if ((rem = limit - dicPos) == 0)+ {+ /*+ We stop decoding and return SZ_OK, and we can resume decoding later.+ Any error conditions can be tested later in caller code.+ For more strict mode we can stop decoding with error+ // len += kMatchSpecLen_Error_Data;+ */+ break;+ }+ + curLen = ((rem < len) ? (unsigned)rem : len);+ pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);++ processedPos += (UInt32)curLen;++ len -= curLen;+ if (curLen <= dicBufSize - pos)+ {+ Byte *dest = dic + dicPos;+ ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;+ const Byte *lim = dest + curLen;+ dicPos += (SizeT)curLen;+ do+ *(dest) = (Byte)*(dest + src);+ while (++dest != lim);+ }+ else+ {+ do+ {+ dic[dicPos++] = dic[pos];+ if (++pos == dicBufSize)+ pos = 0;+ }+ while (--curLen != 0);+ }+ }+ }+ }+ while (dicPos < limit && buf < bufLimit);++ NORMALIZE+ + p->buf = buf;+ p->range = range;+ p->code = code;+ p->remainLen = (UInt32)len; // & (kMatchSpecLen_Error_Data - 1); // we can write real length for error matches too.+ p->dicPos = dicPos;+ p->processedPos = processedPos;+ p->reps[0] = rep0;+ p->reps[1] = rep1;+ p->reps[2] = rep2;+ p->reps[3] = rep3;+ p->state = (UInt32)state;+ if (len >= kMatchSpecLen_Error_Data)+ return SZ_ERROR_DATA;+ return SZ_OK;+}+#endif++++static void Z7_FASTCALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)+{+ unsigned len = (unsigned)p->remainLen;+ if (len == 0 /* || len >= kMatchSpecLenStart */)+ return;+ {+ SizeT dicPos = p->dicPos;+ Byte *dic;+ SizeT dicBufSize;+ SizeT rep0; /* we use SizeT to avoid the BUG of VC14 for AMD64 */+ {+ SizeT rem = limit - dicPos;+ if (rem < len)+ {+ len = (unsigned)(rem);+ if (len == 0)+ return;+ }+ }++ if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)+ p->checkDicSize = p->prop.dicSize;++ p->processedPos += (UInt32)len;+ p->remainLen -= (UInt32)len;+ dic = p->dic;+ rep0 = p->reps[0];+ dicBufSize = p->dicBufSize;+ do+ {+ dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];+ dicPos++;+ }+ while (--len);+ p->dicPos = dicPos;+ }+}+++/*+At staring of new stream we have one of the following symbols:+ - Literal - is allowed+ - Non-Rep-Match - is allowed only if it's end marker symbol+ - Rep-Match - is not allowed+We use early check of (RangeCoder:Code) over kBadRepCode to simplify main decoding code+*/++#define kRange0 0xFFFFFFFF+#define kBound0 ((kRange0 >> kNumBitModelTotalBits) << (kNumBitModelTotalBits - 1))+#define kBadRepCode (kBound0 + (((kRange0 - kBound0) >> kNumBitModelTotalBits) << (kNumBitModelTotalBits - 1)))+#if kBadRepCode != (0xC0000000 - 0x400)+ #error Stop_Compiling_Bad_LZMA_Check+#endif+++/*+LzmaDec_DecodeReal2():+ It calls LZMA_DECODE_REAL() and it adjusts limit according (p->checkDicSize).++We correct (p->checkDicSize) after LZMA_DECODE_REAL() and in LzmaDec_WriteRem(),+and we support the following state of (p->checkDicSize):+ if (total_processed < p->prop.dicSize) then+ {+ (total_processed == p->processedPos)+ (p->checkDicSize == 0)+ }+ else+ (p->checkDicSize == p->prop.dicSize)+*/++static int Z7_FASTCALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)+{+ if (p->checkDicSize == 0)+ {+ UInt32 rem = p->prop.dicSize - p->processedPos;+ if (limit - p->dicPos > rem)+ limit = p->dicPos + rem;+ }+ {+ int res = LZMA_DECODE_REAL(p, limit, bufLimit);+ if (p->checkDicSize == 0 && p->processedPos >= p->prop.dicSize)+ p->checkDicSize = p->prop.dicSize;+ return res;+ }+}++++typedef enum+{+ DUMMY_INPUT_EOF, /* need more input data */+ DUMMY_LIT,+ DUMMY_MATCH,+ DUMMY_REP+} ELzmaDummy;+++#define IS_DUMMY_END_MARKER_POSSIBLE(dummyRes) ((dummyRes) == DUMMY_MATCH)++static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, const Byte **bufOut)+{+ UInt32 range = p->range;+ UInt32 code = p->code;+ const Byte *bufLimit = *bufOut;+ const CLzmaProb *probs = GET_PROBS;+ unsigned state = (unsigned)p->state;+ ELzmaDummy res;++ for (;;)+ {+ const CLzmaProb *prob;+ UInt32 bound;+ unsigned ttt;+ unsigned posState = CALC_POS_STATE(p->processedPos, ((unsigned)1 << p->prop.pb) - 1);++ prob = probs + IsMatch + COMBINED_PS_STATE;+ IF_BIT_0_CHECK(prob)+ {+ UPDATE_0_CHECK++ prob = probs + Literal;+ if (p->checkDicSize != 0 || p->processedPos != 0)+ prob += ((UInt32)LZMA_LIT_SIZE *+ ((((p->processedPos) & (((unsigned)1 << (p->prop.lp)) - 1)) << p->prop.lc) ++ ((unsigned)p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));++ if (state < kNumLitStates)+ {+ unsigned symbol = 1;+ do { GET_BIT_CHECK(prob + symbol, symbol) } while (symbol < 0x100);+ }+ else+ {+ unsigned matchByte = p->dic[p->dicPos - p->reps[0] ++ (p->dicPos < p->reps[0] ? p->dicBufSize : 0)];+ unsigned offs = 0x100;+ unsigned symbol = 1;+ do+ {+ unsigned bit;+ const CLzmaProb *probLit;+ matchByte += matchByte;+ bit = offs;+ offs &= matchByte;+ probLit = prob + (offs + bit + symbol);+ GET_BIT2_CHECK(probLit, symbol, offs ^= bit; , ; )+ }+ while (symbol < 0x100);+ }+ res = DUMMY_LIT;+ }+ else+ {+ unsigned len;+ UPDATE_1_CHECK++ prob = probs + IsRep + state;+ IF_BIT_0_CHECK(prob)+ {+ UPDATE_0_CHECK+ state = 0;+ prob = probs + LenCoder;+ res = DUMMY_MATCH;+ }+ else+ {+ UPDATE_1_CHECK+ res = DUMMY_REP;+ prob = probs + IsRepG0 + state;+ IF_BIT_0_CHECK(prob)+ {+ UPDATE_0_CHECK+ prob = probs + IsRep0Long + COMBINED_PS_STATE;+ IF_BIT_0_CHECK(prob)+ {+ UPDATE_0_CHECK+ break;+ }+ else+ {+ UPDATE_1_CHECK+ }+ }+ else+ {+ UPDATE_1_CHECK+ prob = probs + IsRepG1 + state;+ IF_BIT_0_CHECK(prob)+ {+ UPDATE_0_CHECK+ }+ else+ {+ UPDATE_1_CHECK+ prob = probs + IsRepG2 + state;+ IF_BIT_0_CHECK(prob)+ {+ UPDATE_0_CHECK+ }+ else+ {+ UPDATE_1_CHECK+ }+ }+ }+ state = kNumStates;+ prob = probs + RepLenCoder;+ }+ {+ unsigned limit, offset;+ const CLzmaProb *probLen = prob + LenChoice;+ IF_BIT_0_CHECK(probLen)+ {+ UPDATE_0_CHECK+ probLen = prob + LenLow + GET_LEN_STATE;+ offset = 0;+ limit = 1 << kLenNumLowBits;+ }+ else+ {+ UPDATE_1_CHECK+ probLen = prob + LenChoice2;+ IF_BIT_0_CHECK(probLen)+ {+ UPDATE_0_CHECK+ probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);+ offset = kLenNumLowSymbols;+ limit = 1 << kLenNumLowBits;+ }+ else+ {+ UPDATE_1_CHECK+ probLen = prob + LenHigh;+ offset = kLenNumLowSymbols * 2;+ limit = 1 << kLenNumHighBits;+ }+ }+ TREE_DECODE_CHECK(probLen, limit, len)+ len += offset;+ }++ if (state < 4)+ {+ unsigned posSlot;+ prob = probs + PosSlot ++ ((len < kNumLenToPosStates - 1 ? len : kNumLenToPosStates - 1) <<+ kNumPosSlotBits);+ TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot)+ if (posSlot >= kStartPosModelIndex)+ {+ unsigned numDirectBits = ((posSlot >> 1) - 1);++ if (posSlot < kEndPosModelIndex)+ {+ prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits);+ }+ else+ {+ numDirectBits -= kNumAlignBits;+ do+ {+ NORMALIZE_CHECK+ range >>= 1;+ code -= range & (((code - range) >> 31) - 1);+ /* if (code >= range) code -= range; */+ }+ while (--numDirectBits);+ prob = probs + Align;+ numDirectBits = kNumAlignBits;+ }+ {+ unsigned i = 1;+ unsigned m = 1;+ do+ {+ REV_BIT_CHECK(prob, i, m)+ }+ while (--numDirectBits);+ }+ }+ }+ }+ break;+ }+ NORMALIZE_CHECK++ *bufOut = buf;+ return res;+}++void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState);+void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState)+{+ p->remainLen = kMatchSpecLenStart + 1;+ p->tempBufSize = 0;++ if (initDic)+ {+ p->processedPos = 0;+ p->checkDicSize = 0;+ p->remainLen = kMatchSpecLenStart + 2;+ }+ if (initState)+ p->remainLen = kMatchSpecLenStart + 2;+}++void LzmaDec_Init(CLzmaDec *p)+{+ p->dicPos = 0;+ LzmaDec_InitDicAndState(p, True, True);+}+++/*+LZMA supports optional end_marker.+So the decoder can lookahead for one additional LZMA-Symbol to check end_marker.+That additional LZMA-Symbol can require up to LZMA_REQUIRED_INPUT_MAX bytes in input stream.+When the decoder reaches dicLimit, it looks (finishMode) parameter:+ if (finishMode == LZMA_FINISH_ANY), the decoder doesn't lookahead+ if (finishMode != LZMA_FINISH_ANY), the decoder lookahead, if end_marker is possible for current position++When the decoder lookahead, and the lookahead symbol is not end_marker, we have two ways:+ 1) Strict mode (default) : the decoder returns SZ_ERROR_DATA.+ 2) The relaxed mode (alternative mode) : we could return SZ_OK, and the caller+ must check (status) value. The caller can show the error,+ if the end of stream is expected, and the (status) is noit+ LZMA_STATUS_FINISHED_WITH_MARK or LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK.+*/+++#define RETURN_NOT_FINISHED_FOR_FINISH \+ *status = LZMA_STATUS_NOT_FINISHED; \+ return SZ_ERROR_DATA; // for strict mode+ // return SZ_OK; // for relaxed mode+++SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,+ ELzmaFinishMode finishMode, ELzmaStatus *status)+{+ SizeT inSize = *srcLen;+ (*srcLen) = 0;+ *status = LZMA_STATUS_NOT_SPECIFIED;++ if (p->remainLen > kMatchSpecLenStart)+ {+ if (p->remainLen > kMatchSpecLenStart + 2)+ return p->remainLen == kMatchSpecLen_Error_Fail ? SZ_ERROR_FAIL : SZ_ERROR_DATA;++ for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--)+ p->tempBuf[p->tempBufSize++] = *src++;+ if (p->tempBufSize != 0 && p->tempBuf[0] != 0)+ return SZ_ERROR_DATA;+ if (p->tempBufSize < RC_INIT_SIZE)+ {+ *status = LZMA_STATUS_NEEDS_MORE_INPUT;+ return SZ_OK;+ }+ p->code =+ ((UInt32)p->tempBuf[1] << 24)+ | ((UInt32)p->tempBuf[2] << 16)+ | ((UInt32)p->tempBuf[3] << 8)+ | ((UInt32)p->tempBuf[4]);++ if (p->checkDicSize == 0+ && p->processedPos == 0+ && p->code >= kBadRepCode)+ return SZ_ERROR_DATA;++ p->range = 0xFFFFFFFF;+ p->tempBufSize = 0;++ if (p->remainLen > kMatchSpecLenStart + 1)+ {+ SizeT numProbs = LzmaProps_GetNumProbs(&p->prop);+ SizeT i;+ CLzmaProb *probs = p->probs;+ for (i = 0; i < numProbs; i++)+ probs[i] = kBitModelTotal >> 1;+ p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;+ p->state = 0;+ }++ p->remainLen = 0;+ }++ for (;;)+ {+ if (p->remainLen == kMatchSpecLenStart)+ {+ if (p->code != 0)+ return SZ_ERROR_DATA;+ *status = LZMA_STATUS_FINISHED_WITH_MARK;+ return SZ_OK;+ }++ LzmaDec_WriteRem(p, dicLimit);++ {+ // (p->remainLen == 0 || p->dicPos == dicLimit)++ int checkEndMarkNow = 0;++ if (p->dicPos >= dicLimit)+ {+ if (p->remainLen == 0 && p->code == 0)+ {+ *status = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK;+ return SZ_OK;+ }+ if (finishMode == LZMA_FINISH_ANY)+ {+ *status = LZMA_STATUS_NOT_FINISHED;+ return SZ_OK;+ }+ if (p->remainLen != 0)+ {+ RETURN_NOT_FINISHED_FOR_FINISH+ }+ checkEndMarkNow = 1;+ }++ // (p->remainLen == 0)++ if (p->tempBufSize == 0)+ {+ const Byte *bufLimit;+ int dummyProcessed = -1;+ + if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)+ {+ const Byte *bufOut = src + inSize;+ + ELzmaDummy dummyRes = LzmaDec_TryDummy(p, src, &bufOut);+ + if (dummyRes == DUMMY_INPUT_EOF)+ {+ size_t i;+ if (inSize >= LZMA_REQUIRED_INPUT_MAX)+ break;+ (*srcLen) += inSize;+ p->tempBufSize = (unsigned)inSize;+ for (i = 0; i < inSize; i++)+ p->tempBuf[i] = src[i];+ *status = LZMA_STATUS_NEEDS_MORE_INPUT;+ return SZ_OK;+ }+ + dummyProcessed = (int)(bufOut - src);+ if ((unsigned)dummyProcessed > LZMA_REQUIRED_INPUT_MAX)+ break;+ + if (checkEndMarkNow && !IS_DUMMY_END_MARKER_POSSIBLE(dummyRes))+ {+ unsigned i;+ (*srcLen) += (unsigned)dummyProcessed;+ p->tempBufSize = (unsigned)dummyProcessed;+ for (i = 0; i < (unsigned)dummyProcessed; i++)+ p->tempBuf[i] = src[i];+ // p->remainLen = kMatchSpecLen_Error_Data;+ RETURN_NOT_FINISHED_FOR_FINISH+ }+ + bufLimit = src;+ // we will decode only one iteration+ }+ else+ bufLimit = src + inSize - LZMA_REQUIRED_INPUT_MAX;++ p->buf = src;+ + {+ int res = LzmaDec_DecodeReal2(p, dicLimit, bufLimit);+ + SizeT processed = (SizeT)(p->buf - src);++ if (dummyProcessed < 0)+ {+ if (processed > inSize)+ break;+ }+ else if ((unsigned)dummyProcessed != processed)+ break;++ src += processed;+ inSize -= processed;+ (*srcLen) += processed;++ if (res != SZ_OK)+ {+ p->remainLen = kMatchSpecLen_Error_Data;+ return SZ_ERROR_DATA;+ }+ }+ continue;+ }++ {+ // we have some data in (p->tempBuf)+ // in strict mode: tempBufSize is not enough for one Symbol decoding.+ // in relaxed mode: tempBufSize not larger than required for one Symbol decoding.++ unsigned rem = p->tempBufSize;+ unsigned ahead = 0;+ int dummyProcessed = -1;+ + while (rem < LZMA_REQUIRED_INPUT_MAX && ahead < inSize)+ p->tempBuf[rem++] = src[ahead++];+ + // ahead - the size of new data copied from (src) to (p->tempBuf)+ // rem - the size of temp buffer including new data from (src)+ + if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)+ {+ const Byte *bufOut = p->tempBuf + rem;+ + ELzmaDummy dummyRes = LzmaDec_TryDummy(p, p->tempBuf, &bufOut);+ + if (dummyRes == DUMMY_INPUT_EOF)+ {+ if (rem >= LZMA_REQUIRED_INPUT_MAX)+ break;+ p->tempBufSize = rem;+ (*srcLen) += (SizeT)ahead;+ *status = LZMA_STATUS_NEEDS_MORE_INPUT;+ return SZ_OK;+ }+ + dummyProcessed = (int)(bufOut - p->tempBuf);++ if ((unsigned)dummyProcessed < p->tempBufSize)+ break;++ if (checkEndMarkNow && !IS_DUMMY_END_MARKER_POSSIBLE(dummyRes))+ {+ (*srcLen) += (unsigned)dummyProcessed - p->tempBufSize;+ p->tempBufSize = (unsigned)dummyProcessed;+ // p->remainLen = kMatchSpecLen_Error_Data;+ RETURN_NOT_FINISHED_FOR_FINISH+ }+ }++ p->buf = p->tempBuf;+ + {+ // we decode one symbol from (p->tempBuf) here, so the (bufLimit) is equal to (p->buf)+ int res = LzmaDec_DecodeReal2(p, dicLimit, p->buf);++ SizeT processed = (SizeT)(p->buf - p->tempBuf);+ rem = p->tempBufSize;+ + if (dummyProcessed < 0)+ {+ if (processed > LZMA_REQUIRED_INPUT_MAX)+ break;+ if (processed < rem)+ break;+ }+ else if ((unsigned)dummyProcessed != processed)+ break;+ + processed -= rem;++ src += processed;+ inSize -= processed;+ (*srcLen) += processed;+ p->tempBufSize = 0;+ + if (res != SZ_OK)+ {+ p->remainLen = kMatchSpecLen_Error_Data;+ return SZ_ERROR_DATA;+ }+ }+ }+ }+ }++ /* Some unexpected error: internal error of code, memory corruption or hardware failure */+ p->remainLen = kMatchSpecLen_Error_Fail;+ return SZ_ERROR_FAIL;+}++++SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)+{+ SizeT outSize = *destLen;+ SizeT inSize = *srcLen;+ *srcLen = *destLen = 0;+ for (;;)+ {+ SizeT inSizeCur = inSize, outSizeCur, dicPos;+ ELzmaFinishMode curFinishMode;+ SRes res;+ if (p->dicPos == p->dicBufSize)+ p->dicPos = 0;+ dicPos = p->dicPos;+ if (outSize > p->dicBufSize - dicPos)+ {+ outSizeCur = p->dicBufSize;+ curFinishMode = LZMA_FINISH_ANY;+ }+ else+ {+ outSizeCur = dicPos + outSize;+ curFinishMode = finishMode;+ }++ res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status);+ src += inSizeCur;+ inSize -= inSizeCur;+ *srcLen += inSizeCur;+ outSizeCur = p->dicPos - dicPos;+ memcpy(dest, p->dic + dicPos, outSizeCur);+ dest += outSizeCur;+ outSize -= outSizeCur;+ *destLen += outSizeCur;+ if (res != 0)+ return res;+ if (outSizeCur == 0 || outSize == 0)+ return SZ_OK;+ }+}++void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc)+{+ ISzAlloc_Free(alloc, p->probs);+ p->probs = NULL;+}++static void LzmaDec_FreeDict(CLzmaDec *p, ISzAllocPtr alloc)+{+ ISzAlloc_Free(alloc, p->dic);+ p->dic = NULL;+}++void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc)+{+ LzmaDec_FreeProbs(p, alloc);+ LzmaDec_FreeDict(p, alloc);+}++SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)+{+ UInt32 dicSize;+ Byte d;+ + if (size < LZMA_PROPS_SIZE)+ return SZ_ERROR_UNSUPPORTED;+ else+ dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);+ + if (dicSize < LZMA_DIC_MIN)+ dicSize = LZMA_DIC_MIN;+ p->dicSize = dicSize;++ d = data[0];+ if (d >= (9 * 5 * 5))+ return SZ_ERROR_UNSUPPORTED;++ p->lc = (Byte)(d % 9);+ d /= 9;+ p->pb = (Byte)(d / 5);+ p->lp = (Byte)(d % 5);++ return SZ_OK;+}++static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAllocPtr alloc)+{+ UInt32 numProbs = LzmaProps_GetNumProbs(propNew);+ if (!p->probs || numProbs != p->numProbs)+ {+ LzmaDec_FreeProbs(p, alloc);+ p->probs = (CLzmaProb *)ISzAlloc_Alloc(alloc, numProbs * sizeof(CLzmaProb));+ if (!p->probs)+ return SZ_ERROR_MEM;+ p->probs_1664 = p->probs + 1664;+ p->numProbs = numProbs;+ }+ return SZ_OK;+}++SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc)+{+ CLzmaProps propNew;+ RINOK(LzmaProps_Decode(&propNew, props, propsSize))+ RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc))+ p->prop = propNew;+ return SZ_OK;+}++SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc)+{+ CLzmaProps propNew;+ SizeT dicBufSize;+ RINOK(LzmaProps_Decode(&propNew, props, propsSize))+ RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc))++ {+ UInt32 dictSize = propNew.dicSize;+ SizeT mask = ((UInt32)1 << 12) - 1;+ if (dictSize >= ((UInt32)1 << 30)) mask = ((UInt32)1 << 22) - 1;+ else if (dictSize >= ((UInt32)1 << 22)) mask = ((UInt32)1 << 20) - 1;+ dicBufSize = ((SizeT)dictSize + mask) & ~mask;+ if (dicBufSize < dictSize)+ dicBufSize = dictSize;+ }++ if (!p->dic || dicBufSize != p->dicBufSize)+ {+ LzmaDec_FreeDict(p, alloc);+ p->dic = (Byte *)ISzAlloc_Alloc(alloc, dicBufSize);+ if (!p->dic)+ {+ LzmaDec_FreeProbs(p, alloc);+ return SZ_ERROR_MEM;+ }+ }+ p->dicBufSize = dicBufSize;+ p->prop = propNew;+ return SZ_OK;+}++SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,+ const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,+ ELzmaStatus *status, ISzAllocPtr alloc)+{+ CLzmaDec p;+ SRes res;+ SizeT outSize = *destLen, inSize = *srcLen;+ *destLen = *srcLen = 0;+ *status = LZMA_STATUS_NOT_SPECIFIED;+ if (inSize < RC_INIT_SIZE)+ return SZ_ERROR_INPUT_EOF;+ LzmaDec_CONSTRUCT(&p)+ RINOK(LzmaDec_AllocateProbs(&p, propData, propSize, alloc))+ p.dic = dest;+ p.dicBufSize = outSize;+ LzmaDec_Init(&p);+ *srcLen = inSize;+ res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);+ *destLen = p.dicPos;+ if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)+ res = SZ_ERROR_INPUT_EOF;+ LzmaDec_FreeProbs(&p, alloc);+ return res;+}
@@ -0,0 +1,237 @@+/* LzmaDec.h -- LZMA Decoder+2023-04-02 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_LZMA_DEC_H+#define ZIP7_INC_LZMA_DEC_H++#include "7zTypes.h"++EXTERN_C_BEGIN++/* #define Z7_LZMA_PROB32 */+/* Z7_LZMA_PROB32 can increase the speed on some CPUs,+ but memory usage for CLzmaDec::probs will be doubled in that case */++typedef+#ifdef Z7_LZMA_PROB32+ UInt32+#else+ UInt16+#endif+ CLzmaProb;+++/* ---------- LZMA Properties ---------- */++#define LZMA_PROPS_SIZE 5++typedef struct+{+ Byte lc;+ Byte lp;+ Byte pb;+ Byte _pad_;+ UInt32 dicSize;+} CLzmaProps;++/* LzmaProps_Decode - decodes properties+Returns:+ SZ_OK+ SZ_ERROR_UNSUPPORTED - Unsupported properties+*/++SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);+++/* ---------- LZMA Decoder state ---------- */++/* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case.+ Num bits = log2((2^11 / 31) ^ 22) + 26 < 134 + 26 = 160; */++#define LZMA_REQUIRED_INPUT_MAX 20++typedef struct+{+ /* Don't change this structure. ASM code can use it. */+ CLzmaProps prop;+ CLzmaProb *probs;+ CLzmaProb *probs_1664;+ Byte *dic;+ SizeT dicBufSize;+ SizeT dicPos;+ const Byte *buf;+ UInt32 range;+ UInt32 code;+ UInt32 processedPos;+ UInt32 checkDicSize;+ UInt32 reps[4];+ UInt32 state;+ UInt32 remainLen;++ UInt32 numProbs;+ unsigned tempBufSize;+ Byte tempBuf[LZMA_REQUIRED_INPUT_MAX];+} CLzmaDec;++#define LzmaDec_CONSTRUCT(p) { (p)->dic = NULL; (p)->probs = NULL; }+#define LzmaDec_Construct(p) LzmaDec_CONSTRUCT(p)++void LzmaDec_Init(CLzmaDec *p);++/* There are two types of LZMA streams:+ - Stream with end mark. That end mark adds about 6 bytes to compressed size.+ - Stream without end mark. You must know exact uncompressed size to decompress such stream. */++typedef enum+{+ LZMA_FINISH_ANY, /* finish at any point */+ LZMA_FINISH_END /* block must be finished at the end */+} ELzmaFinishMode;++/* ELzmaFinishMode has meaning only if the decoding reaches output limit !!!++ You must use LZMA_FINISH_END, when you know that current output buffer+ covers last bytes of block. In other cases you must use LZMA_FINISH_ANY.++ If LZMA decoder sees end marker before reaching output limit, it returns SZ_OK,+ and output value of destLen will be less than output buffer size limit.+ You can check status result also.++ You can use multiple checks to test data integrity after full decompression:+ 1) Check Result and "status" variable.+ 2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize.+ 3) Check that output(srcLen) = compressedSize, if you know real compressedSize.+ You must use correct finish mode in that case. */++typedef enum+{+ LZMA_STATUS_NOT_SPECIFIED, /* use main error code instead */+ LZMA_STATUS_FINISHED_WITH_MARK, /* stream was finished with end mark. */+ LZMA_STATUS_NOT_FINISHED, /* stream was not finished */+ LZMA_STATUS_NEEDS_MORE_INPUT, /* you must provide more input bytes */+ LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK /* there is probability that stream was finished without end mark */+} ELzmaStatus;++/* ELzmaStatus is used only as output value for function call */+++/* ---------- Interfaces ---------- */++/* There are 3 levels of interfaces:+ 1) Dictionary Interface+ 2) Buffer Interface+ 3) One Call Interface+ You can select any of these interfaces, but don't mix functions from different+ groups for same object. */+++/* There are two variants to allocate state for Dictionary Interface:+ 1) LzmaDec_Allocate / LzmaDec_Free+ 2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs+ You can use variant 2, if you set dictionary buffer manually.+ For Buffer Interface you must always use variant 1.++LzmaDec_Allocate* can return:+ SZ_OK+ SZ_ERROR_MEM - Memory allocation error+ SZ_ERROR_UNSUPPORTED - Unsupported properties+*/+ +SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);+void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc);++SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);+void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc);++/* ---------- Dictionary Interface ---------- */++/* You can use it, if you want to eliminate the overhead for data copying from+ dictionary to some other external buffer.+ You must work with CLzmaDec variables directly in this interface.++ STEPS:+ LzmaDec_Construct()+ LzmaDec_Allocate()+ for (each new stream)+ {+ LzmaDec_Init()+ while (it needs more decompression)+ {+ LzmaDec_DecodeToDic()+ use data from CLzmaDec::dic and update CLzmaDec::dicPos+ }+ }+ LzmaDec_Free()+*/++/* LzmaDec_DecodeToDic+ + The decoding to internal dictionary buffer (CLzmaDec::dic).+ You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!++finishMode:+ It has meaning only if the decoding reaches output limit (dicLimit).+ LZMA_FINISH_ANY - Decode just dicLimit bytes.+ LZMA_FINISH_END - Stream must be finished after dicLimit.++Returns:+ SZ_OK+ status:+ LZMA_STATUS_FINISHED_WITH_MARK+ LZMA_STATUS_NOT_FINISHED+ LZMA_STATUS_NEEDS_MORE_INPUT+ LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK+ SZ_ERROR_DATA - Data error+ SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure+*/++SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,+ const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);+++/* ---------- Buffer Interface ---------- */++/* It's zlib-like interface.+ See LzmaDec_DecodeToDic description for information about STEPS and return results,+ but you must use LzmaDec_DecodeToBuf instead of LzmaDec_DecodeToDic and you don't need+ to work with CLzmaDec variables manually.++finishMode:+ It has meaning only if the decoding reaches output limit (*destLen).+ LZMA_FINISH_ANY - Decode just destLen bytes.+ LZMA_FINISH_END - Stream must be finished after (*destLen).+*/++SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,+ const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);+++/* ---------- One Call Interface ---------- */++/* LzmaDecode++finishMode:+ It has meaning only if the decoding reaches output limit (*destLen).+ LZMA_FINISH_ANY - Decode just destLen bytes.+ LZMA_FINISH_END - Stream must be finished after (*destLen).++Returns:+ SZ_OK+ status:+ LZMA_STATUS_FINISHED_WITH_MARK+ LZMA_STATUS_NOT_FINISHED+ LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK+ SZ_ERROR_DATA - Data error+ SZ_ERROR_MEM - Memory allocation error+ SZ_ERROR_UNSUPPORTED - Unsupported properties+ SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).+ SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure+*/++SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,+ const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,+ ELzmaStatus *status, ISzAllocPtr alloc);++EXTERN_C_END++#endif
@@ -0,0 +1,3 @@+noinst_LIBRARIES = libviiz.a+libviiz_a_CPPFLAGS = -DZ7_PPMD_SUPPORT -DZ7_EXTRACT_ONLY -DNDEBUG -D_REENTRANT -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE+libviiz_a_SOURCES = viizip.h viizip.c 7z.h 7zAlloc.h 7zBuf.h 7zCrc.h 7zFile.h 7zTypes.h Bcj2.h Bra.h Compiler.h CpuArch.h Delta.h Lzma2Dec.h LzmaDec.h Ppmd.h Ppmd7.h Precomp.h RotateDefs.h 7zAlloc.c 7zArcIn.c 7zBuf.c 7zBuf2.c 7zCrc.c 7zCrcOpt.c 7zDec.c 7zFile.c 7zStream.c Bcj2.c Bra.c Bra86.c BraIA64.c CpuArch.c Delta.c Lzma2Dec.c LzmaDec.c Ppmd7.c Ppmd7Dec.c
@@ -0,0 +1,949 @@+# Makefile.in generated by automake 1.16.5 from Makefile.am.+# @configure_input@++# Copyright (C) 1994-2021 Free Software Foundation, Inc.++# This Makefile.in is free software; the Free Software Foundation+# gives unlimited permission to copy and/or distribute it,+# with or without modifications, as long as this notice is preserved.++# This program is distributed in the hope that it will be useful,+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A+# PARTICULAR PURPOSE.++@SET_MAKE@++VPATH = @srcdir@+am__is_gnu_make = { \+ if test -z '$(MAKELEVEL)'; then \+ false; \+ elif test -n '$(MAKE_HOST)'; then \+ true; \+ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \+ true; \+ else \+ false; \+ fi; \+}+am__make_running_with_option = \+ case $${target_option-} in \+ ?) ;; \+ *) echo "am__make_running_with_option: internal error: invalid" \+ "target option '$${target_option-}' specified" >&2; \+ exit 1;; \+ esac; \+ has_opt=no; \+ sane_makeflags=$$MAKEFLAGS; \+ if $(am__is_gnu_make); then \+ sane_makeflags=$$MFLAGS; \+ else \+ case $$MAKEFLAGS in \+ *\\[\ \ ]*) \+ bs=\\; \+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \+ esac; \+ fi; \+ skip_next=no; \+ strip_trailopt () \+ { \+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \+ }; \+ for flg in $$sane_makeflags; do \+ test $$skip_next = yes && { skip_next=no; continue; }; \+ case $$flg in \+ *=*|--*) continue;; \+ -*I) strip_trailopt 'I'; skip_next=yes;; \+ -*I?*) strip_trailopt 'I';; \+ -*O) strip_trailopt 'O'; skip_next=yes;; \+ -*O?*) strip_trailopt 'O';; \+ -*l) strip_trailopt 'l'; skip_next=yes;; \+ -*l?*) strip_trailopt 'l';; \+ -[dEDm]) skip_next=yes;; \+ -[JT]) skip_next=yes;; \+ esac; \+ case $$flg in \+ *$$target_option*) has_opt=yes; break;; \+ esac; \+ done; \+ test $$has_opt = yes+am__make_dryrun = (target_option=n; $(am__make_running_with_option))+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))+pkgdatadir = $(datadir)/@PACKAGE@+pkgincludedir = $(includedir)/@PACKAGE@+pkglibdir = $(libdir)/@PACKAGE@+pkglibexecdir = $(libexecdir)/@PACKAGE@+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd+install_sh_DATA = $(install_sh) -c -m 644+install_sh_PROGRAM = $(install_sh) -c+install_sh_SCRIPT = $(install_sh) -c+INSTALL_HEADER = $(INSTALL_DATA)+transform = $(program_transform_name)+NORMAL_INSTALL = :+PRE_INSTALL = :+POST_INSTALL = :+NORMAL_UNINSTALL = :+PRE_UNINSTALL = :+POST_UNINSTALL = :+build_triplet = @build@+host_triplet = @host@+subdir = lzma/C+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4+am__aclocal_m4_deps = $(top_srcdir)/m4/ax_boost_regex.m4 \+ $(top_srcdir)/m4/ax_check_brotlilib.m4 \+ $(top_srcdir)/m4/ax_check_bz2lib.m4 \+ $(top_srcdir)/m4/ax_check_bzip3lib.m4 \+ $(top_srcdir)/m4/ax_check_lz4lib.m4 \+ $(top_srcdir)/m4/ax_check_lzmalib.m4 \+ $(top_srcdir)/m4/ax_check_pcre2.m4 \+ $(top_srcdir)/m4/ax_check_zlib.m4 \+ $(top_srcdir)/m4/ax_check_zstdlib.m4 \+ $(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \+ $(top_srcdir)/m4/ax_cxx_compile_stdcxx_11.m4 \+ $(top_srcdir)/configure.ac+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \+ $(ACLOCAL_M4)+DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)+mkinstalldirs = $(install_sh) -d+CONFIG_HEADER = $(top_builddir)/config.h+CONFIG_CLEAN_FILES =+CONFIG_CLEAN_VPATH_FILES =+LIBRARIES = $(noinst_LIBRARIES)+ARFLAGS = cru+AM_V_AR = $(am__v_AR_@AM_V@)+am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)+am__v_AR_0 = @echo " AR " $@;+am__v_AR_1 = +libviiz_a_AR = $(AR) $(ARFLAGS)+libviiz_a_LIBADD =+am_libviiz_a_OBJECTS = libviiz_a-viizip.$(OBJEXT) \+ libviiz_a-7zAlloc.$(OBJEXT) libviiz_a-7zArcIn.$(OBJEXT) \+ libviiz_a-7zBuf.$(OBJEXT) libviiz_a-7zBuf2.$(OBJEXT) \+ libviiz_a-7zCrc.$(OBJEXT) libviiz_a-7zCrcOpt.$(OBJEXT) \+ libviiz_a-7zDec.$(OBJEXT) libviiz_a-7zFile.$(OBJEXT) \+ libviiz_a-7zStream.$(OBJEXT) libviiz_a-Bcj2.$(OBJEXT) \+ libviiz_a-Bra.$(OBJEXT) libviiz_a-Bra86.$(OBJEXT) \+ libviiz_a-BraIA64.$(OBJEXT) libviiz_a-CpuArch.$(OBJEXT) \+ libviiz_a-Delta.$(OBJEXT) libviiz_a-Lzma2Dec.$(OBJEXT) \+ libviiz_a-LzmaDec.$(OBJEXT) libviiz_a-Ppmd7.$(OBJEXT) \+ libviiz_a-Ppmd7Dec.$(OBJEXT)+libviiz_a_OBJECTS = $(am_libviiz_a_OBJECTS)+AM_V_P = $(am__v_P_@AM_V@)+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)+am__v_P_0 = false+am__v_P_1 = :+AM_V_GEN = $(am__v_GEN_@AM_V@)+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)+am__v_GEN_0 = @echo " GEN " $@;+am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@)+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)+am__v_at_0 = @+am__v_at_1 = +DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)+depcomp = $(SHELL) $(top_srcdir)/depcomp+am__maybe_remake_depfiles = depfiles+am__depfiles_remade = ./$(DEPDIR)/libviiz_a-7zAlloc.Po \+ ./$(DEPDIR)/libviiz_a-7zArcIn.Po \+ ./$(DEPDIR)/libviiz_a-7zBuf.Po ./$(DEPDIR)/libviiz_a-7zBuf2.Po \+ ./$(DEPDIR)/libviiz_a-7zCrc.Po \+ ./$(DEPDIR)/libviiz_a-7zCrcOpt.Po \+ ./$(DEPDIR)/libviiz_a-7zDec.Po ./$(DEPDIR)/libviiz_a-7zFile.Po \+ ./$(DEPDIR)/libviiz_a-7zStream.Po \+ ./$(DEPDIR)/libviiz_a-Bcj2.Po ./$(DEPDIR)/libviiz_a-Bra.Po \+ ./$(DEPDIR)/libviiz_a-Bra86.Po \+ ./$(DEPDIR)/libviiz_a-BraIA64.Po \+ ./$(DEPDIR)/libviiz_a-CpuArch.Po \+ ./$(DEPDIR)/libviiz_a-Delta.Po \+ ./$(DEPDIR)/libviiz_a-Lzma2Dec.Po \+ ./$(DEPDIR)/libviiz_a-LzmaDec.Po \+ ./$(DEPDIR)/libviiz_a-Ppmd7.Po \+ ./$(DEPDIR)/libviiz_a-Ppmd7Dec.Po \+ ./$(DEPDIR)/libviiz_a-viizip.Po+am__mv = mv -f+AM_V_lt = $(am__v_lt_@AM_V@)+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)+am__v_lt_0 = --silent+am__v_lt_1 = +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \+ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)+AM_V_CC = $(am__v_CC_@AM_V@)+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)+am__v_CC_0 = @echo " CC " $@;+am__v_CC_1 = +CCLD = $(CC)+LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@+AM_V_CCLD = $(am__v_CCLD_@AM_V@)+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)+am__v_CCLD_0 = @echo " CCLD " $@;+am__v_CCLD_1 = +SOURCES = $(libviiz_a_SOURCES)+DIST_SOURCES = $(libviiz_a_SOURCES)+am__can_run_installinfo = \+ case $$AM_UPDATE_INFO_DIR in \+ n|no|NO) false;; \+ *) (install-info --version) >/dev/null 2>&1;; \+ esac+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)+# Read a list of newline-separated strings from the standard input,+# and print each of them once, without duplicates. Input order is+# *not* preserved.+am__uniquify_input = $(AWK) '\+ BEGIN { nonempty = 0; } \+ { items[$$0] = 1; nonempty = 1; } \+ END { if (nonempty) { for (i in items) print i; }; } \+'+# Make sure the list of sources is unique. This is necessary because,+# e.g., the same source file might be shared among _SOURCES variables+# for different programs/libraries.+am__define_uniq_tagged_files = \+ list='$(am__tagged_files)'; \+ unique=`for i in $$list; do \+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \+ done | $(am__uniquify_input)`+am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)+ACLOCAL = @ACLOCAL@+AMTAR = @AMTAR@+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@+AR = @AR@+AUTOCONF = @AUTOCONF@+AUTOHEADER = @AUTOHEADER@+AUTOMAKE = @AUTOMAKE@+AWK = @AWK@+BASH_COMPLETION_CFLAGS = @BASH_COMPLETION_CFLAGS@+BASH_COMPLETION_DIR = @BASH_COMPLETION_DIR@+BASH_COMPLETION_LIBS = @BASH_COMPLETION_LIBS@+CC = @CC@+CCDEPMODE = @CCDEPMODE@+CFLAGS = @CFLAGS@+CPPFLAGS = @CPPFLAGS@+CSCOPE = @CSCOPE@+CTAGS = @CTAGS@+CXX = @CXX@+CXXCPP = @CXXCPP@+CXXDEPMODE = @CXXDEPMODE@+CXXFLAGS = @CXXFLAGS@+CYGPATH_W = @CYGPATH_W@+DEFS = @DEFS@+DEPDIR = @DEPDIR@+ECHO_C = @ECHO_C@+ECHO_N = @ECHO_N@+ECHO_T = @ECHO_T@+ETAGS = @ETAGS@+EXEEXT = @EXEEXT@+EXTRA_CFLAGS = @EXTRA_CFLAGS@+FISH_COMPLETION_CFLAGS = @FISH_COMPLETION_CFLAGS@+FISH_COMPLETION_DIR = @FISH_COMPLETION_DIR@+FISH_COMPLETION_LIBS = @FISH_COMPLETION_LIBS@+GREP_PATH = @GREP_PATH@+HAVE_CXX11 = @HAVE_CXX11@+INSTALL = @INSTALL@+INSTALL_DATA = @INSTALL_DATA@+INSTALL_PROGRAM = @INSTALL_PROGRAM@+INSTALL_SCRIPT = @INSTALL_SCRIPT@+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@+LDFLAGS = @LDFLAGS@+LIBOBJS = @LIBOBJS@+LIBS = @LIBS@+LN_S = @LN_S@+LTLIBOBJS = @LTLIBOBJS@+MAKEINFO = @MAKEINFO@+MKDIR_P = @MKDIR_P@+OBJEXT = @OBJEXT@+PACKAGE = @PACKAGE@+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@+PACKAGE_NAME = @PACKAGE_NAME@+PACKAGE_STRING = @PACKAGE_STRING@+PACKAGE_TARNAME = @PACKAGE_TARNAME@+PACKAGE_URL = @PACKAGE_URL@+PACKAGE_VERSION = @PACKAGE_VERSION@+PATH_SEPARATOR = @PATH_SEPARATOR@+PKG_CONFIG = @PKG_CONFIG@+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@+PLATFORM = @PLATFORM@+PTHREAD_CFLAGS = @PTHREAD_CFLAGS@+PTHREAD_LIBS = @PTHREAD_LIBS@+RANLIB = @RANLIB@+SED = @SED@+SET_MAKE = @SET_MAKE@+SHELL = @SHELL@+SIMD_AVX2_FLAGS = @SIMD_AVX2_FLAGS@+SIMD_AVX512BW_FLAGS = @SIMD_AVX512BW_FLAGS@+SIMD_FLAGS = @SIMD_FLAGS@+STRIP = @STRIP@+VERSION = @VERSION@+ZSH_COMPLETION_DIR = @ZSH_COMPLETION_DIR@+abs_builddir = @abs_builddir@+abs_srcdir = @abs_srcdir@+abs_top_builddir = @abs_top_builddir@+abs_top_srcdir = @abs_top_srcdir@+ac_ct_AR = @ac_ct_AR@+ac_ct_CC = @ac_ct_CC@+ac_ct_CXX = @ac_ct_CXX@+am__include = @am__include@+am__leading_dot = @am__leading_dot@+am__quote = @am__quote@+am__tar = @am__tar@+am__untar = @am__untar@+bindir = @bindir@+build = @build@+build_alias = @build_alias@+build_cpu = @build_cpu@+build_os = @build_os@+build_vendor = @build_vendor@+builddir = @builddir@+datadir = @datadir@+datarootdir = @datarootdir@+docdir = @docdir@+dvidir = @dvidir@+exec_prefix = @exec_prefix@+host = @host@+host_alias = @host_alias@+host_cpu = @host_cpu@+host_os = @host_os@+host_vendor = @host_vendor@+htmldir = @htmldir@+includedir = @includedir@+infodir = @infodir@+install_sh = @install_sh@+libdir = @libdir@+libexecdir = @libexecdir@+localedir = @localedir@+localstatedir = @localstatedir@+mandir = @mandir@+mkdir_p = @mkdir_p@+oldincludedir = @oldincludedir@+pdfdir = @pdfdir@+prefix = @prefix@+program_transform_name = @program_transform_name@+psdir = @psdir@+runstatedir = @runstatedir@+sbindir = @sbindir@+sharedstatedir = @sharedstatedir@+srcdir = @srcdir@+sysconfdir = @sysconfdir@+target_alias = @target_alias@+top_build_prefix = @top_build_prefix@+top_builddir = @top_builddir@+top_srcdir = @top_srcdir@+noinst_LIBRARIES = libviiz.a+libviiz_a_CPPFLAGS = -DZ7_PPMD_SUPPORT -DZ7_EXTRACT_ONLY -DNDEBUG -D_REENTRANT -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE+libviiz_a_SOURCES = viizip.h viizip.c 7z.h 7zAlloc.h 7zBuf.h 7zCrc.h 7zFile.h 7zTypes.h Bcj2.h Bra.h Compiler.h CpuArch.h Delta.h Lzma2Dec.h LzmaDec.h Ppmd.h Ppmd7.h Precomp.h RotateDefs.h 7zAlloc.c 7zArcIn.c 7zBuf.c 7zBuf2.c 7zCrc.c 7zCrcOpt.c 7zDec.c 7zFile.c 7zStream.c Bcj2.c Bra.c Bra86.c BraIA64.c CpuArch.c Delta.c Lzma2Dec.c LzmaDec.c Ppmd7.c Ppmd7Dec.c+all: all-am++.SUFFIXES:+.SUFFIXES: .c .o .obj+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)+ @for dep in $?; do \+ case '$(am__configure_deps)' in \+ *$$dep*) \+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \+ && { if test -f $@; then exit 0; else break; fi; }; \+ exit 1;; \+ esac; \+ done; \+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign lzma/C/Makefile'; \+ $(am__cd) $(top_srcdir) && \+ $(AUTOMAKE) --foreign lzma/C/Makefile+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status+ @case '$?' in \+ *config.status*) \+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \+ *) \+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \+ esac;++$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh++$(top_srcdir)/configure: $(am__configure_deps)+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh+$(ACLOCAL_M4): $(am__aclocal_m4_deps)+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh+$(am__aclocal_m4_deps):++clean-noinstLIBRARIES:+ -test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)++libviiz.a: $(libviiz_a_OBJECTS) $(libviiz_a_DEPENDENCIES) $(EXTRA_libviiz_a_DEPENDENCIES) + $(AM_V_at)-rm -f libviiz.a+ $(AM_V_AR)$(libviiz_a_AR) libviiz.a $(libviiz_a_OBJECTS) $(libviiz_a_LIBADD)+ $(AM_V_at)$(RANLIB) libviiz.a++mostlyclean-compile:+ -rm -f *.$(OBJEXT)++distclean-compile:+ -rm -f *.tab.c++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-7zAlloc.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-7zArcIn.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-7zBuf.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-7zBuf2.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-7zCrc.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-7zCrcOpt.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-7zDec.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-7zFile.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-7zStream.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-Bcj2.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-Bra.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-Bra86.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-BraIA64.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-CpuArch.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-Delta.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-Lzma2Dec.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-LzmaDec.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-Ppmd7.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-Ppmd7Dec.Po@am__quote@ # am--include-marker+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libviiz_a-viizip.Po@am__quote@ # am--include-marker++$(am__depfiles_remade):+ @$(MKDIR_P) $(@D)+ @echo '# dummy' >$@-t && $(am__mv) $@-t $@++am--depfiles: $(am__depfiles_remade)++.c.o:+@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<++.c.obj:+@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`++libviiz_a-viizip.o: viizip.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-viizip.o -MD -MP -MF $(DEPDIR)/libviiz_a-viizip.Tpo -c -o libviiz_a-viizip.o `test -f 'viizip.c' || echo '$(srcdir)/'`viizip.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-viizip.Tpo $(DEPDIR)/libviiz_a-viizip.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='viizip.c' object='libviiz_a-viizip.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-viizip.o `test -f 'viizip.c' || echo '$(srcdir)/'`viizip.c++libviiz_a-viizip.obj: viizip.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-viizip.obj -MD -MP -MF $(DEPDIR)/libviiz_a-viizip.Tpo -c -o libviiz_a-viizip.obj `if test -f 'viizip.c'; then $(CYGPATH_W) 'viizip.c'; else $(CYGPATH_W) '$(srcdir)/viizip.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-viizip.Tpo $(DEPDIR)/libviiz_a-viizip.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='viizip.c' object='libviiz_a-viizip.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-viizip.obj `if test -f 'viizip.c'; then $(CYGPATH_W) 'viizip.c'; else $(CYGPATH_W) '$(srcdir)/viizip.c'; fi`++libviiz_a-7zAlloc.o: 7zAlloc.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zAlloc.o -MD -MP -MF $(DEPDIR)/libviiz_a-7zAlloc.Tpo -c -o libviiz_a-7zAlloc.o `test -f '7zAlloc.c' || echo '$(srcdir)/'`7zAlloc.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zAlloc.Tpo $(DEPDIR)/libviiz_a-7zAlloc.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zAlloc.c' object='libviiz_a-7zAlloc.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zAlloc.o `test -f '7zAlloc.c' || echo '$(srcdir)/'`7zAlloc.c++libviiz_a-7zAlloc.obj: 7zAlloc.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zAlloc.obj -MD -MP -MF $(DEPDIR)/libviiz_a-7zAlloc.Tpo -c -o libviiz_a-7zAlloc.obj `if test -f '7zAlloc.c'; then $(CYGPATH_W) '7zAlloc.c'; else $(CYGPATH_W) '$(srcdir)/7zAlloc.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zAlloc.Tpo $(DEPDIR)/libviiz_a-7zAlloc.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zAlloc.c' object='libviiz_a-7zAlloc.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zAlloc.obj `if test -f '7zAlloc.c'; then $(CYGPATH_W) '7zAlloc.c'; else $(CYGPATH_W) '$(srcdir)/7zAlloc.c'; fi`++libviiz_a-7zArcIn.o: 7zArcIn.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zArcIn.o -MD -MP -MF $(DEPDIR)/libviiz_a-7zArcIn.Tpo -c -o libviiz_a-7zArcIn.o `test -f '7zArcIn.c' || echo '$(srcdir)/'`7zArcIn.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zArcIn.Tpo $(DEPDIR)/libviiz_a-7zArcIn.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zArcIn.c' object='libviiz_a-7zArcIn.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zArcIn.o `test -f '7zArcIn.c' || echo '$(srcdir)/'`7zArcIn.c++libviiz_a-7zArcIn.obj: 7zArcIn.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zArcIn.obj -MD -MP -MF $(DEPDIR)/libviiz_a-7zArcIn.Tpo -c -o libviiz_a-7zArcIn.obj `if test -f '7zArcIn.c'; then $(CYGPATH_W) '7zArcIn.c'; else $(CYGPATH_W) '$(srcdir)/7zArcIn.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zArcIn.Tpo $(DEPDIR)/libviiz_a-7zArcIn.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zArcIn.c' object='libviiz_a-7zArcIn.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zArcIn.obj `if test -f '7zArcIn.c'; then $(CYGPATH_W) '7zArcIn.c'; else $(CYGPATH_W) '$(srcdir)/7zArcIn.c'; fi`++libviiz_a-7zBuf.o: 7zBuf.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zBuf.o -MD -MP -MF $(DEPDIR)/libviiz_a-7zBuf.Tpo -c -o libviiz_a-7zBuf.o `test -f '7zBuf.c' || echo '$(srcdir)/'`7zBuf.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zBuf.Tpo $(DEPDIR)/libviiz_a-7zBuf.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zBuf.c' object='libviiz_a-7zBuf.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zBuf.o `test -f '7zBuf.c' || echo '$(srcdir)/'`7zBuf.c++libviiz_a-7zBuf.obj: 7zBuf.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zBuf.obj -MD -MP -MF $(DEPDIR)/libviiz_a-7zBuf.Tpo -c -o libviiz_a-7zBuf.obj `if test -f '7zBuf.c'; then $(CYGPATH_W) '7zBuf.c'; else $(CYGPATH_W) '$(srcdir)/7zBuf.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zBuf.Tpo $(DEPDIR)/libviiz_a-7zBuf.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zBuf.c' object='libviiz_a-7zBuf.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zBuf.obj `if test -f '7zBuf.c'; then $(CYGPATH_W) '7zBuf.c'; else $(CYGPATH_W) '$(srcdir)/7zBuf.c'; fi`++libviiz_a-7zBuf2.o: 7zBuf2.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zBuf2.o -MD -MP -MF $(DEPDIR)/libviiz_a-7zBuf2.Tpo -c -o libviiz_a-7zBuf2.o `test -f '7zBuf2.c' || echo '$(srcdir)/'`7zBuf2.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zBuf2.Tpo $(DEPDIR)/libviiz_a-7zBuf2.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zBuf2.c' object='libviiz_a-7zBuf2.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zBuf2.o `test -f '7zBuf2.c' || echo '$(srcdir)/'`7zBuf2.c++libviiz_a-7zBuf2.obj: 7zBuf2.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zBuf2.obj -MD -MP -MF $(DEPDIR)/libviiz_a-7zBuf2.Tpo -c -o libviiz_a-7zBuf2.obj `if test -f '7zBuf2.c'; then $(CYGPATH_W) '7zBuf2.c'; else $(CYGPATH_W) '$(srcdir)/7zBuf2.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zBuf2.Tpo $(DEPDIR)/libviiz_a-7zBuf2.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zBuf2.c' object='libviiz_a-7zBuf2.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zBuf2.obj `if test -f '7zBuf2.c'; then $(CYGPATH_W) '7zBuf2.c'; else $(CYGPATH_W) '$(srcdir)/7zBuf2.c'; fi`++libviiz_a-7zCrc.o: 7zCrc.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zCrc.o -MD -MP -MF $(DEPDIR)/libviiz_a-7zCrc.Tpo -c -o libviiz_a-7zCrc.o `test -f '7zCrc.c' || echo '$(srcdir)/'`7zCrc.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zCrc.Tpo $(DEPDIR)/libviiz_a-7zCrc.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zCrc.c' object='libviiz_a-7zCrc.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zCrc.o `test -f '7zCrc.c' || echo '$(srcdir)/'`7zCrc.c++libviiz_a-7zCrc.obj: 7zCrc.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zCrc.obj -MD -MP -MF $(DEPDIR)/libviiz_a-7zCrc.Tpo -c -o libviiz_a-7zCrc.obj `if test -f '7zCrc.c'; then $(CYGPATH_W) '7zCrc.c'; else $(CYGPATH_W) '$(srcdir)/7zCrc.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zCrc.Tpo $(DEPDIR)/libviiz_a-7zCrc.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zCrc.c' object='libviiz_a-7zCrc.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zCrc.obj `if test -f '7zCrc.c'; then $(CYGPATH_W) '7zCrc.c'; else $(CYGPATH_W) '$(srcdir)/7zCrc.c'; fi`++libviiz_a-7zCrcOpt.o: 7zCrcOpt.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zCrcOpt.o -MD -MP -MF $(DEPDIR)/libviiz_a-7zCrcOpt.Tpo -c -o libviiz_a-7zCrcOpt.o `test -f '7zCrcOpt.c' || echo '$(srcdir)/'`7zCrcOpt.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zCrcOpt.Tpo $(DEPDIR)/libviiz_a-7zCrcOpt.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zCrcOpt.c' object='libviiz_a-7zCrcOpt.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zCrcOpt.o `test -f '7zCrcOpt.c' || echo '$(srcdir)/'`7zCrcOpt.c++libviiz_a-7zCrcOpt.obj: 7zCrcOpt.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zCrcOpt.obj -MD -MP -MF $(DEPDIR)/libviiz_a-7zCrcOpt.Tpo -c -o libviiz_a-7zCrcOpt.obj `if test -f '7zCrcOpt.c'; then $(CYGPATH_W) '7zCrcOpt.c'; else $(CYGPATH_W) '$(srcdir)/7zCrcOpt.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zCrcOpt.Tpo $(DEPDIR)/libviiz_a-7zCrcOpt.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zCrcOpt.c' object='libviiz_a-7zCrcOpt.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zCrcOpt.obj `if test -f '7zCrcOpt.c'; then $(CYGPATH_W) '7zCrcOpt.c'; else $(CYGPATH_W) '$(srcdir)/7zCrcOpt.c'; fi`++libviiz_a-7zDec.o: 7zDec.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zDec.o -MD -MP -MF $(DEPDIR)/libviiz_a-7zDec.Tpo -c -o libviiz_a-7zDec.o `test -f '7zDec.c' || echo '$(srcdir)/'`7zDec.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zDec.Tpo $(DEPDIR)/libviiz_a-7zDec.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zDec.c' object='libviiz_a-7zDec.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zDec.o `test -f '7zDec.c' || echo '$(srcdir)/'`7zDec.c++libviiz_a-7zDec.obj: 7zDec.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zDec.obj -MD -MP -MF $(DEPDIR)/libviiz_a-7zDec.Tpo -c -o libviiz_a-7zDec.obj `if test -f '7zDec.c'; then $(CYGPATH_W) '7zDec.c'; else $(CYGPATH_W) '$(srcdir)/7zDec.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zDec.Tpo $(DEPDIR)/libviiz_a-7zDec.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zDec.c' object='libviiz_a-7zDec.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zDec.obj `if test -f '7zDec.c'; then $(CYGPATH_W) '7zDec.c'; else $(CYGPATH_W) '$(srcdir)/7zDec.c'; fi`++libviiz_a-7zFile.o: 7zFile.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zFile.o -MD -MP -MF $(DEPDIR)/libviiz_a-7zFile.Tpo -c -o libviiz_a-7zFile.o `test -f '7zFile.c' || echo '$(srcdir)/'`7zFile.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zFile.Tpo $(DEPDIR)/libviiz_a-7zFile.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zFile.c' object='libviiz_a-7zFile.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zFile.o `test -f '7zFile.c' || echo '$(srcdir)/'`7zFile.c++libviiz_a-7zFile.obj: 7zFile.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zFile.obj -MD -MP -MF $(DEPDIR)/libviiz_a-7zFile.Tpo -c -o libviiz_a-7zFile.obj `if test -f '7zFile.c'; then $(CYGPATH_W) '7zFile.c'; else $(CYGPATH_W) '$(srcdir)/7zFile.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zFile.Tpo $(DEPDIR)/libviiz_a-7zFile.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zFile.c' object='libviiz_a-7zFile.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zFile.obj `if test -f '7zFile.c'; then $(CYGPATH_W) '7zFile.c'; else $(CYGPATH_W) '$(srcdir)/7zFile.c'; fi`++libviiz_a-7zStream.o: 7zStream.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zStream.o -MD -MP -MF $(DEPDIR)/libviiz_a-7zStream.Tpo -c -o libviiz_a-7zStream.o `test -f '7zStream.c' || echo '$(srcdir)/'`7zStream.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zStream.Tpo $(DEPDIR)/libviiz_a-7zStream.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zStream.c' object='libviiz_a-7zStream.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zStream.o `test -f '7zStream.c' || echo '$(srcdir)/'`7zStream.c++libviiz_a-7zStream.obj: 7zStream.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-7zStream.obj -MD -MP -MF $(DEPDIR)/libviiz_a-7zStream.Tpo -c -o libviiz_a-7zStream.obj `if test -f '7zStream.c'; then $(CYGPATH_W) '7zStream.c'; else $(CYGPATH_W) '$(srcdir)/7zStream.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-7zStream.Tpo $(DEPDIR)/libviiz_a-7zStream.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='7zStream.c' object='libviiz_a-7zStream.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-7zStream.obj `if test -f '7zStream.c'; then $(CYGPATH_W) '7zStream.c'; else $(CYGPATH_W) '$(srcdir)/7zStream.c'; fi`++libviiz_a-Bcj2.o: Bcj2.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Bcj2.o -MD -MP -MF $(DEPDIR)/libviiz_a-Bcj2.Tpo -c -o libviiz_a-Bcj2.o `test -f 'Bcj2.c' || echo '$(srcdir)/'`Bcj2.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Bcj2.Tpo $(DEPDIR)/libviiz_a-Bcj2.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Bcj2.c' object='libviiz_a-Bcj2.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Bcj2.o `test -f 'Bcj2.c' || echo '$(srcdir)/'`Bcj2.c++libviiz_a-Bcj2.obj: Bcj2.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Bcj2.obj -MD -MP -MF $(DEPDIR)/libviiz_a-Bcj2.Tpo -c -o libviiz_a-Bcj2.obj `if test -f 'Bcj2.c'; then $(CYGPATH_W) 'Bcj2.c'; else $(CYGPATH_W) '$(srcdir)/Bcj2.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Bcj2.Tpo $(DEPDIR)/libviiz_a-Bcj2.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Bcj2.c' object='libviiz_a-Bcj2.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Bcj2.obj `if test -f 'Bcj2.c'; then $(CYGPATH_W) 'Bcj2.c'; else $(CYGPATH_W) '$(srcdir)/Bcj2.c'; fi`++libviiz_a-Bra.o: Bra.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Bra.o -MD -MP -MF $(DEPDIR)/libviiz_a-Bra.Tpo -c -o libviiz_a-Bra.o `test -f 'Bra.c' || echo '$(srcdir)/'`Bra.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Bra.Tpo $(DEPDIR)/libviiz_a-Bra.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Bra.c' object='libviiz_a-Bra.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Bra.o `test -f 'Bra.c' || echo '$(srcdir)/'`Bra.c++libviiz_a-Bra.obj: Bra.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Bra.obj -MD -MP -MF $(DEPDIR)/libviiz_a-Bra.Tpo -c -o libviiz_a-Bra.obj `if test -f 'Bra.c'; then $(CYGPATH_W) 'Bra.c'; else $(CYGPATH_W) '$(srcdir)/Bra.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Bra.Tpo $(DEPDIR)/libviiz_a-Bra.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Bra.c' object='libviiz_a-Bra.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Bra.obj `if test -f 'Bra.c'; then $(CYGPATH_W) 'Bra.c'; else $(CYGPATH_W) '$(srcdir)/Bra.c'; fi`++libviiz_a-Bra86.o: Bra86.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Bra86.o -MD -MP -MF $(DEPDIR)/libviiz_a-Bra86.Tpo -c -o libviiz_a-Bra86.o `test -f 'Bra86.c' || echo '$(srcdir)/'`Bra86.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Bra86.Tpo $(DEPDIR)/libviiz_a-Bra86.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Bra86.c' object='libviiz_a-Bra86.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Bra86.o `test -f 'Bra86.c' || echo '$(srcdir)/'`Bra86.c++libviiz_a-Bra86.obj: Bra86.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Bra86.obj -MD -MP -MF $(DEPDIR)/libviiz_a-Bra86.Tpo -c -o libviiz_a-Bra86.obj `if test -f 'Bra86.c'; then $(CYGPATH_W) 'Bra86.c'; else $(CYGPATH_W) '$(srcdir)/Bra86.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Bra86.Tpo $(DEPDIR)/libviiz_a-Bra86.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Bra86.c' object='libviiz_a-Bra86.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Bra86.obj `if test -f 'Bra86.c'; then $(CYGPATH_W) 'Bra86.c'; else $(CYGPATH_W) '$(srcdir)/Bra86.c'; fi`++libviiz_a-BraIA64.o: BraIA64.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-BraIA64.o -MD -MP -MF $(DEPDIR)/libviiz_a-BraIA64.Tpo -c -o libviiz_a-BraIA64.o `test -f 'BraIA64.c' || echo '$(srcdir)/'`BraIA64.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-BraIA64.Tpo $(DEPDIR)/libviiz_a-BraIA64.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='BraIA64.c' object='libviiz_a-BraIA64.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-BraIA64.o `test -f 'BraIA64.c' || echo '$(srcdir)/'`BraIA64.c++libviiz_a-BraIA64.obj: BraIA64.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-BraIA64.obj -MD -MP -MF $(DEPDIR)/libviiz_a-BraIA64.Tpo -c -o libviiz_a-BraIA64.obj `if test -f 'BraIA64.c'; then $(CYGPATH_W) 'BraIA64.c'; else $(CYGPATH_W) '$(srcdir)/BraIA64.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-BraIA64.Tpo $(DEPDIR)/libviiz_a-BraIA64.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='BraIA64.c' object='libviiz_a-BraIA64.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-BraIA64.obj `if test -f 'BraIA64.c'; then $(CYGPATH_W) 'BraIA64.c'; else $(CYGPATH_W) '$(srcdir)/BraIA64.c'; fi`++libviiz_a-CpuArch.o: CpuArch.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-CpuArch.o -MD -MP -MF $(DEPDIR)/libviiz_a-CpuArch.Tpo -c -o libviiz_a-CpuArch.o `test -f 'CpuArch.c' || echo '$(srcdir)/'`CpuArch.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-CpuArch.Tpo $(DEPDIR)/libviiz_a-CpuArch.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='CpuArch.c' object='libviiz_a-CpuArch.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-CpuArch.o `test -f 'CpuArch.c' || echo '$(srcdir)/'`CpuArch.c++libviiz_a-CpuArch.obj: CpuArch.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-CpuArch.obj -MD -MP -MF $(DEPDIR)/libviiz_a-CpuArch.Tpo -c -o libviiz_a-CpuArch.obj `if test -f 'CpuArch.c'; then $(CYGPATH_W) 'CpuArch.c'; else $(CYGPATH_W) '$(srcdir)/CpuArch.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-CpuArch.Tpo $(DEPDIR)/libviiz_a-CpuArch.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='CpuArch.c' object='libviiz_a-CpuArch.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-CpuArch.obj `if test -f 'CpuArch.c'; then $(CYGPATH_W) 'CpuArch.c'; else $(CYGPATH_W) '$(srcdir)/CpuArch.c'; fi`++libviiz_a-Delta.o: Delta.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Delta.o -MD -MP -MF $(DEPDIR)/libviiz_a-Delta.Tpo -c -o libviiz_a-Delta.o `test -f 'Delta.c' || echo '$(srcdir)/'`Delta.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Delta.Tpo $(DEPDIR)/libviiz_a-Delta.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Delta.c' object='libviiz_a-Delta.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Delta.o `test -f 'Delta.c' || echo '$(srcdir)/'`Delta.c++libviiz_a-Delta.obj: Delta.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Delta.obj -MD -MP -MF $(DEPDIR)/libviiz_a-Delta.Tpo -c -o libviiz_a-Delta.obj `if test -f 'Delta.c'; then $(CYGPATH_W) 'Delta.c'; else $(CYGPATH_W) '$(srcdir)/Delta.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Delta.Tpo $(DEPDIR)/libviiz_a-Delta.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Delta.c' object='libviiz_a-Delta.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Delta.obj `if test -f 'Delta.c'; then $(CYGPATH_W) 'Delta.c'; else $(CYGPATH_W) '$(srcdir)/Delta.c'; fi`++libviiz_a-Lzma2Dec.o: Lzma2Dec.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Lzma2Dec.o -MD -MP -MF $(DEPDIR)/libviiz_a-Lzma2Dec.Tpo -c -o libviiz_a-Lzma2Dec.o `test -f 'Lzma2Dec.c' || echo '$(srcdir)/'`Lzma2Dec.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Lzma2Dec.Tpo $(DEPDIR)/libviiz_a-Lzma2Dec.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Lzma2Dec.c' object='libviiz_a-Lzma2Dec.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Lzma2Dec.o `test -f 'Lzma2Dec.c' || echo '$(srcdir)/'`Lzma2Dec.c++libviiz_a-Lzma2Dec.obj: Lzma2Dec.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Lzma2Dec.obj -MD -MP -MF $(DEPDIR)/libviiz_a-Lzma2Dec.Tpo -c -o libviiz_a-Lzma2Dec.obj `if test -f 'Lzma2Dec.c'; then $(CYGPATH_W) 'Lzma2Dec.c'; else $(CYGPATH_W) '$(srcdir)/Lzma2Dec.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Lzma2Dec.Tpo $(DEPDIR)/libviiz_a-Lzma2Dec.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Lzma2Dec.c' object='libviiz_a-Lzma2Dec.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Lzma2Dec.obj `if test -f 'Lzma2Dec.c'; then $(CYGPATH_W) 'Lzma2Dec.c'; else $(CYGPATH_W) '$(srcdir)/Lzma2Dec.c'; fi`++libviiz_a-LzmaDec.o: LzmaDec.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-LzmaDec.o -MD -MP -MF $(DEPDIR)/libviiz_a-LzmaDec.Tpo -c -o libviiz_a-LzmaDec.o `test -f 'LzmaDec.c' || echo '$(srcdir)/'`LzmaDec.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-LzmaDec.Tpo $(DEPDIR)/libviiz_a-LzmaDec.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='LzmaDec.c' object='libviiz_a-LzmaDec.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-LzmaDec.o `test -f 'LzmaDec.c' || echo '$(srcdir)/'`LzmaDec.c++libviiz_a-LzmaDec.obj: LzmaDec.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-LzmaDec.obj -MD -MP -MF $(DEPDIR)/libviiz_a-LzmaDec.Tpo -c -o libviiz_a-LzmaDec.obj `if test -f 'LzmaDec.c'; then $(CYGPATH_W) 'LzmaDec.c'; else $(CYGPATH_W) '$(srcdir)/LzmaDec.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-LzmaDec.Tpo $(DEPDIR)/libviiz_a-LzmaDec.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='LzmaDec.c' object='libviiz_a-LzmaDec.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-LzmaDec.obj `if test -f 'LzmaDec.c'; then $(CYGPATH_W) 'LzmaDec.c'; else $(CYGPATH_W) '$(srcdir)/LzmaDec.c'; fi`++libviiz_a-Ppmd7.o: Ppmd7.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Ppmd7.o -MD -MP -MF $(DEPDIR)/libviiz_a-Ppmd7.Tpo -c -o libviiz_a-Ppmd7.o `test -f 'Ppmd7.c' || echo '$(srcdir)/'`Ppmd7.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Ppmd7.Tpo $(DEPDIR)/libviiz_a-Ppmd7.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Ppmd7.c' object='libviiz_a-Ppmd7.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Ppmd7.o `test -f 'Ppmd7.c' || echo '$(srcdir)/'`Ppmd7.c++libviiz_a-Ppmd7.obj: Ppmd7.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Ppmd7.obj -MD -MP -MF $(DEPDIR)/libviiz_a-Ppmd7.Tpo -c -o libviiz_a-Ppmd7.obj `if test -f 'Ppmd7.c'; then $(CYGPATH_W) 'Ppmd7.c'; else $(CYGPATH_W) '$(srcdir)/Ppmd7.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Ppmd7.Tpo $(DEPDIR)/libviiz_a-Ppmd7.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Ppmd7.c' object='libviiz_a-Ppmd7.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Ppmd7.obj `if test -f 'Ppmd7.c'; then $(CYGPATH_W) 'Ppmd7.c'; else $(CYGPATH_W) '$(srcdir)/Ppmd7.c'; fi`++libviiz_a-Ppmd7Dec.o: Ppmd7Dec.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Ppmd7Dec.o -MD -MP -MF $(DEPDIR)/libviiz_a-Ppmd7Dec.Tpo -c -o libviiz_a-Ppmd7Dec.o `test -f 'Ppmd7Dec.c' || echo '$(srcdir)/'`Ppmd7Dec.c+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Ppmd7Dec.Tpo $(DEPDIR)/libviiz_a-Ppmd7Dec.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Ppmd7Dec.c' object='libviiz_a-Ppmd7Dec.o' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Ppmd7Dec.o `test -f 'Ppmd7Dec.c' || echo '$(srcdir)/'`Ppmd7Dec.c++libviiz_a-Ppmd7Dec.obj: Ppmd7Dec.c+@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libviiz_a-Ppmd7Dec.obj -MD -MP -MF $(DEPDIR)/libviiz_a-Ppmd7Dec.Tpo -c -o libviiz_a-Ppmd7Dec.obj `if test -f 'Ppmd7Dec.c'; then $(CYGPATH_W) 'Ppmd7Dec.c'; else $(CYGPATH_W) '$(srcdir)/Ppmd7Dec.c'; fi`+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libviiz_a-Ppmd7Dec.Tpo $(DEPDIR)/libviiz_a-Ppmd7Dec.Po+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='Ppmd7Dec.c' object='libviiz_a-Ppmd7Dec.obj' libtool=no @AMDEPBACKSLASH@+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libviiz_a_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libviiz_a-Ppmd7Dec.obj `if test -f 'Ppmd7Dec.c'; then $(CYGPATH_W) 'Ppmd7Dec.c'; else $(CYGPATH_W) '$(srcdir)/Ppmd7Dec.c'; fi`++ID: $(am__tagged_files)+ $(am__define_uniq_tagged_files); mkid -fID $$unique+tags: tags-am+TAGS: tags++tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)+ set x; \+ here=`pwd`; \+ $(am__define_uniq_tagged_files); \+ shift; \+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \+ test -n "$$unique" || unique=$$empty_fix; \+ if test $$# -gt 0; then \+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \+ "$$@" $$unique; \+ else \+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \+ $$unique; \+ fi; \+ fi+ctags: ctags-am++CTAGS: ctags+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)+ $(am__define_uniq_tagged_files); \+ test -z "$(CTAGS_ARGS)$$unique" \+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \+ $$unique++GTAGS:+ here=`$(am__cd) $(top_builddir) && pwd` \+ && $(am__cd) $(top_srcdir) \+ && gtags -i $(GTAGS_ARGS) "$$here"+cscopelist: cscopelist-am++cscopelist-am: $(am__tagged_files)+ list='$(am__tagged_files)'; \+ case "$(srcdir)" in \+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \+ *) sdir=$(subdir)/$(srcdir) ;; \+ esac; \+ for i in $$list; do \+ if test -f "$$i"; then \+ echo "$(subdir)/$$i"; \+ else \+ echo "$$sdir/$$i"; \+ fi; \+ done >> $(top_builddir)/cscope.files++distclean-tags:+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags+distdir: $(BUILT_SOURCES)+ $(MAKE) $(AM_MAKEFLAGS) distdir-am++distdir-am: $(DISTFILES)+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \+ list='$(DISTFILES)'; \+ dist_files=`for file in $$list; do echo $$file; done | \+ sed -e "s|^$$srcdirstrip/||;t" \+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \+ case $$dist_files in \+ */*) $(MKDIR_P) `echo "$$dist_files" | \+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \+ sort -u` ;; \+ esac; \+ for file in $$dist_files; do \+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \+ if test -d $$d/$$file; then \+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \+ if test -d "$(distdir)/$$file"; then \+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \+ fi; \+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \+ fi; \+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \+ else \+ test -f "$(distdir)/$$file" \+ || cp -p $$d/$$file "$(distdir)/$$file" \+ || exit 1; \+ fi; \+ done+check-am: all-am+check: check-am+all-am: Makefile $(LIBRARIES)+installdirs:+install: install-am+install-exec: install-exec-am+install-data: install-data-am+uninstall: uninstall-am++install-am: all-am+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am++installcheck: installcheck-am+install-strip:+ if test -z '$(STRIP)'; then \+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \+ install; \+ else \+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \+ fi+mostlyclean-generic:++clean-generic:++distclean-generic:+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)++maintainer-clean-generic:+ @echo "This command is intended for maintainers to use"+ @echo "it deletes files that may require special tools to rebuild."+clean: clean-am++clean-am: clean-generic clean-noinstLIBRARIES mostlyclean-am++distclean: distclean-am+ -rm -f ./$(DEPDIR)/libviiz_a-7zAlloc.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zArcIn.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zBuf.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zBuf2.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zCrc.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zCrcOpt.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zDec.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zFile.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zStream.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Bcj2.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Bra.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Bra86.Po+ -rm -f ./$(DEPDIR)/libviiz_a-BraIA64.Po+ -rm -f ./$(DEPDIR)/libviiz_a-CpuArch.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Delta.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Lzma2Dec.Po+ -rm -f ./$(DEPDIR)/libviiz_a-LzmaDec.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Ppmd7.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Ppmd7Dec.Po+ -rm -f ./$(DEPDIR)/libviiz_a-viizip.Po+ -rm -f Makefile+distclean-am: clean-am distclean-compile distclean-generic \+ distclean-tags++dvi: dvi-am++dvi-am:++html: html-am++html-am:++info: info-am++info-am:++install-data-am:++install-dvi: install-dvi-am++install-dvi-am:++install-exec-am:++install-html: install-html-am++install-html-am:++install-info: install-info-am++install-info-am:++install-man:++install-pdf: install-pdf-am++install-pdf-am:++install-ps: install-ps-am++install-ps-am:++installcheck-am:++maintainer-clean: maintainer-clean-am+ -rm -f ./$(DEPDIR)/libviiz_a-7zAlloc.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zArcIn.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zBuf.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zBuf2.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zCrc.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zCrcOpt.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zDec.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zFile.Po+ -rm -f ./$(DEPDIR)/libviiz_a-7zStream.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Bcj2.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Bra.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Bra86.Po+ -rm -f ./$(DEPDIR)/libviiz_a-BraIA64.Po+ -rm -f ./$(DEPDIR)/libviiz_a-CpuArch.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Delta.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Lzma2Dec.Po+ -rm -f ./$(DEPDIR)/libviiz_a-LzmaDec.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Ppmd7.Po+ -rm -f ./$(DEPDIR)/libviiz_a-Ppmd7Dec.Po+ -rm -f ./$(DEPDIR)/libviiz_a-viizip.Po+ -rm -f Makefile+maintainer-clean-am: distclean-am maintainer-clean-generic++mostlyclean: mostlyclean-am++mostlyclean-am: mostlyclean-compile mostlyclean-generic++pdf: pdf-am++pdf-am:++ps: ps-am++ps-am:++uninstall-am:++.MAKE: install-am install-strip++.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \+ clean-generic clean-noinstLIBRARIES cscopelist-am ctags \+ ctags-am distclean distclean-compile distclean-generic \+ distclean-tags distdir dvi dvi-am html html-am info info-am \+ install install-am install-data install-data-am install-dvi \+ install-dvi-am install-exec install-exec-am install-html \+ install-html-am install-info install-info-am install-man \+ install-pdf install-pdf-am install-ps install-ps-am \+ install-strip installcheck installcheck-am installdirs \+ maintainer-clean maintainer-clean-generic mostlyclean \+ mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \+ tags tags-am uninstall uninstall-am++.PRECIOUS: Makefile+++# Tell versions [3.59,3.63) of GNU make to not export all variables.+# Otherwise a system limit (for SysV at least) may be exceeded.+.NOEXPORT:
@@ -0,0 +1,169 @@+/* Ppmd.h -- PPMD codec common code+2023-03-05 : Igor Pavlov : Public domain+This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */++#ifndef ZIP7_INC_PPMD_H+#define ZIP7_INC_PPMD_H++#include "CpuArch.h"++EXTERN_C_BEGIN++#if defined(MY_CPU_SIZEOF_POINTER) && (MY_CPU_SIZEOF_POINTER == 4)+/*+ PPMD code always uses 32-bit internal fields in PPMD structures to store internal references in main block.+ if (PPMD_32BIT is defined), the PPMD code stores internal pointers to 32-bit reference fields.+ if (PPMD_32BIT is NOT defined), the PPMD code stores internal UInt32 offsets to reference fields.+ if (pointer size is 64-bit), then (PPMD_32BIT) mode is not allowed,+ if (pointer size is 32-bit), then (PPMD_32BIT) mode is optional,+ and it's allowed to disable PPMD_32BIT mode even if pointer is 32-bit.+ PPMD code works slightly faster in (PPMD_32BIT) mode.+*/+ #define PPMD_32BIT+#endif++#define PPMD_INT_BITS 7+#define PPMD_PERIOD_BITS 7+#define PPMD_BIN_SCALE (1 << (PPMD_INT_BITS + PPMD_PERIOD_BITS))++#define PPMD_GET_MEAN_SPEC(summ, shift, round) (((summ) + (1 << ((shift) - (round)))) >> (shift))+#define PPMD_GET_MEAN(summ) PPMD_GET_MEAN_SPEC((summ), PPMD_PERIOD_BITS, 2)+#define PPMD_UPDATE_PROB_0(prob) ((prob) + (1 << PPMD_INT_BITS) - PPMD_GET_MEAN(prob))+#define PPMD_UPDATE_PROB_1(prob) ((prob) - PPMD_GET_MEAN(prob))++#define PPMD_N1 4+#define PPMD_N2 4+#define PPMD_N3 4+#define PPMD_N4 ((128 + 3 - 1 * PPMD_N1 - 2 * PPMD_N2 - 3 * PPMD_N3) / 4)+#define PPMD_NUM_INDEXES (PPMD_N1 + PPMD_N2 + PPMD_N3 + PPMD_N4)++MY_CPU_pragma_pack_push_1+/* Most compilers works OK here even without #pragma pack(push, 1), but some GCC compilers need it. */++/* SEE-contexts for PPM-contexts with masked symbols */+typedef struct+{+ UInt16 Summ; /* Freq */+ Byte Shift; /* Speed of Freq change; low Shift is for fast change */+ Byte Count; /* Count to next change of Shift */+} CPpmd_See;++#define Ppmd_See_UPDATE(p) \+ { if ((p)->Shift < PPMD_PERIOD_BITS && --(p)->Count == 0) \+ { (p)->Summ = (UInt16)((p)->Summ << 1); \+ (p)->Count = (Byte)(3 << (p)->Shift++); }}+++typedef struct+{+ Byte Symbol;+ Byte Freq;+ UInt16 Successor_0;+ UInt16 Successor_1;+} CPpmd_State;++typedef struct CPpmd_State2_+{+ Byte Symbol;+ Byte Freq;+} CPpmd_State2;++typedef struct CPpmd_State4_+{+ UInt16 Successor_0;+ UInt16 Successor_1;+} CPpmd_State4;++MY_CPU_pragma_pop++/*+ PPMD code can write full CPpmd_State structure data to CPpmd*_Context+ at (byte offset = 2) instead of some fields of original CPpmd*_Context structure.+ + If we use pointers to different types, but that point to shared+ memory space, we can have aliasing problem (strict aliasing).+ + XLC compiler in -O2 mode can change the order of memory write instructions+ in relation to read instructions, if we have use pointers to different types.+ + To solve that aliasing problem we use combined CPpmd*_Context structure+ with unions that contain the fields from both structures:+ the original CPpmd*_Context and CPpmd_State.+ So we can access the fields from both structures via one pointer,+ and the compiler doesn't change the order of write instructions+ in relation to read instructions.++ If we don't use memory write instructions to shared memory in+ some local code, and we use only reading instructions (read only),+ then probably it's safe to use pointers to different types for reading.+*/+ +++#ifdef PPMD_32BIT++ #define Ppmd_Ref_Type(type) type *+ #define Ppmd_GetRef(p, ptr) (ptr)+ #define Ppmd_GetPtr(p, ptr) (ptr)+ #define Ppmd_GetPtr_Type(p, ptr, note_type) (ptr)++#else++ #define Ppmd_Ref_Type(type) UInt32+ #define Ppmd_GetRef(p, ptr) ((UInt32)((Byte *)(ptr) - (p)->Base))+ #define Ppmd_GetPtr(p, offs) ((void *)((p)->Base + (offs)))+ #define Ppmd_GetPtr_Type(p, offs, type) ((type *)Ppmd_GetPtr(p, offs))++#endif // PPMD_32BIT+++typedef Ppmd_Ref_Type(CPpmd_State) CPpmd_State_Ref;+typedef Ppmd_Ref_Type(void) CPpmd_Void_Ref;+typedef Ppmd_Ref_Type(Byte) CPpmd_Byte_Ref;+++/*+#ifdef MY_CPU_LE_UNALIGN+// the unaligned 32-bit access latency can be too large, if the data is not in L1 cache.+#define Ppmd_GET_SUCCESSOR(p) ((CPpmd_Void_Ref)*(const UInt32 *)(const void *)&(p)->Successor_0)+#define Ppmd_SET_SUCCESSOR(p, v) *(UInt32 *)(void *)(void *)&(p)->Successor_0 = (UInt32)(v)++#else+*/++/*+ We can write 16-bit halves to 32-bit (Successor) field in any selected order.+ But the native order is more consistent way.+ So we use the native order, if LE/BE order can be detected here at compile time.+*/++#ifdef MY_CPU_BE++ #define Ppmd_GET_SUCCESSOR(p) \+ ( (CPpmd_Void_Ref) (((UInt32)(p)->Successor_0 << 16) | (p)->Successor_1) )++ #define Ppmd_SET_SUCCESSOR(p, v) { \+ (p)->Successor_0 = (UInt16)(((UInt32)(v) >> 16) /* & 0xFFFF */); \+ (p)->Successor_1 = (UInt16)((UInt32)(v) /* & 0xFFFF */); }++#else++ #define Ppmd_GET_SUCCESSOR(p) \+ ( (CPpmd_Void_Ref) ((p)->Successor_0 | ((UInt32)(p)->Successor_1 << 16)) )++ #define Ppmd_SET_SUCCESSOR(p, v) { \+ (p)->Successor_0 = (UInt16)((UInt32)(v) /* & 0xFFFF */); \+ (p)->Successor_1 = (UInt16)(((UInt32)(v) >> 16) /* & 0xFFFF */); }++#endif++// #endif+++#define PPMD_SetAllBitsIn256Bytes(p) \+ { size_t z; for (z = 0; z < 256 / sizeof(p[0]); z += 8) { \+ p[z+7] = p[z+6] = p[z+5] = p[z+4] = p[z+3] = p[z+2] = p[z+1] = p[z+0] = ~(size_t)0; }}++EXTERN_C_END+ +#endif
@@ -0,0 +1,1122 @@+/* Ppmd7.c -- PPMdH codec+2023-04-02 : Igor Pavlov : Public domain+This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */++#include "Precomp.h"++#include <string.h>++#include "Ppmd7.h"++/* define PPMD7_ORDER_0_SUPPPORT to suport order-0 mode, unsupported by orignal PPMd var.H. code */+// #define PPMD7_ORDER_0_SUPPPORT+ +MY_ALIGN(16)+static const Byte PPMD7_kExpEscape[16] = { 25, 14, 9, 7, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 2 };+MY_ALIGN(16)+static const UInt16 PPMD7_kInitBinEsc[] = { 0x3CDD, 0x1F3F, 0x59BF, 0x48F3, 0x64A1, 0x5ABC, 0x6632, 0x6051};++#define MAX_FREQ 124+#define UNIT_SIZE 12++#define U2B(nu) ((UInt32)(nu) * UNIT_SIZE)+#define U2I(nu) (p->Units2Indx[(size_t)(nu) - 1])+#define I2U(indx) ((unsigned)p->Indx2Units[indx])+#define I2U_UInt16(indx) ((UInt16)p->Indx2Units[indx])++#define REF(ptr) Ppmd_GetRef(p, ptr)++#define STATS_REF(ptr) ((CPpmd_State_Ref)REF(ptr))++#define CTX(ref) ((CPpmd7_Context *)Ppmd7_GetContext(p, ref))+#define STATS(ctx) Ppmd7_GetStats(p, ctx)+#define ONE_STATE(ctx) Ppmd7Context_OneState(ctx)+#define SUFFIX(ctx) CTX((ctx)->Suffix)++typedef CPpmd7_Context * PPMD7_CTX_PTR;++struct CPpmd7_Node_;++typedef Ppmd_Ref_Type(struct CPpmd7_Node_) CPpmd7_Node_Ref;++typedef struct CPpmd7_Node_+{+ UInt16 Stamp; /* must be at offset 0 as CPpmd7_Context::NumStats. Stamp=0 means free */+ UInt16 NU;+ CPpmd7_Node_Ref Next; /* must be at offset >= 4 */+ CPpmd7_Node_Ref Prev;+} CPpmd7_Node;++#define NODE(r) Ppmd_GetPtr_Type(p, r, CPpmd7_Node)++void Ppmd7_Construct(CPpmd7 *p)+{+ unsigned i, k, m;++ p->Base = NULL;++ for (i = 0, k = 0; i < PPMD_NUM_INDEXES; i++)+ {+ unsigned step = (i >= 12 ? 4 : (i >> 2) + 1);+ do { p->Units2Indx[k++] = (Byte)i; } while (--step);+ p->Indx2Units[i] = (Byte)k;+ }++ p->NS2BSIndx[0] = (0 << 1);+ p->NS2BSIndx[1] = (1 << 1);+ memset(p->NS2BSIndx + 2, (2 << 1), 9);+ memset(p->NS2BSIndx + 11, (3 << 1), 256 - 11);++ for (i = 0; i < 3; i++)+ p->NS2Indx[i] = (Byte)i;++ for (m = i, k = 1; i < 256; i++)+ {+ p->NS2Indx[i] = (Byte)m;+ if (--k == 0)+ k = (++m) - 2;+ }++ memcpy(p->ExpEscape, PPMD7_kExpEscape, 16);+}+++void Ppmd7_Free(CPpmd7 *p, ISzAllocPtr alloc)+{+ ISzAlloc_Free(alloc, p->Base);+ p->Size = 0;+ p->Base = NULL;+}+++BoolInt Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAllocPtr alloc)+{+ if (!p->Base || p->Size != size)+ {+ Ppmd7_Free(p, alloc);+ p->AlignOffset = (4 - size) & 3;+ if ((p->Base = (Byte *)ISzAlloc_Alloc(alloc, p->AlignOffset + size)) == NULL)+ return False;+ p->Size = size;+ }+ return True;+}++++// ---------- Internal Memory Allocator ----------++/* We can use CPpmd7_Node in list of free units (as in Ppmd8)+ But we still need one additional list walk pass in Ppmd7_GlueFreeBlocks().+ So we use simple CPpmd_Void_Ref instead of CPpmd7_Node in Ppmd7_InsertNode() / Ppmd7_RemoveNode()+*/++#define EMPTY_NODE 0+++static void Ppmd7_InsertNode(CPpmd7 *p, void *node, unsigned indx)+{+ *((CPpmd_Void_Ref *)node) = p->FreeList[indx];+ // ((CPpmd7_Node *)node)->Next = (CPpmd7_Node_Ref)p->FreeList[indx];++ p->FreeList[indx] = REF(node);++}+++static void *Ppmd7_RemoveNode(CPpmd7 *p, unsigned indx)+{+ CPpmd_Void_Ref *node = (CPpmd_Void_Ref *)Ppmd7_GetPtr(p, p->FreeList[indx]);+ p->FreeList[indx] = *node;+ // CPpmd7_Node *node = NODE((CPpmd7_Node_Ref)p->FreeList[indx]);+ // p->FreeList[indx] = node->Next;+ return node;+}+++static void Ppmd7_SplitBlock(CPpmd7 *p, void *ptr, unsigned oldIndx, unsigned newIndx)+{+ unsigned i, nu = I2U(oldIndx) - I2U(newIndx);+ ptr = (Byte *)ptr + U2B(I2U(newIndx));+ if (I2U(i = U2I(nu)) != nu)+ {+ unsigned k = I2U(--i);+ Ppmd7_InsertNode(p, ((Byte *)ptr) + U2B(k), nu - k - 1);+ }+ Ppmd7_InsertNode(p, ptr, i);+}+++/* we use CPpmd7_Node_Union union to solve XLC -O2 strict pointer aliasing problem */++typedef union+{+ CPpmd7_Node Node;+ CPpmd7_Node_Ref NextRef;+} CPpmd7_Node_Union;++/* Original PPmdH (Ppmd7) code uses doubly linked list in Ppmd7_GlueFreeBlocks()+ we use single linked list similar to Ppmd8 code */+++static void Ppmd7_GlueFreeBlocks(CPpmd7 *p)+{+ /*+ we use first UInt16 field of 12-bytes UNITs as record type stamp+ CPpmd_State { Byte Symbol; Byte Freq; : Freq != 0+ CPpmd7_Context { UInt16 NumStats; : NumStats != 0+ CPpmd7_Node { UInt16 Stamp : Stamp == 0 for free record+ : Stamp == 1 for head record and guard+ Last 12-bytes UNIT in array is always contains 12-bytes order-0 CPpmd7_Context record.+ */+ CPpmd7_Node_Ref head, n = 0;+ + p->GlueCount = 255;++ + /* we set guard NODE at LoUnit */+ if (p->LoUnit != p->HiUnit)+ ((CPpmd7_Node *)(void *)p->LoUnit)->Stamp = 1;++ {+ /* Create list of free blocks.+ We still need one additional list walk pass before Glue. */+ unsigned i;+ for (i = 0; i < PPMD_NUM_INDEXES; i++)+ {+ const UInt16 nu = I2U_UInt16(i);+ CPpmd7_Node_Ref next = (CPpmd7_Node_Ref)p->FreeList[i];+ p->FreeList[i] = 0;+ while (next != 0)+ {+ /* Don't change the order of the following commands: */+ CPpmd7_Node_Union *un = (CPpmd7_Node_Union *)NODE(next);+ const CPpmd7_Node_Ref tmp = next;+ next = un->NextRef;+ un->Node.Stamp = EMPTY_NODE;+ un->Node.NU = nu;+ un->Node.Next = n;+ n = tmp;+ }+ }+ }++ head = n;+ /* Glue and Fill must walk the list in same direction */+ {+ /* Glue free blocks */+ CPpmd7_Node_Ref *prev = &head;+ while (n)+ {+ CPpmd7_Node *node = NODE(n);+ UInt32 nu = node->NU;+ n = node->Next;+ if (nu == 0)+ {+ *prev = n;+ continue;+ }+ prev = &node->Next;+ for (;;)+ {+ CPpmd7_Node *node2 = node + nu;+ nu += node2->NU;+ if (node2->Stamp != EMPTY_NODE || nu >= 0x10000)+ break;+ node->NU = (UInt16)nu;+ node2->NU = 0;+ }+ }+ }++ /* Fill lists of free blocks */+ for (n = head; n != 0;)+ {+ CPpmd7_Node *node = NODE(n);+ UInt32 nu = node->NU;+ unsigned i;+ n = node->Next;+ if (nu == 0)+ continue;+ for (; nu > 128; nu -= 128, node += 128)+ Ppmd7_InsertNode(p, node, PPMD_NUM_INDEXES - 1);+ if (I2U(i = U2I(nu)) != nu)+ {+ unsigned k = I2U(--i);+ Ppmd7_InsertNode(p, node + k, (unsigned)nu - k - 1);+ }+ Ppmd7_InsertNode(p, node, i);+ }+}+++Z7_NO_INLINE+static void *Ppmd7_AllocUnitsRare(CPpmd7 *p, unsigned indx)+{+ unsigned i;+ + if (p->GlueCount == 0)+ {+ Ppmd7_GlueFreeBlocks(p);+ if (p->FreeList[indx] != 0)+ return Ppmd7_RemoveNode(p, indx);+ }+ + i = indx;+ + do+ {+ if (++i == PPMD_NUM_INDEXES)+ {+ UInt32 numBytes = U2B(I2U(indx));+ Byte *us = p->UnitsStart;+ p->GlueCount--;+ return ((UInt32)(us - p->Text) > numBytes) ? (p->UnitsStart = us - numBytes) : NULL;+ }+ }+ while (p->FreeList[i] == 0);++ {+ void *block = Ppmd7_RemoveNode(p, i);+ Ppmd7_SplitBlock(p, block, i, indx);+ return block;+ }+}+++static void *Ppmd7_AllocUnits(CPpmd7 *p, unsigned indx)+{+ if (p->FreeList[indx] != 0)+ return Ppmd7_RemoveNode(p, indx);+ {+ UInt32 numBytes = U2B(I2U(indx));+ Byte *lo = p->LoUnit;+ if ((UInt32)(p->HiUnit - lo) >= numBytes)+ {+ p->LoUnit = lo + numBytes;+ return lo;+ }+ }+ return Ppmd7_AllocUnitsRare(p, indx);+}+++#define MEM_12_CPY(dest, src, num) \+ { UInt32 *d = (UInt32 *)dest; const UInt32 *z = (const UInt32 *)src; UInt32 n = num; \+ do { d[0] = z[0]; d[1] = z[1]; d[2] = z[2]; z += 3; d += 3; } while (--n); }+++/*+static void *ShrinkUnits(CPpmd7 *p, void *oldPtr, unsigned oldNU, unsigned newNU)+{+ unsigned i0 = U2I(oldNU);+ unsigned i1 = U2I(newNU);+ if (i0 == i1)+ return oldPtr;+ if (p->FreeList[i1] != 0)+ {+ void *ptr = Ppmd7_RemoveNode(p, i1);+ MEM_12_CPY(ptr, oldPtr, newNU)+ Ppmd7_InsertNode(p, oldPtr, i0);+ return ptr;+ }+ Ppmd7_SplitBlock(p, oldPtr, i0, i1);+ return oldPtr;+}+*/+++#define SUCCESSOR(p) Ppmd_GET_SUCCESSOR(p)+static void SetSuccessor(CPpmd_State *p, CPpmd_Void_Ref v)+{+ Ppmd_SET_SUCCESSOR(p, v)+}++++Z7_NO_INLINE+static+void Ppmd7_RestartModel(CPpmd7 *p)+{+ unsigned i, k;++ memset(p->FreeList, 0, sizeof(p->FreeList));+ + p->Text = p->Base + p->AlignOffset;+ p->HiUnit = p->Text + p->Size;+ p->LoUnit = p->UnitsStart = p->HiUnit - p->Size / 8 / UNIT_SIZE * 7 * UNIT_SIZE;+ p->GlueCount = 0;++ p->OrderFall = p->MaxOrder;+ p->RunLength = p->InitRL = -(Int32)((p->MaxOrder < 12) ? p->MaxOrder : 12) - 1;+ p->PrevSuccess = 0;++ {+ CPpmd7_Context *mc = (PPMD7_CTX_PTR)(void *)(p->HiUnit -= UNIT_SIZE); /* AllocContext(p); */+ CPpmd_State *s = (CPpmd_State *)p->LoUnit; /* Ppmd7_AllocUnits(p, PPMD_NUM_INDEXES - 1); */+ + p->LoUnit += U2B(256 / 2);+ p->MaxContext = p->MinContext = mc;+ p->FoundState = s;++ mc->NumStats = 256;+ mc->Union2.SummFreq = 256 + 1;+ mc->Union4.Stats = REF(s);+ mc->Suffix = 0;++ for (i = 0; i < 256; i++, s++)+ {+ s->Symbol = (Byte)i;+ s->Freq = 1;+ SetSuccessor(s, 0);+ }++ #ifdef PPMD7_ORDER_0_SUPPPORT+ if (p->MaxOrder == 0)+ {+ CPpmd_Void_Ref r = REF(mc);+ s = p->FoundState;+ for (i = 0; i < 256; i++, s++)+ SetSuccessor(s, r);+ return;+ }+ #endif+ }++ for (i = 0; i < 128; i++)+ + + + for (k = 0; k < 8; k++)+ {+ unsigned m;+ UInt16 *dest = p->BinSumm[i] + k;+ const UInt16 val = (UInt16)(PPMD_BIN_SCALE - PPMD7_kInitBinEsc[k] / (i + 2));+ for (m = 0; m < 64; m += 8)+ dest[m] = val;+ }++ + for (i = 0; i < 25; i++)+ {++ CPpmd_See *s = p->See[i];+ + + + unsigned summ = ((5 * i + 10) << (PPMD_PERIOD_BITS - 4));+ for (k = 0; k < 16; k++, s++)+ {+ s->Summ = (UInt16)summ;+ s->Shift = (PPMD_PERIOD_BITS - 4);+ s->Count = 4;+ }+ }+ + p->DummySee.Summ = 0; /* unused */+ p->DummySee.Shift = PPMD_PERIOD_BITS;+ p->DummySee.Count = 64; /* unused */+}+++void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder)+{+ p->MaxOrder = maxOrder;++ Ppmd7_RestartModel(p);+}++++/*+ Ppmd7_CreateSuccessors()+ It's called when (FoundState->Successor) is RAW-Successor,+ that is the link to position in Raw text.+ So we create Context records and write the links to+ FoundState->Successor and to identical RAW-Successors in suffix+ contexts of MinContex.+ + The function returns:+ if (OrderFall == 0) then MinContext is already at MAX order,+ { return pointer to new or existing context of same MAX order }+ else+ { return pointer to new real context that will be (Order+1) in comparison with MinContext++ also it can return pointer to real context of same order,+*/++Z7_NO_INLINE+static PPMD7_CTX_PTR Ppmd7_CreateSuccessors(CPpmd7 *p)+{+ PPMD7_CTX_PTR c = p->MinContext;+ CPpmd_Byte_Ref upBranch = (CPpmd_Byte_Ref)SUCCESSOR(p->FoundState);+ Byte newSym, newFreq;+ unsigned numPs = 0;+ CPpmd_State *ps[PPMD7_MAX_ORDER];++ if (p->OrderFall != 0)+ ps[numPs++] = p->FoundState;+ + while (c->Suffix)+ {+ CPpmd_Void_Ref successor;+ CPpmd_State *s;+ c = SUFFIX(c);+ ++ if (c->NumStats != 1)+ {+ Byte sym = p->FoundState->Symbol;+ for (s = STATS(c); s->Symbol != sym; s++);++ }+ else+ {+ s = ONE_STATE(c);++ }+ successor = SUCCESSOR(s);+ if (successor != upBranch)+ {+ // (c) is real record Context here,+ c = CTX(successor);+ if (numPs == 0)+ {+ // (c) is real record MAX Order Context here,+ // So we don't need to create any new contexts.+ return c;+ }+ break;+ }+ ps[numPs++] = s;+ }+ + // All created contexts will have single-symbol with new RAW-Successor+ // All new RAW-Successors will point to next position in RAW text+ // after FoundState->Successor++ newSym = *(const Byte *)Ppmd7_GetPtr(p, upBranch);+ upBranch++;+ + + if (c->NumStats == 1)+ newFreq = ONE_STATE(c)->Freq;+ else+ {+ UInt32 cf, s0;+ CPpmd_State *s;+ for (s = STATS(c); s->Symbol != newSym; s++);+ cf = (UInt32)s->Freq - 1;+ s0 = (UInt32)c->Union2.SummFreq - c->NumStats - cf;+ /*+ cf - is frequency of symbol that will be Successor in new context records.+ s0 - is commulative frequency sum of another symbols from parent context.+ max(newFreq)= (s->Freq + 1), when (s0 == 1)+ we have requirement (Ppmd7Context_OneState()->Freq <= 128) in BinSumm[]+ so (s->Freq < 128) - is requirement for multi-symbol contexts+ */+ newFreq = (Byte)(1 + ((2 * cf <= s0) ? (5 * cf > s0) : (2 * cf + s0 - 1) / (2 * s0) + 1));+ }++ // Create new single-symbol contexts from low order to high order in loop++ do+ {+ PPMD7_CTX_PTR c1;+ /* = AllocContext(p); */+ if (p->HiUnit != p->LoUnit)+ c1 = (PPMD7_CTX_PTR)(void *)(p->HiUnit -= UNIT_SIZE);+ else if (p->FreeList[0] != 0)+ c1 = (PPMD7_CTX_PTR)Ppmd7_RemoveNode(p, 0);+ else+ {+ c1 = (PPMD7_CTX_PTR)Ppmd7_AllocUnitsRare(p, 0);+ if (!c1)+ return NULL;+ }+ + c1->NumStats = 1;+ ONE_STATE(c1)->Symbol = newSym;+ ONE_STATE(c1)->Freq = newFreq;+ SetSuccessor(ONE_STATE(c1), upBranch);+ c1->Suffix = REF(c);+ SetSuccessor(ps[--numPs], REF(c1));+ c = c1;+ }+ while (numPs != 0);+ + return c;+}++++#define SWAP_STATES(s) \+ { CPpmd_State tmp = s[0]; s[0] = s[-1]; s[-1] = tmp; }+++void Ppmd7_UpdateModel(CPpmd7 *p);+Z7_NO_INLINE+void Ppmd7_UpdateModel(CPpmd7 *p)+{+ CPpmd_Void_Ref maxSuccessor, minSuccessor;+ PPMD7_CTX_PTR c, mc;+ unsigned s0, ns;++++ if (p->FoundState->Freq < MAX_FREQ / 4 && p->MinContext->Suffix != 0)+ {+ /* Update Freqs in Suffix Context */++ c = SUFFIX(p->MinContext);+ + if (c->NumStats == 1)+ {+ CPpmd_State *s = ONE_STATE(c);+ if (s->Freq < 32)+ s->Freq++;+ }+ else+ {+ CPpmd_State *s = STATS(c);+ Byte sym = p->FoundState->Symbol;+ + if (s->Symbol != sym)+ {+ do+ {+ // s++; if (s->Symbol == sym) break;+ s++;+ }+ while (s->Symbol != sym);+ + if (s[0].Freq >= s[-1].Freq)+ {+ SWAP_STATES(s)+ s--;+ }+ }++ if (s->Freq < MAX_FREQ - 9)+ {+ s->Freq = (Byte)(s->Freq + 2);+ c->Union2.SummFreq = (UInt16)(c->Union2.SummFreq + 2);+ }+ }+ }++ + if (p->OrderFall == 0)+ {+ /* MAX ORDER context */+ /* (FoundState->Successor) is RAW-Successor. */+ p->MaxContext = p->MinContext = Ppmd7_CreateSuccessors(p);+ if (!p->MinContext)+ {+ Ppmd7_RestartModel(p);+ return;+ }+ SetSuccessor(p->FoundState, REF(p->MinContext));+ return;+ }++ + /* NON-MAX ORDER context */+ + {+ Byte *text = p->Text;+ *text++ = p->FoundState->Symbol;+ p->Text = text;+ if (text >= p->UnitsStart)+ {+ Ppmd7_RestartModel(p);+ return;+ }+ maxSuccessor = REF(text);+ }+ + minSuccessor = SUCCESSOR(p->FoundState);++ if (minSuccessor)+ {+ // there is Successor for FoundState in MinContext.+ // So the next context will be one order higher than MinContext.+ + if (minSuccessor <= maxSuccessor)+ {+ // minSuccessor is RAW-Successor. So we will create real contexts records:+ PPMD7_CTX_PTR cs = Ppmd7_CreateSuccessors(p);+ if (!cs)+ {+ Ppmd7_RestartModel(p);+ return;+ }+ minSuccessor = REF(cs);+ }++ // minSuccessor now is real Context pointer that points to existing (Order+1) context+ + if (--p->OrderFall == 0)+ {+ /*+ if we move to MaxOrder context, then minSuccessor will be common Succesor for both:+ MinContext that is (MaxOrder - 1)+ MaxContext that is (MaxOrder)+ so we don't need new RAW-Successor, and we can use real minSuccessor+ as succssors for both MinContext and MaxContext.+ */+ maxSuccessor = minSuccessor;+ + /*+ if (MaxContext != MinContext)+ {+ there was order fall from MaxOrder and we don't need current symbol+ to transfer some RAW-Succesors to real contexts.+ So we roll back pointer in raw data for one position.+ }+ */+ p->Text -= (p->MaxContext != p->MinContext);+ }+ }+ else+ {+ /*+ FoundState has NULL-Successor here.+ And only root 0-order context can contain NULL-Successors.+ We change Successor in FoundState to RAW-Successor,+ And next context will be same 0-order root Context.+ */+ SetSuccessor(p->FoundState, maxSuccessor);+ minSuccessor = REF(p->MinContext);+ }++ mc = p->MinContext;+ c = p->MaxContext;++ p->MaxContext = p->MinContext = CTX(minSuccessor);++ if (c == mc)+ return;++ // s0 : is pure Escape Freq+ s0 = mc->Union2.SummFreq - (ns = mc->NumStats) - ((unsigned)p->FoundState->Freq - 1);++ do+ {+ unsigned ns1;+ UInt32 sum;+ + if ((ns1 = c->NumStats) != 1)+ {+ if ((ns1 & 1) == 0)+ {+ /* Expand for one UNIT */+ unsigned oldNU = ns1 >> 1;+ unsigned i = U2I(oldNU);+ if (i != U2I((size_t)oldNU + 1))+ {+ void *ptr = Ppmd7_AllocUnits(p, i + 1);+ void *oldPtr;+ if (!ptr)+ {+ Ppmd7_RestartModel(p);+ return;+ }+ oldPtr = STATS(c);+ MEM_12_CPY(ptr, oldPtr, oldNU)+ Ppmd7_InsertNode(p, oldPtr, i);+ c->Union4.Stats = STATS_REF(ptr);+ }+ }+ sum = c->Union2.SummFreq;+ /* max increase of Escape_Freq is 3 here.+ total increase of Union2.SummFreq for all symbols is less than 256 here */+ sum += (UInt32)(2 * ns1 < ns) + 2 * ((unsigned)(4 * ns1 <= ns) & (sum <= 8 * ns1));+ /* original PPMdH uses 16-bit variable for (sum) here.+ But (sum < 0x9000). So we don't truncate (sum) to 16-bit */+ // sum = (UInt16)sum;+ }+ else+ {+ // instead of One-symbol context we create 2-symbol context+ CPpmd_State *s = (CPpmd_State*)Ppmd7_AllocUnits(p, 0);+ if (!s)+ {+ Ppmd7_RestartModel(p);+ return;+ }+ {+ unsigned freq = c->Union2.State2.Freq;+ // s = *ONE_STATE(c);+ s->Symbol = c->Union2.State2.Symbol;+ s->Successor_0 = c->Union4.State4.Successor_0;+ s->Successor_1 = c->Union4.State4.Successor_1;+ // SetSuccessor(s, c->Union4.Stats); // call it only for debug purposes to check the order of+ // (Successor_0 and Successor_1) in LE/BE.+ c->Union4.Stats = REF(s);+ if (freq < MAX_FREQ / 4 - 1)+ freq <<= 1;+ else+ freq = MAX_FREQ - 4;+ // (max(s->freq) == 120), when we convert from 1-symbol into 2-symbol context+ s->Freq = (Byte)freq;+ // max(InitEsc = PPMD7_kExpEscape[*]) is 25. So the max(escapeFreq) is 26 here+ sum = freq + p->InitEsc + (ns > 3);+ }+ }+ + {+ CPpmd_State *s = STATS(c) + ns1;+ UInt32 cf = 2 * (sum + 6) * (UInt32)p->FoundState->Freq;+ UInt32 sf = (UInt32)s0 + sum;+ s->Symbol = p->FoundState->Symbol;+ c->NumStats = (UInt16)(ns1 + 1);+ SetSuccessor(s, maxSuccessor);+ + if (cf < 6 * sf)+ {+ cf = (UInt32)1 + (cf > sf) + (cf >= 4 * sf);+ sum += 3;+ /* It can add (0, 1, 2) to Escape_Freq */+ }+ else+ {+ cf = (UInt32)4 + (cf >= 9 * sf) + (cf >= 12 * sf) + (cf >= 15 * sf);+ sum += cf;+ }+ + c->Union2.SummFreq = (UInt16)sum;+ s->Freq = (Byte)cf;+ }+ c = SUFFIX(c);+ }+ while (c != mc);+}+ +++Z7_NO_INLINE+static void Ppmd7_Rescale(CPpmd7 *p)+{+ unsigned i, adder, sumFreq, escFreq;+ CPpmd_State *stats = STATS(p->MinContext);+ CPpmd_State *s = p->FoundState;++ /* Sort the list by Freq */+ if (s != stats)+ {+ CPpmd_State tmp = *s;+ do+ s[0] = s[-1];+ while (--s != stats);+ *s = tmp;+ }++ sumFreq = s->Freq;+ escFreq = p->MinContext->Union2.SummFreq - sumFreq;+ + /*+ if (p->OrderFall == 0), adder = 0 : it's allowed to remove symbol from MAX Order context+ if (p->OrderFall != 0), adder = 1 : it's NOT allowed to remove symbol from NON-MAX Order context+ */++ adder = (p->OrderFall != 0);++ #ifdef PPMD7_ORDER_0_SUPPPORT+ adder |= (p->MaxOrder == 0); // we don't remove symbols from order-0 context+ #endif++ sumFreq = (sumFreq + 4 + adder) >> 1;+ i = (unsigned)p->MinContext->NumStats - 1;+ s->Freq = (Byte)sumFreq;+ + do+ {+ unsigned freq = (++s)->Freq;+ escFreq -= freq;+ freq = (freq + adder) >> 1;+ sumFreq += freq;+ s->Freq = (Byte)freq;+ if (freq > s[-1].Freq)+ {+ CPpmd_State tmp = *s;+ CPpmd_State *s1 = s;+ do+ {+ s1[0] = s1[-1];+ }+ while (--s1 != stats && freq > s1[-1].Freq);+ *s1 = tmp;+ }+ }+ while (--i);+ + if (s->Freq == 0)+ {+ /* Remove all items with Freq == 0 */+ CPpmd7_Context *mc;+ unsigned numStats, numStatsNew, n0, n1;+ + i = 0; do { i++; } while ((--s)->Freq == 0);+ + /* We increase (escFreq) for the number of removed symbols.+ So we will have (0.5) increase for Escape_Freq in avarage per+ removed symbol after Escape_Freq halving */+ escFreq += i;+ mc = p->MinContext;+ numStats = mc->NumStats;+ numStatsNew = numStats - i;+ mc->NumStats = (UInt16)(numStatsNew);+ n0 = (numStats + 1) >> 1;+ + if (numStatsNew == 1)+ {+ /* Create Single-Symbol context */+ unsigned freq = stats->Freq;+ + do+ {+ escFreq >>= 1;+ freq = (freq + 1) >> 1;+ }+ while (escFreq > 1);++ s = ONE_STATE(mc);+ *s = *stats;+ s->Freq = (Byte)freq; // (freq <= 260 / 4)+ p->FoundState = s;+ Ppmd7_InsertNode(p, stats, U2I(n0));+ return;+ }+ + n1 = (numStatsNew + 1) >> 1;+ if (n0 != n1)+ {+ // p->MinContext->Union4.Stats = STATS_REF(ShrinkUnits(p, stats, n0, n1));+ unsigned i0 = U2I(n0);+ unsigned i1 = U2I(n1);+ if (i0 != i1)+ {+ if (p->FreeList[i1] != 0)+ {+ void *ptr = Ppmd7_RemoveNode(p, i1);+ p->MinContext->Union4.Stats = STATS_REF(ptr);+ MEM_12_CPY(ptr, (const void *)stats, n1)+ Ppmd7_InsertNode(p, stats, i0);+ }+ else+ Ppmd7_SplitBlock(p, stats, i0, i1);+ }+ }+ }+ {+ CPpmd7_Context *mc = p->MinContext;+ mc->Union2.SummFreq = (UInt16)(sumFreq + escFreq - (escFreq >> 1));+ // Escape_Freq halving here+ p->FoundState = STATS(mc);+ }+}+++CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *escFreq)+{+ CPpmd_See *see;+ const CPpmd7_Context *mc = p->MinContext;+ unsigned numStats = mc->NumStats;+ if (numStats != 256)+ {+ unsigned nonMasked = numStats - numMasked;+ see = p->See[(unsigned)p->NS2Indx[(size_t)nonMasked - 1]]+ + (nonMasked < (unsigned)SUFFIX(mc)->NumStats - numStats)+ + 2 * (unsigned)(mc->Union2.SummFreq < 11 * numStats)+ + 4 * (unsigned)(numMasked > nonMasked) ++ p->HiBitsFlag;+ {+ // if (see->Summ) field is larger than 16-bit, we need only low 16 bits of Summ+ unsigned summ = (UInt16)see->Summ; // & 0xFFFF+ unsigned r = (summ >> see->Shift);+ see->Summ = (UInt16)(summ - r);+ *escFreq = r + (r == 0);+ }+ }+ else+ {+ see = &p->DummySee;+ *escFreq = 1;+ }+ return see;+}+++static void Ppmd7_NextContext(CPpmd7 *p)+{+ PPMD7_CTX_PTR c = CTX(SUCCESSOR(p->FoundState));+ if (p->OrderFall == 0 && (const Byte *)c > p->Text)+ p->MaxContext = p->MinContext = c;+ else+ Ppmd7_UpdateModel(p);+}+++void Ppmd7_Update1(CPpmd7 *p)+{+ CPpmd_State *s = p->FoundState;+ unsigned freq = s->Freq;+ freq += 4;+ p->MinContext->Union2.SummFreq = (UInt16)(p->MinContext->Union2.SummFreq + 4);+ s->Freq = (Byte)freq;+ if (freq > s[-1].Freq)+ {+ SWAP_STATES(s)+ p->FoundState = --s;+ if (freq > MAX_FREQ)+ Ppmd7_Rescale(p);+ }+ Ppmd7_NextContext(p);+}+++void Ppmd7_Update1_0(CPpmd7 *p)+{+ CPpmd_State *s = p->FoundState;+ CPpmd7_Context *mc = p->MinContext;+ unsigned freq = s->Freq;+ unsigned summFreq = mc->Union2.SummFreq;+ p->PrevSuccess = (2 * freq > summFreq);+ p->RunLength += (int)p->PrevSuccess;+ mc->Union2.SummFreq = (UInt16)(summFreq + 4);+ freq += 4;+ s->Freq = (Byte)freq;+ if (freq > MAX_FREQ)+ Ppmd7_Rescale(p);+ Ppmd7_NextContext(p);+}+++/*+void Ppmd7_UpdateBin(CPpmd7 *p)+{+ unsigned freq = p->FoundState->Freq;+ p->FoundState->Freq = (Byte)(freq + (freq < 128));+ p->PrevSuccess = 1;+ p->RunLength++;+ Ppmd7_NextContext(p);+}+*/++void Ppmd7_Update2(CPpmd7 *p)+{+ CPpmd_State *s = p->FoundState;+ unsigned freq = s->Freq;+ freq += 4;+ p->RunLength = p->InitRL;+ p->MinContext->Union2.SummFreq = (UInt16)(p->MinContext->Union2.SummFreq + 4);+ s->Freq = (Byte)freq;+ if (freq > MAX_FREQ)+ Ppmd7_Rescale(p);+ Ppmd7_UpdateModel(p);+}++++/*+PPMd Memory Map:+{+ [ 0 ] contains subset of original raw text, that is required to create context+ records, Some symbols are not written, when max order context was reached+ [ Text ] free area+ [ UnitsStart ] CPpmd_State vectors and CPpmd7_Context records+ [ LoUnit ] free area for CPpmd_State and CPpmd7_Context items+[ HiUnit ] CPpmd7_Context records+ [ Size ] end of array+}++These addresses don't cross at any time.+And the following condtions is true for addresses:+ (0 <= Text < UnitsStart <= LoUnit <= HiUnit <= Size)++Raw text is BYTE--aligned.+the data in block [ UnitsStart ... Size ] contains 12-bytes aligned UNITs.++Last UNIT of array at offset (Size - 12) is root order-0 CPpmd7_Context record.+The code can free UNITs memory blocks that were allocated to store CPpmd_State vectors.+The code doesn't free UNITs allocated for CPpmd7_Context records.++The code calls Ppmd7_RestartModel(), when there is no free memory for allocation.+And Ppmd7_RestartModel() changes the state to orignal start state, with full free block.+++The code allocates UNITs with the following order:++Allocation of 1 UNIT for Context record+ - from free space (HiUnit) down to (LoUnit)+ - from FreeList[0]+ - Ppmd7_AllocUnitsRare()++Ppmd7_AllocUnits() for CPpmd_State vectors:+ - from FreeList[i]+ - from free space (LoUnit) up to (HiUnit)+ - Ppmd7_AllocUnitsRare()++Ppmd7_AllocUnitsRare()+ - if (GlueCount == 0)+ { Glue lists, GlueCount = 255, allocate from FreeList[i]] }+ - loop for all higher sized FreeList[...] lists+ - from (UnitsStart - Text), GlueCount--+ - ERROR+++Each Record with Context contains the CPpmd_State vector, where each+CPpmd_State contains the link to Successor.+There are 3 types of Successor:+ 1) NULL-Successor - NULL pointer. NULL-Successor links can be stored+ only in 0-order Root Context Record.+ We use 0 value as NULL-Successor+ 2) RAW-Successor - the link to position in raw text,+ that "RAW-Successor" is being created after first+ occurrence of new symbol for some existing context record.+ (RAW-Successor > 0).+ 3) RECORD-Successor - the link to CPpmd7_Context record of (Order+1),+ that record is being created when we go via RAW-Successor again.++For any successors at any time: the following condtions are true for Successor links:+(NULL-Successor < RAW-Successor < UnitsStart <= RECORD-Successor)+++---------- Symbol Frequency, SummFreq and Range in Range_Coder ----------++CPpmd7_Context::SummFreq = Sum(Stats[].Freq) + Escape_Freq++The PPMd code tries to fulfill the condition:+ (SummFreq <= (256 * 128 = RC::kBot))++We have (Sum(Stats[].Freq) <= 256 * 124), because of (MAX_FREQ = 124)+So (4 = 128 - 124) is average reserve for Escape_Freq for each symbol.+If (CPpmd_State::Freq) is not aligned for 4, the reserve can be 5, 6 or 7.+SummFreq and Escape_Freq can be changed in Ppmd7_Rescale() and *Update*() functions.+Ppmd7_Rescale() can remove symbols only from max-order contexts. So Escape_Freq can increase after multiple calls of Ppmd7_Rescale() for+max-order context.++When the PPMd code still break (Total <= RC::Range) condition in range coder,+we have two ways to resolve that problem:+ 1) we can report error, if we want to keep compatibility with original PPMd code that has no fix for such cases.+ 2) we can reduce (Total) value to (RC::Range) by reducing (Escape_Freq) part of (Total) value.+*/++#undef MAX_FREQ+#undef UNIT_SIZE+#undef U2B+#undef U2I+#undef I2U+#undef I2U_UInt16+#undef REF+#undef STATS_REF+#undef CTX+#undef STATS+#undef ONE_STATE+#undef SUFFIX+#undef NODE+#undef EMPTY_NODE+#undef MEM_12_CPY+#undef SUCCESSOR+#undef SWAP_STATES
@@ -0,0 +1,181 @@+/* Ppmd7.h -- Ppmd7 (PPMdH) compression codec+2023-04-02 : Igor Pavlov : Public domain+This code is based on:+ PPMd var.H (2001): Dmitry Shkarin : Public domain */+ ++#ifndef ZIP7_INC_PPMD7_H+#define ZIP7_INC_PPMD7_H++#include "Ppmd.h"++EXTERN_C_BEGIN++#define PPMD7_MIN_ORDER 2+#define PPMD7_MAX_ORDER 64++#define PPMD7_MIN_MEM_SIZE (1 << 11)+#define PPMD7_MAX_MEM_SIZE (0xFFFFFFFF - 12 * 3)++struct CPpmd7_Context_;++typedef Ppmd_Ref_Type(struct CPpmd7_Context_) CPpmd7_Context_Ref;++// MY_CPU_pragma_pack_push_1++typedef struct CPpmd7_Context_+{+ UInt16 NumStats;+++ union+ {+ UInt16 SummFreq;+ CPpmd_State2 State2;+ } Union2;++ union+ {+ CPpmd_State_Ref Stats;+ CPpmd_State4 State4;+ } Union4;++ CPpmd7_Context_Ref Suffix;+} CPpmd7_Context;++// MY_CPU_pragma_pop++#define Ppmd7Context_OneState(p) ((CPpmd_State *)&(p)->Union2)+++++typedef struct+{+ UInt32 Range;+ UInt32 Code;+ UInt32 Low;+ IByteInPtr Stream;+} CPpmd7_RangeDec;+++typedef struct+{+ UInt32 Range;+ Byte Cache;+ // Byte _dummy_[3];+ UInt64 Low;+ UInt64 CacheSize;+ IByteOutPtr Stream;+} CPpmd7z_RangeEnc;+++typedef struct+{+ CPpmd7_Context *MinContext, *MaxContext;+ CPpmd_State *FoundState;+ unsigned OrderFall, InitEsc, PrevSuccess, MaxOrder, HiBitsFlag;+ Int32 RunLength, InitRL; /* must be 32-bit at least */++ UInt32 Size;+ UInt32 GlueCount;+ UInt32 AlignOffset;+ Byte *Base, *LoUnit, *HiUnit, *Text, *UnitsStart;+++ + + union+ {+ CPpmd7_RangeDec dec;+ CPpmd7z_RangeEnc enc;+ } rc;+ + Byte Indx2Units[PPMD_NUM_INDEXES + 2]; // +2 for alignment+ Byte Units2Indx[128];+ CPpmd_Void_Ref FreeList[PPMD_NUM_INDEXES];++ Byte NS2BSIndx[256], NS2Indx[256];+ Byte ExpEscape[16];+ CPpmd_See DummySee, See[25][16];+ UInt16 BinSumm[128][64];+ // int LastSymbol;+} CPpmd7;+++void Ppmd7_Construct(CPpmd7 *p);+BoolInt Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAllocPtr alloc);+void Ppmd7_Free(CPpmd7 *p, ISzAllocPtr alloc);+void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder);+#define Ppmd7_WasAllocated(p) ((p)->Base != NULL)+++/* ---------- Internal Functions ---------- */++#define Ppmd7_GetPtr(p, ptr) Ppmd_GetPtr(p, ptr)+#define Ppmd7_GetContext(p, ptr) Ppmd_GetPtr_Type(p, ptr, CPpmd7_Context)+#define Ppmd7_GetStats(p, ctx) Ppmd_GetPtr_Type(p, (ctx)->Union4.Stats, CPpmd_State)++void Ppmd7_Update1(CPpmd7 *p);+void Ppmd7_Update1_0(CPpmd7 *p);+void Ppmd7_Update2(CPpmd7 *p);++#define PPMD7_HiBitsFlag_3(sym) ((((unsigned)sym + 0xC0) >> (8 - 3)) & (1 << 3))+#define PPMD7_HiBitsFlag_4(sym) ((((unsigned)sym + 0xC0) >> (8 - 4)) & (1 << 4))+// #define PPMD7_HiBitsFlag_3(sym) ((sym) < 0x40 ? 0 : (1 << 3))+// #define PPMD7_HiBitsFlag_4(sym) ((sym) < 0x40 ? 0 : (1 << 4))++#define Ppmd7_GetBinSumm(p) \+ &p->BinSumm[(size_t)(unsigned)Ppmd7Context_OneState(p->MinContext)->Freq - 1] \+ [ p->PrevSuccess + ((p->RunLength >> 26) & 0x20) \+ + p->NS2BSIndx[(size_t)Ppmd7_GetContext(p, p->MinContext->Suffix)->NumStats - 1] \+ + PPMD7_HiBitsFlag_4(Ppmd7Context_OneState(p->MinContext)->Symbol) \+ + (p->HiBitsFlag = PPMD7_HiBitsFlag_3(p->FoundState->Symbol)) ]++CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *scale);+++/*+We support two versions of Ppmd7 (PPMdH) methods that use same CPpmd7 structure:+ 1) Ppmd7a_*: original PPMdH+ 2) Ppmd7z_*: modified PPMdH with 7z Range Coder+Ppmd7_*: the structures and functions that are common for both versions of PPMd7 (PPMdH)+*/++/* ---------- Decode ---------- */++#define PPMD7_SYM_END (-1)+#define PPMD7_SYM_ERROR (-2)++/*+You must set (CPpmd7::rc.dec.Stream) before Ppmd7*_RangeDec_Init()++Ppmd7*_DecodeSymbol()+out:+ >= 0 : decoded byte+ -1 : PPMD7_SYM_END : End of payload marker+ -2 : PPMD7_SYM_ERROR : Data error+*/++/* Ppmd7a_* : original PPMdH */+BoolInt Ppmd7a_RangeDec_Init(CPpmd7_RangeDec *p);+#define Ppmd7a_RangeDec_IsFinishedOK(p) ((p)->Code == 0)+int Ppmd7a_DecodeSymbol(CPpmd7 *p);++/* Ppmd7z_* : modified PPMdH with 7z Range Coder */+BoolInt Ppmd7z_RangeDec_Init(CPpmd7_RangeDec *p);+#define Ppmd7z_RangeDec_IsFinishedOK(p) ((p)->Code == 0)+int Ppmd7z_DecodeSymbol(CPpmd7 *p);+// Byte *Ppmd7z_DecodeSymbols(CPpmd7 *p, Byte *buf, const Byte *lim);+++/* ---------- Encode ---------- */++void Ppmd7z_Init_RangeEnc(CPpmd7 *p);+void Ppmd7z_Flush_RangeEnc(CPpmd7 *p);+// void Ppmd7z_EncodeSymbol(CPpmd7 *p, int symbol);+void Ppmd7z_EncodeSymbols(CPpmd7 *p, const Byte *buf, const Byte *lim);++EXTERN_C_END+ +#endif
@@ -0,0 +1,312 @@+/* Ppmd7Dec.c -- Ppmd7z (PPMdH with 7z Range Coder) Decoder+2023-04-02 : Igor Pavlov : Public domain+This code is based on:+ PPMd var.H (2001): Dmitry Shkarin : Public domain */+++#include "Precomp.h"++#include "Ppmd7.h"++#define kTopValue ((UInt32)1 << 24)+++#define READ_BYTE(p) IByteIn_Read((p)->Stream)++BoolInt Ppmd7z_RangeDec_Init(CPpmd7_RangeDec *p)+{+ unsigned i;+ p->Code = 0;+ p->Range = 0xFFFFFFFF;+ if (READ_BYTE(p) != 0)+ return False;+ for (i = 0; i < 4; i++)+ p->Code = (p->Code << 8) | READ_BYTE(p);+ return (p->Code < 0xFFFFFFFF);+}++#define RC_NORM_BASE(p) if ((p)->Range < kTopValue) \+ { (p)->Code = ((p)->Code << 8) | READ_BYTE(p); (p)->Range <<= 8;++#define RC_NORM_1(p) RC_NORM_BASE(p) }+#define RC_NORM(p) RC_NORM_BASE(p) RC_NORM_BASE(p) }}++// we must use only one type of Normalization from two: LOCAL or REMOTE+#define RC_NORM_LOCAL(p) // RC_NORM(p)+#define RC_NORM_REMOTE(p) RC_NORM(p)++#define R (&p->rc.dec)++Z7_FORCE_INLINE+// Z7_NO_INLINE+static void Ppmd7z_RD_Decode(CPpmd7 *p, UInt32 start, UInt32 size)+{++ + R->Code -= start * R->Range;+ R->Range *= size;+ RC_NORM_LOCAL(R)+}++#define RC_Decode(start, size) Ppmd7z_RD_Decode(p, start, size);+#define RC_DecodeFinal(start, size) RC_Decode(start, size) RC_NORM_REMOTE(R)+#define RC_GetThreshold(total) (R->Code / (R->Range /= (total)))+++#define CTX(ref) ((CPpmd7_Context *)Ppmd7_GetContext(p, ref))+// typedef CPpmd7_Context * CTX_PTR;+#define SUCCESSOR(p) Ppmd_GET_SUCCESSOR(p)+void Ppmd7_UpdateModel(CPpmd7 *p);++#define MASK(sym) ((unsigned char *)charMask)[sym]+// Z7_FORCE_INLINE+// static+int Ppmd7z_DecodeSymbol(CPpmd7 *p)+{+ size_t charMask[256 / sizeof(size_t)];++ if (p->MinContext->NumStats != 1)+ {+ CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);+ unsigned i;+ UInt32 count, hiCnt;+ const UInt32 summFreq = p->MinContext->Union2.SummFreq;++ + + + count = RC_GetThreshold(summFreq);+ hiCnt = count;+ + if ((Int32)(count -= s->Freq) < 0)+ {+ Byte sym;+ RC_DecodeFinal(0, s->Freq)+ p->FoundState = s;+ sym = s->Symbol;+ Ppmd7_Update1_0(p);+ return sym;+ }+ + p->PrevSuccess = 0;+ i = (unsigned)p->MinContext->NumStats - 1;+ + do+ {+ if ((Int32)(count -= (++s)->Freq) < 0)+ {+ Byte sym;+ RC_DecodeFinal((hiCnt - count) - s->Freq, s->Freq)+ p->FoundState = s;+ sym = s->Symbol;+ Ppmd7_Update1(p);+ return sym;+ }+ }+ while (--i);+ + if (hiCnt >= summFreq)+ return PPMD7_SYM_ERROR;+ + hiCnt -= count;+ RC_Decode(hiCnt, summFreq - hiCnt)++ p->HiBitsFlag = PPMD7_HiBitsFlag_3(p->FoundState->Symbol);+ PPMD_SetAllBitsIn256Bytes(charMask)+ // i = p->MinContext->NumStats - 1;+ // do { MASK((--s)->Symbol) = 0; } while (--i);+ {+ CPpmd_State *s2 = Ppmd7_GetStats(p, p->MinContext);+ MASK(s->Symbol) = 0;+ do+ {+ unsigned sym0 = s2[0].Symbol;+ unsigned sym1 = s2[1].Symbol;+ s2 += 2;+ MASK(sym0) = 0;+ MASK(sym1) = 0;+ }+ while (s2 < s);+ }+ }+ else+ {+ CPpmd_State *s = Ppmd7Context_OneState(p->MinContext);+ UInt16 *prob = Ppmd7_GetBinSumm(p);+ UInt32 pr = *prob;+ UInt32 size0 = (R->Range >> 14) * pr;+ pr = PPMD_UPDATE_PROB_1(pr);++ if (R->Code < size0)+ {+ Byte sym;+ *prob = (UInt16)(pr + (1 << PPMD_INT_BITS));+ + // RangeDec_DecodeBit0(size0);+ R->Range = size0;+ RC_NORM_1(R)+ /* we can use single byte normalization here because of+ (min(BinSumm[][]) = 95) > (1 << (14 - 8)) */++ // sym = (p->FoundState = Ppmd7Context_OneState(p->MinContext))->Symbol;+ // Ppmd7_UpdateBin(p);+ {+ unsigned freq = s->Freq;+ CPpmd7_Context *c = CTX(SUCCESSOR(s));+ sym = s->Symbol;+ p->FoundState = s;+ p->PrevSuccess = 1;+ p->RunLength++;+ s->Freq = (Byte)(freq + (freq < 128));+ // NextContext(p);+ if (p->OrderFall == 0 && (const Byte *)c > p->Text)+ p->MaxContext = p->MinContext = c;+ else+ Ppmd7_UpdateModel(p);+ }+ return sym;+ }++ *prob = (UInt16)pr;+ p->InitEsc = p->ExpEscape[pr >> 10];++ // RangeDec_DecodeBit1(size0);+ + R->Code -= size0;+ R->Range -= size0;+ RC_NORM_LOCAL(R)+ + PPMD_SetAllBitsIn256Bytes(charMask)+ MASK(Ppmd7Context_OneState(p->MinContext)->Symbol) = 0;+ p->PrevSuccess = 0;+ }++ for (;;)+ {+ CPpmd_State *s, *s2;+ UInt32 freqSum, count, hiCnt;++ CPpmd_See *see;+ CPpmd7_Context *mc;+ unsigned numMasked;+ RC_NORM_REMOTE(R)+ mc = p->MinContext;+ numMasked = mc->NumStats;++ do+ {+ p->OrderFall++;+ if (!mc->Suffix)+ return PPMD7_SYM_END;+ mc = Ppmd7_GetContext(p, mc->Suffix);+ }+ while (mc->NumStats == numMasked);+ + s = Ppmd7_GetStats(p, mc);++ {+ unsigned num = mc->NumStats;+ unsigned num2 = num / 2;+ + num &= 1;+ hiCnt = (s->Freq & (unsigned)(MASK(s->Symbol))) & (0 - (UInt32)num);+ s += num;+ p->MinContext = mc;++ do+ {+ unsigned sym0 = s[0].Symbol;+ unsigned sym1 = s[1].Symbol;+ s += 2;+ hiCnt += (s[-2].Freq & (unsigned)(MASK(sym0)));+ hiCnt += (s[-1].Freq & (unsigned)(MASK(sym1)));+ }+ while (--num2);+ }++ see = Ppmd7_MakeEscFreq(p, numMasked, &freqSum);+ freqSum += hiCnt;+++++ count = RC_GetThreshold(freqSum);+ + if (count < hiCnt)+ {+ Byte sym;++ s = Ppmd7_GetStats(p, p->MinContext);+ hiCnt = count;+ // count -= s->Freq & (unsigned)(MASK(s->Symbol));+ // if ((Int32)count >= 0)+ {+ for (;;)+ {+ count -= s->Freq & (unsigned)(MASK((s)->Symbol)); s++; if ((Int32)count < 0) break;+ // count -= s->Freq & (unsigned)(MASK((s)->Symbol)); s++; if ((Int32)count < 0) break;+ }+ }+ s--;+ RC_DecodeFinal((hiCnt - count) - s->Freq, s->Freq)++ // new (see->Summ) value can overflow over 16-bits in some rare cases+ Ppmd_See_UPDATE(see)+ p->FoundState = s;+ sym = s->Symbol;+ Ppmd7_Update2(p);+ return sym;+ }++ if (count >= freqSum)+ return PPMD7_SYM_ERROR;+ + RC_Decode(hiCnt, freqSum - hiCnt)++ // We increase (see->Summ) for sum of Freqs of all non_Masked symbols.+ // new (see->Summ) value can overflow over 16-bits in some rare cases+ see->Summ = (UInt16)(see->Summ + freqSum);++ s = Ppmd7_GetStats(p, p->MinContext);+ s2 = s + p->MinContext->NumStats;+ do+ {+ MASK(s->Symbol) = 0;+ s++;+ }+ while (s != s2);+ }+}++/*+Byte *Ppmd7z_DecodeSymbols(CPpmd7 *p, Byte *buf, const Byte *lim)+{+ int sym = 0;+ if (buf != lim)+ do+ {+ sym = Ppmd7z_DecodeSymbol(p);+ if (sym < 0)+ break;+ *buf = (Byte)sym;+ }+ while (++buf < lim);+ p->LastSymbol = sym;+ return buf;+}+*/++#undef kTopValue+#undef READ_BYTE+#undef RC_NORM_BASE+#undef RC_NORM_1+#undef RC_NORM+#undef RC_NORM_LOCAL+#undef RC_NORM_REMOTE+#undef R+#undef RC_Decode+#undef RC_DecodeFinal+#undef RC_GetThreshold+#undef CTX+#undef SUCCESSOR+#undef MASK
@@ -0,0 +1,10 @@+/* Precomp.h -- StdAfx+2023-04-02 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_PRECOMP_H+#define ZIP7_INC_PRECOMP_H++#include "Compiler.h"+/* #include "7zTypes.h" */++#endif
@@ -0,0 +1,30 @@+This directory contains a subset of the LZMA SDK lzma2301/C files++LZMA SDK is available from https://7-zip.org/sdk.html++LZMA SDK is placed in the public domain.++LZMA SDK by Igor Pavlov.++Included in this directory is a new C API to simplify decompression:++- viizip.h declarations, see below (hides implementation details)+- viizip.c implementation+- libviiz.a static library compiled from source++The 7zip decompressor state with hidden members:+struct viizip++To create a new 7zip decompressor for the given 7zip file:+struct viizip *viinew(FILE *file)++To free viizip decompressor state:+void viifree(struct viizip *viizip)++To get archive part pathname and info, start decompressing:+int viiget(struct viizip *viizip, char *name, size_t max, time_t *mtime, uint64_t *usize)++To decompress up to len bytes into buf[], return number of bytes decompressed:+ssize_t viidec(struct viizip *viizip, unsigned char *buf, size_t len)++The viizip files are part of the ugrep project licensed BSD-3.
@@ -0,0 +1,50 @@+/* RotateDefs.h -- Rotate functions+2023-06-18 : Igor Pavlov : Public domain */++#ifndef ZIP7_INC_ROTATE_DEFS_H+#define ZIP7_INC_ROTATE_DEFS_H++#ifdef _MSC_VER++#include <stdlib.h>++/* don't use _rotl with old MINGW. It can insert slow call to function. */+ +/* #if (_MSC_VER >= 1200) */+#pragma intrinsic(_rotl)+#pragma intrinsic(_rotr)+/* #endif */++#define rotlFixed(x, n) _rotl((x), (n))+#define rotrFixed(x, n) _rotr((x), (n))++#if (_MSC_VER >= 1300)+#define Z7_ROTL64(x, n) _rotl64((x), (n))+#define Z7_ROTR64(x, n) _rotr64((x), (n))+#else+#define Z7_ROTL64(x, n) (((x) << (n)) | ((x) >> (64 - (n))))+#define Z7_ROTR64(x, n) (((x) >> (n)) | ((x) << (64 - (n))))+#endif++#else++/* new compilers can translate these macros to fast commands. */++#if defined(__clang__) && (__clang_major__ >= 4) \+ || defined(__GNUC__) && (__GNUC__ >= 5)+/* GCC 4.9.0 and clang 3.5 can recognize more correct version: */+#define rotlFixed(x, n) (((x) << (n)) | ((x) >> (-(n) & 31)))+#define rotrFixed(x, n) (((x) >> (n)) | ((x) << (-(n) & 31)))+#define Z7_ROTL64(x, n) (((x) << (n)) | ((x) >> (-(n) & 63)))+#define Z7_ROTR64(x, n) (((x) >> (n)) | ((x) << (-(n) & 63)))+#else+/* for old GCC / clang: */+#define rotlFixed(x, n) (((x) << (n)) | ((x) >> (32 - (n))))+#define rotrFixed(x, n) (((x) >> (n)) | ((x) << (32 - (n))))+#define Z7_ROTL64(x, n) (((x) << (n)) | ((x) >> (64 - (n))))+#define Z7_ROTR64(x, n) (((x) >> (n)) | ((x) << (64 - (n))))+#endif++#endif++#endif
@@ -0,0 +1,381 @@+/******************************************************************************\+* Copyright (c) 2023, Robert van Engelen, Genivia Inc. All rights reserved. *+* *+* Redistribution and use in source and binary forms, with or without *+* modification, are permitted provided that the following conditions are met: *+* *+* (1) Redistributions of source code must retain the above copyright notice, *+* this list of conditions and the following disclaimer. *+* *+* (2) Redistributions in binary form must reproduce the above copyright *+* notice, this list of conditions and the following disclaimer in the *+* documentation and/or other materials provided with the distribution. *+* *+* (3) The name of the author may not be used to endorse or promote products *+* derived from this software without specific prior written permission. *+* *+* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED *+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO *+* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, *+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *+* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, *+* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR *+* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF *+* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *+\******************************************************************************/++/**+@file viizip.c+@brief 7zip archive decompressor based on lzma/C/Util/7z/7zMain.c+@author Robert van Engelen - engelen@genivia.com+@copyright (c) 2023-2023, Robert van Engelen, Genivia Inc. All rights reserved.+@copyright (c) BSD-3 License - see LICENSE.txt+*/++#include "viizip.h"+#include <stdlib.h>+#include <string.h>++#include "7z.h"+#include "7zAlloc.h"+#include "7zCrc.h"+#include "7zFile.h"++#ifdef OS_WIN+#include <io.h>+#endif++#define PERIOD_4 (4 * 365 + 1)+#define PERIOD_100 (PERIOD_4 * 25 - 1)+#define PERIOD_400 (PERIOD_100 * 4 + 1)++#ifdef __cplusplus+extern "C" {+#endif++enum viistate { DOGET, DOEXT, ISDIR };++/* 7zip decompressor state */+struct viizip {+ ISzAlloc alloc_main;+ ISzAlloc alloc_temp;+ CFileInStream stream;+ CLookToRead2 look;+ CSzArEx db;+ UInt32 index;+ UInt32 block;+ Byte *buf;+ size_t buflen;+ UInt16 *tmp;+ size_t tmplen;+ size_t loc;+ size_t len;+ enum viistate state;+};++/* convert UTF-16 string to UTF-8 string buffer utf8[] of max size */+static size_t utf16_to_utf8(const UInt16 *utf16, char *utf8, size_t max)+{+ char *ptr = utf8;+ UInt32 c;++ if (max == 0)+ return 0;++ while ((c = *utf16++) != 0 && --max != 0)+ {+ if (c >= 0xD800 && c < 0xDC00 && *utf16 >= 0xDC00)+ c = 0x010000 - 0xDC00 + ((c - 0xD800) << 10) + *utf16++;++ if (c < 0x80)+ {+ *ptr++ = (char)c;+ }+ else+ {+ if (c < 0x0800)+ {+ *ptr++ = (char)(0xC0 | ((c >> 6) & 0x1F));+ }+ else+ {+ if (c < 0x010000)+ {+ *ptr++ = (char)(0xE0 | ((c >> 12) & 0x0F));+ }+ else+ {+ *ptr++ = (char)(0xF0 | ((c >> 18) & 0x07));++ if (--max == 0)+ break;++ *ptr++ = (char)(0x80 | ((c >> 12) & 0x3F));+ }++ if (--max == 0)+ break;++ *ptr++ = (char)(0x80 | ((c >> 6) & 0x3F));+ }++ if (--max == 0)+ break;++ *ptr++ = (char)(0x80 | (c & 0x3F));+ }+ }++ *ptr = '\0';++ return ptr - utf8;+}++/* convert (low,high) 7zip time to time_t, based on 7zMain.c but using mktime() */+static time_t convert_time(const CNtfsFileTime *nTime)+{+ int year, mon;+ Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };+ unsigned t;+ UInt32 v;+ UInt64 v64 = nTime->Low + ((UInt64)nTime->High << 32);+ struct tm tm;++ memset(&tm, 0, sizeof(struct tm));+ v64 /= 10000000;+ tm.tm_sec = (unsigned)(v64 % 60);+ v64 /= 60;+ tm.tm_min = (unsigned)(v64 % 60);+ v64 /= 60;+ tm.tm_hour = (unsigned)(v64 % 24);+ v64 /= 24;++ v = (UInt32)v64;++ year = (unsigned)(1601 + v / PERIOD_400 * 400);+ v %= PERIOD_400;++ t = v / PERIOD_100;+ if (t == 4)+ t = 3;+ year += t * 100;+ v -= t * PERIOD_100;++ t = v / PERIOD_4;+ if (t == 25)+ t = 24;+ year += t * 4;+ v -= t * PERIOD_4;++ t = v / 365;+ if (t == 4)+ t = 3;+ year += t;+ v -= t * 365;++ if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))+ ms[1] = 29;++ for (mon = 0;; ++mon)+ {+ unsigned d = ms[mon];+ if (v < d)+ break;+ v -= d;+ }++ tm.tm_year = year - 1900;+ tm.tm_mon = mon;+ tm.tm_mday = v + 1;+ tm.tm_isdst = -1;++ return mktime(&tm);+}++/* create new 7zip decompressor for the given 7zip file, returns decompressor state or NULL on failure */+struct viizip *viinew(FILE *file)+{+ static const size_t INPUTBUFSIZE = (size_t)1 << 18;+ static const ISzAlloc g_Alloc = { SzAlloc, SzFree };+ static volatile int init_done = 0;+ struct viizip *viizip = (struct viizip*)malloc(sizeof(struct viizip));+ if (viizip == NULL)+ return NULL;++ /* CrcGenerateTable() appears MT safe to compute g_CrcTable[], but we shouldn't init every time we get here */+ if (!init_done)+ {+ /* initialize global CRC table */+ CrcGenerateTable();+ init_done = 1;+ }++ viizip->alloc_main = g_Alloc;+ viizip->alloc_temp = g_Alloc;+ viizip->index = 0;+ viizip->block = 0xFFFFFFFF;+ viizip->buf = NULL;+ viizip->buflen = 0;+ viizip->tmp = NULL;+ viizip->tmplen = 0;+#ifdef OS_WIN+ viizip->stream.file.handle = (HANDLE)_get_osfhandle(_fileno(file));+#else+ viizip->stream.file.fd = fileno(file);+#endif+ SzArEx_Init(&viizip->db);+ FileInStream_CreateVTable(&viizip->stream);+ viizip->stream.wres = 0;+ LookToRead2_CreateVTable(&viizip->look, 0);+ viizip->look.buf = (Byte*)ISzAlloc_Alloc(&viizip->alloc_main, INPUTBUFSIZE);+ if (viizip->look.buf != NULL)+ {+ viizip->look.bufSize = INPUTBUFSIZE;+ viizip->look.realStream = &viizip->stream.vt;+ LookToRead2_INIT(&viizip->look);+ if (SzArEx_Open(&viizip->db, &viizip->look.vt, &viizip->alloc_main, &viizip->alloc_temp) == SZ_OK)+ return viizip;+ }++ /* failed to create decompressor */+ viifree(viizip);+ return NULL;+}++/* free viizip decompressor state */+void viifree(struct viizip *viizip)+{+ if (viizip == NULL)+ return;++ ISzAlloc_Free(&viizip->alloc_main, viizip->buf);+ SzFree(NULL, viizip->tmp);+ SzArEx_Free(&viizip->db, &viizip->alloc_main);+ free(viizip);+}++/* get number of archived files and directories */+size_t viinum(struct viizip *viizip)+{+ return viizip != NULL ? viizip->db.NumFiles : 0;+}++/* get archive part pathname and info, start decompressing, return 0 if success, 1 when end reached, -1 on error */+int viiget(struct viizip *viizip, char *name, size_t max, time_t *mtime, uint64_t *usize)+{+ SRes res = SZ_OK;++ if (viizip == NULL)+ return -1;++ /* if no more archive parts to decompress, return 1 */+ if (viizip->index >= viizip->db.NumFiles)+ return 1;++ /* check if directory */+ viizip->state = SzArEx_IsDir(&viizip->db, viizip->index) ? ISDIR : DOGET;++ /* populate name[] buffer up to max with the archive part name, make directories end with a / */+ if (name != NULL && max > 1)+ {+ size_t len = SzArEx_GetFileNameUtf16(&viizip->db, viizip->index, NULL);+ if (len > viizip->tmplen)+ {+ SzFree(NULL, viizip->tmp);+ viizip->tmplen = ((len + 0xFFUL) & ~0xFFUL); /* round up to multiple of 256 */+ viizip->tmp = (UInt16*)SzAlloc(NULL, viizip->tmplen * sizeof(UInt16));+ if (viizip->tmp == NULL)+ return -1;+ }+ SzArEx_GetFileNameUtf16(&viizip->db, viizip->index, viizip->tmp);+ len = utf16_to_utf8(viizip->tmp, name, max);++ if (viizip->state == ISDIR)+ {+ if (len + 1 >= max)+ len = max - 2;+ name[len] = '/';+ name[len + 1] = '\0';+ }+ }++ viizip->loc = 0;+ viizip->len = 0;++ /* populate modification/creation time */+ if (mtime != NULL)+ {+ if (SzBitWithVals_Check(&viizip->db.MTime, viizip->index))+ {+ const CNtfsFileTime *t = &viizip->db.MTime.Vals[viizip->index];+ *mtime = convert_time(t);+ }+ else if (SzBitWithVals_Check(&viizip->db.CTime, viizip->index))+ {+ const CNtfsFileTime *t = &viizip->db.CTime.Vals[viizip->index];+ *mtime = convert_time(t);+ }+ else+ {+ *mtime = 0;+ }+ }++ /* get uncompressed file size */+ if (usize != NULL)+ *usize = viizip->state == DOGET ? SzArEx_GetFileSize(&viizip->db, viizip->index) : 0;++ /* next archive part */+ ++viizip->index;++ return res == SZ_OK ? 0 : -1;+}++/* decompress up to len bytes into buf[], return number of bytes decompressed */+ssize_t viidec(struct viizip *viizip, unsigned char *buf, size_t len)+{+ if (viizip == NULL)+ return -1;++ switch (viizip->state)+ {+ case ISDIR:+ return 0;++ case DOGET:+ /* 7zip decompresses the whole file in memory instead of allowing us to incrementally get blocks */+ /* i.e. huge memory overhead to extract large files, no pipelining advantage, no quick stop half way */+ if (SzArEx_Extract(+ &viizip->db,+ &viizip->look.vt,+ viizip->index - 1, /* viiget() increased index by one */+ &viizip->block,+ &viizip->buf,+ &viizip->buflen,+ &viizip->loc,+ &viizip->len,+ &viizip->alloc_main,+ &viizip->alloc_temp) != SZ_OK)+ return -1;+ viizip->state = DOEXT;+ break;++ case DOEXT:+ break;+ }++ if (viizip->len < len)+ len = viizip->len;++ memcpy(buf, viizip->buf + viizip->loc, len);+ viizip->loc += len;+ viizip->len -= len;++ return (ssize_t)len;+}++#ifdef __cplusplus+}+#endif
@@ -0,0 +1,81 @@+/******************************************************************************\+* Copyright (c) 2023, Robert van Engelen, Genivia Inc. All rights reserved. *+* *+* Redistribution and use in source and binary forms, with or without *+* modification, are permitted provided that the following conditions are met: *+* *+* (1) Redistributions of source code must retain the above copyright notice, *+* this list of conditions and the following disclaimer. *+* *+* (2) Redistributions in binary form must reproduce the above copyright *+* notice, this list of conditions and the following disclaimer in the *+* documentation and/or other materials provided with the distribution. *+* *+* (3) The name of the author may not be used to endorse or promote products *+* derived from this software without specific prior written permission. *+* *+* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED *+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO *+* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, *+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *+* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, *+* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR *+* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF *+* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *+\******************************************************************************/++/**+@file viizip.h+@brief 7zip archive decompressor based on lzma/C/Util/7z/7zMain.c+@author Robert van Engelen - engelen@genivia.com+@copyright (c) 2023-2023, Robert van Engelen, Genivia Inc. All rights reserved.+@copyright (c) BSD-3 License - see LICENSE.txt+*/++#ifndef VIIZIP_H+#define VIIZIP_H++// check if we are compiling for a windows OS, but not Cygwin or MinGW+#if !defined(OS_WIN) && (defined(__WIN32__) || defined(_WIN32) || defined(WIN32) || defined(__BORLANDC__)) && !defined(__CYGWIN__) && !defined(__MINGW32__) && !defined(__MINGW64__)+# define OS_WIN+#endif++#ifdef OS_WIN+#include <windows.h>+/* POSIX read() and write() return type is ssize_t */+typedef int ssize_t;+#endif++#include <stdio.h>+#include <stdint.h>+#include <time.h>++#ifdef __cplusplus+extern "C" {+#endif++/* 7zip decompressor state */+struct viizip;++/* create new 7zip decompressor for the given 7zip file, returns decompressor state or NULL on failure */+struct viizip *viinew(FILE *file);++/* free viizip decompressor state */+void viifree(struct viizip *viizip);++/* get number of archived files and directories */+size_t viinum(struct viizip *viizip);++/* get archive part pathname and info, start decompressing, return 0 if success, 1 when end reached, -1 on error */+int viiget(struct viizip *viizip, char *name, size_t max, time_t *mtime, uint64_t *usize);++/* decompress up to len bytes into buf[], return number of bytes decompressed */+ssize_t viidec(struct viizip *viizip, unsigned char *buf, size_t len);++#ifdef __cplusplus+}+#endif++#endif
@@ -633,8 +633,8 @@ and `old' directories: .IP $ ugrep -n FIXME -tc++ -g^bak/,^old/ .PP-Recursively search for the word `copyright' in cpio/jar/pax/tar/zip archives,-compressed and regular files, and in PDFs using a PDF filter:+Recursively search for the word `copyright' in cpio, jar, pax, tar, zip, 7z+archives, compressed and regular files, and in PDFs using a PDF filter: .IP $ ugrep -z -w --filter='pdf:pdftotext % -' copyright .PP
@@ -1,4 +1,4 @@-.TH UGREP "1" "December 19, 2023" "ugrep 4.4.1" "User Commands"+.TH UGREP "1" "January 05, 2024" "ugrep 4.5.0" "User Commands" .SH NAME \fBugrep\fR, \fBug\fR -- file pattern searcher .SH SYNOPSIS@@ -614,9 +614,9 @@ under certain conditions to improve performance. When MAX is specified, use up to MAX mmap memory per thread. .TP \fB\-N\fR \fIPATTERN\fR, \fB\-\-neg\-regexp\fR=\fIPATTERN\fR-Specify a negative PATTERN to reject pattern matches that also-match PATTERN. Note that longer patterns take precedence over-shorter patterns, i.e. a negative pattern must be of the same+Specify a negative PATTERN to reject specific \fB\-e\fR \fIPATTERN\fR matches+with a counter pattern. Note that longer patterns take precedence+over shorter patterns, i.e. a negative pattern must be of the same length or longer to reject matching patterns. Option \fB\-N\fR cannot be specified with \fB\-P\fR. This option may be repeated. .TP@@ -893,15 +893,15 @@ text. No whitespace may be given between \fB\-Z\fR and its argument. .TP \fB\-z\fR, \fB\-\-decompress\fR Search compressed files and archives. Archives (.cpio, .pax, .tar)-and compressed archives (e.g. .zip, .taz, .tgz, .tpz, .tbz, .tbz2,-\&.tb2, .tz2, .tlz, .txz, .tzst) are searched and matching pathnames-of files in archives are output in braces. When used with option-\fB\-\-zmax\fR=\fINUM\fR, searches the contents of compressed files and archives-stored within archives up to NUM levels. If \fB\-g\fR, \fB\-O\fR, \fB\-M\fR, or \fB\-t\fR is-specified, searches files stored in archives whose filenames match-globs, match filename extensions, match file signature magic bytes,-or match file types, respectively.-Supported compression formats: gzip (.gz), compress (.Z), zip,+and compressed archives (e.g. .zip, .7z, .taz, .tgz, .tpz, .tbz,+\&.tbz2, .tb2, .tz2, .tlz, .txz, .tzst) are searched and matching+pathnames of files in archives are output in braces. When used+with option \fB\-\-zmax\fR=\fINUM\fR, searches the contents of compressed files+and archives stored within archives up to NUM levels. If \fB\-g\fR, \fB\-O\fR,+\fB\-M\fR, or \fB\-t\fR is specified, searches files stored in archives whose+filenames match globs, match filename extensions, match file+signature magic bytes, or match file types, respectively.+Supported compression formats: gzip (.gz), compress (.Z), zip, 7z, bzip2 (requires suffix .bz, .bz2, .bzip2, .tbz, .tbz2, .tb2, .tz2), lzma and xz (requires suffix .lzma, .tlz, .xz, .txz), lz4 (requires suffix .lz4),@@ -912,11 +912,11 @@ brotli (requires suffix .br). When used with option \fB\-z\fR (\fB\-\-decompress\fR), searches the contents of compressed files and archives stored within archives by up to NUM expansion stages. The default \fB\-\-zmax\fR=1 only permits searching-uncompressed files stored in cpio, pax, tar and zip archives;+uncompressed files stored in cpio, pax, tar, zip and 7z archives; compressed files and archives are detected as binary files and are effectively ignored. Specify \fB\-\-zmax\fR=2 to search compressed files-and archives stored in cpio, pax, tar and zip archives. NUM may-range from 1 to 99 for up to 99 decompression and de\-archiving+and archives stored in cpio, pax, tar, zip and 7z archives. NUM+may range from 1 to 99 for up to 99 decompression and de\-archiving steps. Increasing NUM values gradually degrades performance. .TP \fB\-0\fR, \fB\-\-null\fR@@ -1389,8 +1389,8 @@ and `old' directories: .IP $ ugrep -n FIXME -tc++ -g^bak/,^old/ .PP-Recursively search for the word `copyright' in cpio/jar/pax/tar/zip archives,-compressed and regular files, and in PDFs using a PDF filter:+Recursively search for the word `copyright' in cpio, jar, pax, tar, zip, 7z+archives, compressed and regular files, and in PDFs using a PDF filter: .IP $ ugrep -z -w --filter='pdf:pdftotext % -' copyright .PP
@@ -2727,7 +2727,7 @@ void Query::select() mark_.reset(); - size_t n = pathname.find(PATHSEPCHR);+ size_t n = pathname.find(PATHSEPCHR, 1); // ignore PATHSEPCHR at front when present size_t b = pathname.find('{'); // do not cd into archives if (n != std::string::npos && (b == std::string::npos || n < b)) {@@ -2742,7 +2742,12 @@ void Query::select() return; } - dirs_.append(dir);+ // absolute dir or relative dir+ if (dir.front() == PATHSEPCHR)+ dirs_.assign(dir);+ else+ dirs_.append(dir);+ pathname.erase(0, n + 1); // a directory change affects --hyperlink@@ -2807,14 +2812,11 @@ void Query::deselect() } } - if (chdir("..") < 0)- return;-- // a directory change affects --hyperlink- set_terminal_hyperlink();- if (dirs_.empty()) {+ if (chdir("..") < 0)+ return;+ dirs_.assign(".." PATHSEPSTR); } else@@ -2823,22 +2825,38 @@ void Query::deselect() size_t n = dirs_.find_last_of(PATHSEPCHR); - if (n == std::string::npos)+ if (n != std::string::npos && dirs_.front() == PATHSEPCHR) {- if (dirs_ != "..")- dirs_.clear();- else- dirs_.append(PATHSEPSTR ".." PATHSEPSTR);- }- else if (dirs_.compare(n + 1, std::string::npos, "..") == 0)- {- dirs_.append(PATHSEPSTR ".." PATHSEPSTR);+ if (chdir(dirs_.substr(0, n + 1).c_str()) < 0)+ return;++ dirs_.resize(n + 1); } else {- dirs_.resize(n + 1);+ if (chdir("..") < 0)+ return;++ if (n == std::string::npos)+ {+ if (dirs_ != "..")+ dirs_.clear();+ else+ dirs_.append(PATHSEPSTR ".." PATHSEPSTR);+ }+ else if (dirs_.compare(n + 1, std::string::npos, "..") == 0)+ {+ dirs_.append(PATHSEPSTR ".." PATHSEPSTR);+ }+ else+ {+ dirs_.resize(n + 1);+ } } }++ // a directory change affects --hyperlink+ set_terminal_hyperlink(); } else {
@@ -161,6 +161,7 @@ After this, you may want to test ugrep and install it (optional): // use zlib, libbz2, liblzma etc for option -z #ifdef HAVE_LIBZ+# define WITH_MAX_7ZIP_SIZE 1073741824 // 7zip expands archived files in memory, we should limit expansion up to 1GB # include "zstream.hpp" #endif @@ -6897,7 +6898,7 @@ void init(int argc, const char **argv) std::string type(types.substr(from, size)); - size_t i;+ size_t i = 0; bool found = false; bool valid = true; @@ -7631,6 +7632,11 @@ void ugrep() flag_all_include.emplace_back("*.zipx"); flag_all_include.emplace_back("*.ZIP"); +#ifndef WITH_NO_7ZIP+ flag_all_include.emplace_back("*.7z");+ flag_all_include.emplace_back("*.7Z");+#endif+ flag_all_include.emplace_back("*.cpio.gz"); flag_all_include.emplace_back("*.pax.gz"); flag_all_include.emplace_back("*.tar.gz");@@ -13951,9 +13957,9 @@ void help(std::ostream& out) under certain conditions to improve performance. When MAX is\n\ specified, use up to MAX mmap memory per thread.\n\ -N PATTERN, --neg-regexp=PATTERN\n\- Specify a negative PATTERN to reject pattern matches that also\n\- match PATTERN. Note that longer patterns take precedence over\n\- shorter patterns, i.e. a negative pattern must be of the same\n\+ Specify a negative PATTERN to reject specific -e PATTERN matches\n\+ with a counter pattern. Note that longer patterns take precedence\n\+ over shorter patterns, i.e. a negative pattern must be of the same\n\ length or longer to reject matching patterns. Option -N cannot be\n\ specified with -P. This option may be repeated.\n\ -n, --line-number\n\@@ -14184,20 +14190,23 @@ void help(std::ostream& out) text. No whitespace may be given between -Z and its argument.\n\ -z, --decompress\n\ Search compressed files and archives. Archives (.cpio, .pax, .tar)\n\- and compressed archives (e.g. .zip, .taz, .tgz, .tpz, .tbz, .tbz2,\n\- .tb2, .tz2, .tlz, .txz, .tzst) are searched and matching pathnames\n\- of files in archives are output in braces. When used with option\n\- --zmax=NUM, searches the contents of compressed files and archives\n\- stored within archives up to NUM levels. If -g, -O, -M, or -t is\n\- specified, searches files stored in archives whose filenames match\n\- globs, match filename extensions, match file signature magic bytes,\n\- or match file types, respectively.\n"+ and compressed archives (e.g. .zip, .7z, .taz, .tgz, .tpz, .tbz,\n\+ .tbz2, .tb2, .tz2, .tlz, .txz, .tzst) are searched and matching\n\+ pathnames of files in archives are output in braces. When used\n\+ with option --zmax=NUM, searches the contents of compressed files\n\+ and archives stored within archives up to NUM levels. If -g, -O,\n\+ -M, or -t is specified, searches files stored in archives whose\n\+ filenames match globs, match filename extensions, match file\n\+ signature magic bytes, or match file types, respectively.\n" #ifndef HAVE_LIBZ "\ This option is not available in this build configuration of ugrep.\n" #else "\ Supported compression formats: gzip (.gz), compress (.Z), zip"+#ifndef WITH_NO_7ZIP+ ", 7z"+#endif #ifdef HAVE_LIBBZ2 ",\n\ bzip2 (requires suffix .bz, .bz2, .bzip2, .tbz, .tbz2, .tb2, .tz2)"@@ -14229,11 +14238,11 @@ void help(std::ostream& out) When used with option -z (--decompress), searches the contents of\n\ compressed files and archives stored within archives by up to NUM\n\ expansion stages. The default --zmax=1 only permits searching\n\- uncompressed files stored in cpio, pax, tar and zip archives;\n\+ uncompressed files stored in cpio, pax, tar, zip and 7z archives;\n\ compressed files and archives are detected as binary files and are\n\ effectively ignored. Specify --zmax=2 to search compressed files\n\- and archives stored in cpio, pax, tar and zip archives. NUM may\n\- range from 1 to 99 for up to 99 decompression and de-archiving\n\+ and archives stored in cpio, pax, tar, zip and 7z archives. NUM\n\+ may range from 1 to 99 for up to 99 decompression and de-archiving\n\ steps. Increasing NUM values gradually degrades performance.\n" #ifndef WITH_DECOMPRESSION_THREAD "\@@ -14432,8 +14441,8 @@ void help(const char *what) \\W a non-word character \n\ -------------------------------------- (-P): pattern requires option -P\n\ \n\-Character classes never match a newline, except when \\P, \\D, \\H, \\W or \\X\n\-is specified or when a \\n or a \\R is specified, such as [\\s\\n].\n\+Character classes do not match a newline, except for \\P, \\D, \\H, \\W and \\X\n\+or when a \\n or a \\R is explicitly specified, such as [\\s\\n].\n\ \n\ Option -P enables Perl regex matching, supporting Unicode patterns, Unicode\n\ word boundary matching, lookaheads and capturing groups.\n\@@ -14441,7 +14450,7 @@ word boundary matching, lookaheads and capturing groups.\n\ Option -U disables full Unicode pattern matching: non-POSIX Unicode character\n\ classes \\p{class} are disabled, ASCII, LATIN1 and binary regex patterns only.\n\ \n\-Option -% (--bool) adds the following operations to regex patterns `a' and `b':\n\+Options -% (--bool --lines) and -%% (--bool --files) augments pattern syntax:\n\ \n\ pattern operation pattern operation\n\ ---------- -------------------------- ---------- --------------------------\n\@@ -14453,7 +14462,6 @@ Option -% (--bool) adds the following operations to regex patterns `a' and `b':\ \n\ Listed from the highest level of precedence to the lowest, NOT is performed\n\ before OR and OR is performed before AND. Thus, `-x|y z' is `((-x)|y) z'.\n\-\n\ Spacing of the logical AND, OR and NOT operators is required.\n\ \n\ Nested parentheses that are part of a regex sub-pattern do not group logical\n\@@ -14461,8 +14469,8 @@ operators. For example, `((x y)z)' matches `x yz'. Note that `((x y){3} z)'\n\ matches `x y' three times and a `z', since the outer parentheses group the AND\n\ (a space).\n\ \n\-The default is to match lines satisfying the Boolean query. To match files,\n\-specify the double short option -%% to enable both options --bool --files.\n\+Option -% matches lines satisfying the Boolean query. The double short option\n\+-%% matches files satisfying the Boolean query.\n\ \n\ See also options --and, --andnot, --not to specify sub-patterns as command-line\n\ arguments with options as logical operators.\n\
@@ -38,7 +38,7 @@ #define UGREP_HPP // ugrep version-#define UGREP_VERSION "4.4.1"+#define UGREP_VERSION "4.5.0" // disable mmap because mmap is almost always slower than the file reading speed improvements since 3.0.0 #define WITH_NO_MMAP
@@ -41,6 +41,9 @@ #include <cstdlib> #include <cstdint> #include <cstring>+#include <ctime>+#include <climits>+#include <exception> #include <streambuf> #include <zlib.h> @@ -93,6 +96,15 @@ extern "C" { } #endif +// use 7zip LZMA SDK using a viizip decompressor wrapper+#ifndef WITH_NO_7ZIP+#include "viizip.h"+// 7zip archive part pathname max length if limits.h doesn't define it+#ifndef PATH_MAX+#define PATH_MAX 4096+#endif+#endif+ // zip decompression crc check disabled as this is too slow, we should optimize crc32() with a table // use zip crc integrity check at the cost of a significant slow down? // #define WITH_ZIP_CRC32@@ -116,6 +128,46 @@ class zstreambuf : public std::streambuf { public: + // C++ wrapper for our C viizip 7zip decompressor+ struct sz_stream {+#ifndef WITH_NO_7ZIP+ sz_stream(const char *pathname, FILE *file)+ {+ viizip = viinew(file);++ /* non-seekable 7zip files cannot be decompressed */+ if (viizip == NULL)+ throw std::invalid_argument(pathname);+ }++ ~sz_stream()+ {+ viifree(viizip);+ }++ // next 7zip file to decompress and get its info, return 0 if OK, if none return 1 or -1 on error+ int get(std::string& name, time_t& mtime, uint64_t& usize)+ {+ char buf[PATH_MAX];+ int res = viiget(viizip, buf, PATH_MAX, &mtime, &usize);+ if (res)+ return res;++ name.assign(buf);++ return 0;+ }++ // read and decompress 7zip file data into buf[0..len-1], return number of bytes decompressed, 0 for EOF or -1 for error+ inline std::streamsize decompress(unsigned char *buf, size_t len)+ {+ return viidec(viizip, buf, len);+ }++ struct viizip *viizip;+#endif+ };+ // zip compression methods, STORE and DEFLATE are common. others are less common and some are specific to WinZip (.zipx) enum class Compression : uint16_t { STORE = 0, DEFLATE = 8, BZIP2 = 12, LZMA = 14, ZSTD = 93, XZ = 95, /* PPMD = 98 not supported */ }; @@ -128,6 +180,7 @@ class zstreambuf : public std::streambuf { bz_strm_(NULL), lzma_strm_(NULL), zstd_strm_(NULL),+ sz_strm_(NULL), zcur_(0), zlen_(0), zcrc_(0xffffffff),@@ -161,32 +214,67 @@ class zstreambuf : public std::streambuf { #ifdef HAVE_LIBZSTD if (zstd_strm_ != NULL) ZSTD_freeDStream(zstd_strm_);+#endif+#ifndef WITH_NO_7ZIP+ if (sz_strm_ != NULL)+ delete sz_strm_; #endif } uint16_t version; // zip version (unused) uint16_t flag; // zip general purpose bit flag Compression method; // zip compression method- uint16_t time; // zip last mod file time (unused)- uint16_t date; // zip last mod file date (unused)+ time_t mtime; // zip file modification time and date converted to local time uint32_t crc; // zip crc-32- uint64_t size; // zip compressed file size- uint64_t usize; // zip uncompressed file size (unused)- std::string name; // zip file name from local file header or zip extra field+ uint64_t size; // zip compressed file size, if known+ uint64_t usize; // zip uncompressed file size+ std::string name; // zip file name extracted from local file header or zip extra field protected: static const size_t ZIPBLOCK = 65536; // block size to read zip data, at least 64K to fit long 64K pathnames - static const uint16_t COMPRESS_HEADER_MAGIC = 0x9d1f; // compress header magic- static const uint16_t DEFLATE_HEADER_MAGIC = 0x8b1f; // zlib deflate header magic- static const uint32_t ZIP_HEADER_MAGIC = 0x04034b50; // zip local file header magic- static const uint32_t ZIP_EMPTY_MAGIC = 0x06054b50; // zip empty archive header magic- static const uint32_t ZIP_DESCRIPTOR_MAGIC = 0x08074b50; // zip descriptor magic+ static const uint16_t COMPRESS_HEADER_MAGIC = 0x9d1f; // compress header magic+ static const uint16_t DEFLATE_HEADER_MAGIC = 0x8b1f; // zlib deflate header magic++ static const uint32_t ZIP_HEADER_MAGIC = 0x04034b50; // zip local file header magic+ static const uint32_t ZIP_EMPTY_MAGIC = 0x06054b50; // zip empty archive header magic+ static const uint32_t ZIP_DESCRIPTOR_MAGIC = 0x08074b50; // zip descriptor magic // read zip local file header if we are at a header, read the header, file name, and extra field bool header() {+#ifndef WITH_NO_7ZIP+ // if 7zip then get the next file name and info, start decompressing, return false if none+ if (sz_strm_ != NULL)+ {+ // if info was already retrieved, then return+ if (!znew_)+ return true;++ int res = sz_strm_->get(name, mtime, usize);+ if (res < 0)+ {+ cannot_decompress(pathname_, "corrupt 7zip archive");+ return false;+ }++#ifdef WITH_MAX_7ZIP_SIZE+ if (res == 0 && usize > WITH_MAX_7ZIP_SIZE)+ {+ cannot_decompress(pathname_, std::string("7zip archived file size exceeds the set limit: ").append(name).c_str());+ return znew_ = zend_ = true;+ }+#endif++ /* don't advance to the next file */+ znew_ = false;++ zend_ = res;+ return !zend_;+ }+#endif+ // are we at a new header? If not, do nothing and return true if (!znew_) {@@ -206,16 +294,31 @@ class zstreambuf : public std::streambuf { // we're reading the zip local file header znew_ = false; + uint16_t ziptime;+ uint16_t zipdate;+ // get the zip local file header info version = u16(data + 4); flag = u16(data + 6); method = static_cast<Compression>(u16(data + 8));- time = u16(data + 10);- date = u16(data + 12);+ ziptime = u16(data + 10);+ zipdate = u16(data + 12); crc = u32(data + 14); size = u32(data + 18); usize = u32(data + 22); + // convert zip time and date+ struct tm ziptm;+ memset(&ziptm, 0, sizeof(ziptm));+ ziptm.tm_sec = 2 * (ziptime & 0x1f);+ ziptm.tm_min = (ziptime >> 5) & 0x3f;+ ziptm.tm_hour = ziptime >> 11;+ ziptm.tm_mday = zipdate & 0x1f;+ ziptm.tm_mon = (zipdate >> 5) & 0x3f;+ ziptm.tm_year = 80 + (zipdate >> 9);+ ziptm.tm_isdst = -1;+ mtime = mktime(&ziptm);+ uint16_t namelen = u16(data + 26); uint16_t extralen = u16(data + 28); @@ -441,6 +544,19 @@ class zstreambuf : public std::streambuf { std::streamsize num = 0; +#ifndef WITH_NO_7ZIP+ // 7zip decompression+ if (sz_strm_ != NULL)+ {+ num = sz_strm_->decompress(buf, len);++ if (num < static_cast<std::streamsize>(len))+ znew_ = zend_ = true;++ return num;+ }+#endif+ if (method == Compression::DEFLATE && z_strm_ != NULL) { while (true)@@ -611,58 +727,6 @@ class zstreambuf : public std::streambuf { } } #endif-#ifdef HAVE_LIBZSTD- else if (method == Compression::ZSTD && zstd_strm_ != NULL)- {- ZSTD_outBuffer out = { buf, len, 0 };- size_t ret = 1;-- if (zcur_ < zlen_)- {- ZSTD_inBuffer in = { zbuf_, zlen_, zcur_ };- ret = ZSTD_decompressStream(zstd_strm_, &out, &in);-- if (ZSTD_isError(ret))- {- cannot_decompress(pathname_, "an error was detected in the zstd compressed data");- zend_ = true;- num = -1;- }- else- {- zcur_ = in.pos;- num = static_cast<std::streamsize>(out.pos);- }- }-- if (ret != 0 && num < static_cast<std::streamsize>(len) && !zend_)- {- if (read())- {- ZSTD_inBuffer in = { zbuf_, zlen_, zcur_ };- ret = ZSTD_decompressStream(zstd_strm_, &out, &in);-- if (ZSTD_isError(ret))- {- cannot_decompress(pathname_, "an error was detected in the zstd compressed data");- zend_ = true;- num = -1;- }- else- {- zcur_ = in.pos;- num = static_cast<std::streamsize>(out.pos);- }- }- else- {- cannot_decompress(pathname_, "EOF detected in the zip compressed data");- zend_ = true;- num = -1;- }- }- }-#endif #ifdef HAVE_LIBLZMA else if ((method == Compression::LZMA || method == Compression::XZ) && lzma_strm_ != NULL) {@@ -732,6 +796,58 @@ class zstreambuf : public std::streambuf { if (zend_) lzma_end(lzma_strm_); }+#endif+#ifdef HAVE_LIBZSTD+ else if (method == Compression::ZSTD && zstd_strm_ != NULL)+ {+ ZSTD_outBuffer out = { buf, len, 0 };+ size_t ret = 1;++ if (zcur_ < zlen_)+ {+ ZSTD_inBuffer in = { zbuf_, zlen_, zcur_ };+ ret = ZSTD_decompressStream(zstd_strm_, &out, &in);++ if (ZSTD_isError(ret))+ {+ cannot_decompress(pathname_, "a zstd decompression error was detected in the zip compressed data");+ zend_ = true;+ num = -1;+ }+ else+ {+ zcur_ = in.pos;+ num = static_cast<std::streamsize>(out.pos);+ }+ }++ if (ret != 0 && num < static_cast<std::streamsize>(len) && !zend_)+ {+ if (read())+ {+ ZSTD_inBuffer in = { zbuf_, zlen_, zcur_ };+ ret = ZSTD_decompressStream(zstd_strm_, &out, &in);++ if (ZSTD_isError(ret))+ {+ cannot_decompress(pathname_, "a zstd decompression error was detected in the zip compressed data");+ zend_ = true;+ num = -1;+ }+ else+ {+ zcur_ = in.pos;+ num = static_cast<std::streamsize>(out.pos);+ }+ }+ else+ {+ cannot_decompress(pathname_, "EOF detected in the zip compressed data");+ zend_ = true;+ num = -1;+ }+ }+ } #endif else {@@ -837,6 +953,9 @@ class zstreambuf : public std::streambuf { lzma_strm_->next_in = zbuf_; lzma_strm_->avail_in = zlen_; }+#endif+#ifdef HAVE_LIBZSTD+ // no action is needed #endif } @@ -895,12 +1014,13 @@ class zstreambuf : public std::streambuf { } #endif - const char *pathname_; // the pathname of the compressed file+ const char *pathname_; // the pathname of the zip file FILE *file_; // input file z_stream *z_strm_; // zlib stream handle bz_stream *bz_strm_; // bzip2 stream handle lzma_stream *lzma_strm_; // xz/lzma stream handle zstd_stream *zstd_strm_; // zstd stream handle+ sz_stream *sz_strm_; // 7zip stream handle unsigned char zbuf_[ZIPBLOCK]; // buffer with compressed zip file data to decompress size_t zcur_; // current position in the zbuf_[] buffer, less or equal to zlen_ size_t zlen_; // length of the compressed data in the zbuf_[] buffer@@ -1232,9 +1352,36 @@ class zstreambuf : public std::streambuf { } else if (is_7z(pathname)) {- // perhaps 7zip can be supported sometime in the future?+#ifndef WITH_NO_7ZIP+ // open 7zip compressed file+ try+ {+ zipinfo_ = new ZipInfo(pathname, file);+ zipinfo_->sz_strm_ = new ZipInfo::sz_stream(pathname, file);+ }++ catch (const std::invalid_argument&)+ {+ /* non-seekable 7zip files cannot be decompressed, */+ cannot_decompress("non-seekable 7zip archive", pathname);+ file_ = NULL;+ }++ catch (const std::bad_alloc&)+ {+ if (zipinfo_ != NULL)+ {+ delete zipinfo_;+ zipinfo_ = NULL;+ }+ errno = ENOMEM;+ warning("out of memory", pathname);+ file_ = NULL;+ }+#else cannot_decompress("unsupported compression format", pathname); file_ = NULL;+#endif } else if (is_rar(pathname)) {@@ -1300,7 +1447,7 @@ class zstreambuf : public std::streambuf { { zipinfo_ = new ZipInfo(pathname, file, buf_, 4); - // read the zip header of the first compressed file+ // read the zip header of the first compressed file, if none then end if (!zipinfo_->header()) { delete zipinfo_;
@@ -15,21 +15,19 @@ Download the latest version of PCRE2 from: ftp://ftp.pcre.org/pub/pcre/ -Below we assume PCRE2 version 10.37 is used.+Below we assume PCRE2 version 10.42 is used. -Copy the downloaded pcre2-10.37 directory here.+Copy the downloaded pcre2-10.42 directory here. -Rename pcre2-10.37\src\config.h.generic as pcre2-10.37\src\config.h+Rename pcre2-10.42\src\config.h.generic as pcre2-10.42\src\config.h -Rename pcre2-10.37\src\pcre2.h.generic as pcre2-10.37\src\pcre2.h+Rename pcre2-10.42\src\pcre2.h.generic as pcre2-10.42\src\pcre2.h -Rename pcre2-10.37\src\pcre2_chartables.c.dist as pcre2-10.37\src\pcre2_chartables.c+Rename pcre2-10.42\src\pcre2_chartables.c.dist as pcre2-10.42\src\pcre2_chartables.c -Create a new C++ Static Library project in Visual Studio named "pcre2". This-should be an empty project (remove the .h and .cpp files when present).+Create a new C++ Static Library project in Visual Studio named "pcre2". This should be an empty project (remove the .h and .cpp files when present). -Add all of the .h files and a select set of .c files in directory-pcre2-10.37/src to the project sources:+Add all of the .h files and a select set of .c files in directory pcre2-10.42/src to the project sources: pcre2_auto_possess.c pcre2_chartables.c@@ -65,26 +63,24 @@ Select Release/x86 then Project Configuration Properties: Use of MFC: Use Standard Windows Libraries C/C++: General:- Additional Include Directories: C:\Users\<YOUR-PATH-HERE>\ugrep\vs\ugrep\pcre2-10.37\src+ Additional Include Directories: C:\Users\<YOUR-PATH-HERE>\ugrep\vs\ugrep\pcre2-10.42\src Precompiled Headers: Precompiled Header: Not Using Precompiled Headers Preprocessor: - Preprocessor Definitions: WIN32;NDEBUG;_LIB;HAVE_CONFIG_H;PCRE2_STATIC;PCRE2_CODE_UNIT_WIDTH=8;SUPPORT_JIT;SUPPORT_UNICODE+ Preprocessor Definitions: WIN32;NDEBUG;_LIB;WIN32_LEAN_AND_MEAN;HAVE_CONFIG_H;PCRE2_STATIC;PCRE2_CODE_UNIT_WIDTH=8;SUPPORT_JIT;SUPPORT_UNICODE;HAVE_MEMMOVE Code Generation: Runtime Library: Multi-threaded (/MT) Advanced:- Disable Specific Warnings: 4146;4703+ Disable Specific Warnings: 4146;4703;4996 -Note: to increase the PCRE2 link size from 2 to 3 to support very large regex-patterns, add LINK_SIZE=3 to the Preprocessor Definitions.+Note: to increase the PCRE2 link size from 2 to 3 to support very large regex patterns, add LINK_SIZE=3 to the Preprocessor Definitions. Then build the pcre2.lib static library in Visual Studio. Copy Release\pcre2.lib to ugrep\vs\ugrep\pcre2-x32.lib. -To build pcre2-x64.lib, repeat the last three steps, copy Release\x64\pcre2.lib-to ugrep\vs\ugrep\pcre2-x64.lib.+To build pcre2-x64.lib, repeat the last three steps, copy Release\x64\pcre2.lib to ugrep\vs\ugrep\pcre2-x64.lib. Download zlib 1.2.11 source code from: @@ -127,12 +123,37 @@ Follow the instructions to build the Release Win32 and x64 versions of the libzs https://github.com/facebook/zstd/tree/dev/build +Next we build the viiz library based on 7zip LZMA SDK. This step can be omitted when defining WITH_NO_7ZIP to compile ugrep.++Create a new C++ Static Library project in Visual Studio named "viiz". This should be an empty project (remove the .h and .cpp files when present).++Add all of the .h and .c files from ugrep/lzma/C to the viiz project sources.++Select Release/x86 then Project Configuration Properties:+ General:+ Configuration Type: Static library (.lib)+ Use of MFC: Use Standard Windows Libraries+ C/C++:+ Precompiled Headers:+ Precompiled Header: Not Using Precompiled Headers+ Preprocessor: + Preprocessor Definitions: WIN32;NDEBUG;_LIB;WIN32_LEAN_AND_MEAN;Z7_PPMD_SUPPORT;Z7_EXTRACT_ONLY;_REENTRANT;_FILE_OFFSET_BITS=64;_LARGEFILE_SOURCE+ Code Generation:+ Runtime Library:+ Multi-threaded (/MT)++Then build the viiz.lib static library in Visual Studio.++Copy ugrep\Release\viiz.lib to ugrep\viiz-x32.lib++To build viiz-x64.lib, repeat the last three steps, copy ugrep\Release\x64\viiz.lib to ugrep\viiz-x64.lib.+ After completing the steps above, this directory should contain the following directories and files (versions may differ): api bzip2-1.0.5 lz4-dev- pcre2-10.37+ pcre2-10.42 Release ugrep x64@@ -145,6 +166,8 @@ After completing the steps above, this directory should contain the following di README.txt ugrep.sln manifest.xml+ viiz-x32.lib+ viiz-x64.lib Open vs\ugrep\ugrep.sln in Visual Studio. Upgrade the version if prompted. @@ -161,7 +184,7 @@ Project Configuration Properties Use of MFC: Use Standard Windows Libraries C/C++ General:- Additional Include Directories: $(ProjectDir)\include;$(ProjectDir)\..\pcre2-10.37\src;$(ProjectDir)\..\zlib-1.2.11;$(ProjectDir)\..\bzip2-1.0.5;$(ProjectDir)\..\api;$(ProjectDir)\..\lz4-dev\lib;$(ProjectDir)\..\zstd-dev\lib+ Additional Include Directories: $(ProjectDir)\include;$(ProjectDir)\..\pcre2-10.42\src;$(ProjectDir)\..\zlib-1.2.11;$(ProjectDir)\..\bzip2-1.0.5;$(ProjectDir)\..\api;$(ProjectDir)\..\lz4-dev\lib;$(ProjectDir)\..\zstd-dev\lib;$(ProjectDir)\lzma\C Preprocessor: Preprocessor Definitions: WIN32;NDEBUG;_CONSOLE;WITH_NO_INDENT;WITH_NO_CODEGEN;HAVE_AVX2;HAVE_PCRE2;PCRE2_STATIC;HAVE_LIBZ;HAVE_LIBBZ2;HAVE_LIBLZMA;HAVE_LIBLZ4;HAVE_LIBZSTD;WITH_COLOR;ZLIB_WINAPI;NO_GZCOMPRESS;LZMA_API_STATIC;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_WARNINGS Code Generation:@@ -173,7 +196,7 @@ Project Configuration Properties General: Additional Library Directories: $(ProjectDir)\..;$(ProjectDir)\..\zstd-dev\build\VS2010\bin\Win32_Release Input:- Additional Dependencies: pcre2-x32.lib;liblzma-x32.lib;libzstd_static.lib+ Additional Dependencies: pcre2-x32.lib;liblzma-x32.lib;libzstd_static.lib;viiz-x32.lib Manifest Tool: Input and Output: Additional Manifest Files: $(ProjectDir)\..\manifest.xml@@ -195,8 +218,8 @@ Optionally, right-click on the matcher_avx512bw.cpp file to enable AVX512 when a Then build ugrep in Visual Studio. -When using Boost.Regex for option -P (fallback)------------------------------------------------+When using Boost.Regex for option -P instead of PCRE2 (fallback)+---------------------------------------------------------------- Copy the ugrep\include, ugrep\lib, and ugrep\src directories to the Visual Studio ugrep project directory located below this directory to create ugrep\include, ugrep\lib, and ugrep\src. @@ -289,7 +312,7 @@ Project Configuration Properties Use of MFC: Use Standard Windows Libraries C/C++ General:- Additional Include Directories: $(ProjectDir)\include;$(ProjectDir)\..\boost_1_72_0;$(ProjectDir)\..\zlib-1.2.11;$(ProjectDir)\..\bzip2-1.0.5;$(ProjectDir)\..\api;$(ProjectDir)\..\lz4-dev\lib;$(ProjectDir)\..\zstd-dev\lib+ Additional Include Directories: $(ProjectDir)\include;$(ProjectDir)\..\boost_1_72_0;$(ProjectDir)\..\zlib-1.2.11;$(ProjectDir)\..\bzip2-1.0.5;$(ProjectDir)\..\api;$(ProjectDir)\..\lz4-dev\lib;$(ProjectDir)\..\zstd-dev\lib;$(ProjectDir)\lzma\C Preprocessor: Preprocessor Definitions: WIN32;NDEBUG;_CONSOLE;WITH_NO_INDENT;WITH_NO_CODEGEN;HAVE_AVX2;HAVE_BOOST_REGEX;HAVE_LIBZ;HAVE_LIBBZ2;HAVE_LIBLZMA;HAVE_LIBLZ4;HAVE_LIBZSTD;WITH_COLOR;ZLIB_WINAPI;NO_GZCOMPRESS;LZMA_API_STATIC;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_WARNINGS Code Generation:@@ -301,7 +324,7 @@ Project Configuration Properties General: Additional Library Directories: $(ProjectDir)\..;$(ProjectDir)\..\zstd-dev\build\VS2010\bin\Win32_Release Input:- Additional Dependencies: liblzma-x32.lib;libzstd_static.lib+ Additional Dependencies: liblzma-x32.lib;libzstd_static.lib;viiz-x32.lib Manifest Tool: Input and Output: Additional Manifest Files: $(ProjectDir)\..\manifest.xml
@@ -48,7 +48,10 @@ <EnableEnhancedInstructionSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AdvancedVectorExtensions2</EnableEnhancedInstructionSet> <EnableEnhancedInstructionSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AdvancedVectorExtensions2</EnableEnhancedInstructionSet> </ClCompile>- <ClCompile Include="lib\matcher_avx512bw.cpp" />+ <ClCompile Include="lib\matcher_avx512bw.cpp">+ <EnableEnhancedInstructionSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AdvancedVectorExtensions512</EnableEnhancedInstructionSet>+ <EnableEnhancedInstructionSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AdvancedVectorExtensions512</EnableEnhancedInstructionSet>+ </ClCompile> <ClCompile Include="lib\pattern.cpp" /> <ClCompile Include="lib\posix.cpp" /> <ClCompile Include="lib\simd_avx2.cpp" />@@ -69,6 +72,8 @@ <ClInclude Include="..\api\lzma.h" /> <ClInclude Include="..\bzip2-1.0.5\bzlib.h" /> <ClInclude Include="..\lz4-dev\lib\lz4.h" />+ <ClInclude Include="..\zlib-1.2.11\zconf.h" />+ <ClInclude Include="..\zlib-1.2.11\zlib.h" /> <ClInclude Include="include\reflex\abslexer.h" /> <ClInclude Include="include\reflex\absmatcher.h" /> <ClInclude Include="include\reflex\bits.h" />@@ -81,6 +86,7 @@ <ClInclude Include="include\reflex\input.h" /> <ClInclude Include="include\reflex\matcher.h" /> <ClInclude Include="include\reflex\pattern.h" />+ <ClInclude Include="include\reflex\pcre2matcher.h" /> <ClInclude Include="include\reflex\posix.h" /> <ClInclude Include="include\reflex\ranges.h" /> <ClInclude Include="include\reflex\setop.h" />@@ -90,8 +96,6 @@ <ClInclude Include="include\reflex\traits.h" /> <ClInclude Include="include\reflex\unicode.h" /> <ClInclude Include="include\reflex\utf8.h" />- <ClInclude Include="include\zconf.h" />- <ClInclude Include="include\zlib.h" /> <ClInclude Include="src\cnf.hpp" /> <ClInclude Include="src\flag.hpp" /> <ClInclude Include="src\glob.hpp" />@@ -109,19 +113,19 @@ <ProjectGuid>{545CF86F-46AD-42AD-A745-9CFF05393539}</ProjectGuid> <Keyword>Win32Proj</Keyword> <RootNamespace>ugrep</RootNamespace>- <WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>+ <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion> </PropertyGroup> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration"> <ConfigurationType>Application</ConfigurationType> <UseDebugLibraries>true</UseDebugLibraries>- <PlatformToolset>v141</PlatformToolset>+ <PlatformToolset>v143</PlatformToolset> <CharacterSet>Unicode</CharacterSet> </PropertyGroup> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration"> <ConfigurationType>Application</ConfigurationType> <UseDebugLibraries>false</UseDebugLibraries>- <PlatformToolset>v141</PlatformToolset>+ <PlatformToolset>v143</PlatformToolset> <WholeProgramOptimization>true</WholeProgramOptimization> <CharacterSet>Unicode</CharacterSet> <UseOfMfc>false</UseOfMfc>@@ -129,13 +133,13 @@ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration"> <ConfigurationType>Application</ConfigurationType> <UseDebugLibraries>true</UseDebugLibraries>- <PlatformToolset>v141</PlatformToolset>+ <PlatformToolset>v143</PlatformToolset> <CharacterSet>Unicode</CharacterSet> </PropertyGroup> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration"> <ConfigurationType>Application</ConfigurationType> <UseDebugLibraries>false</UseDebugLibraries>- <PlatformToolset>v141</PlatformToolset>+ <PlatformToolset>v143</PlatformToolset> <WholeProgramOptimization>true</WholeProgramOptimization> <CharacterSet>Unicode</CharacterSet> <UseOfMfc>false</UseOfMfc>@@ -211,20 +215,21 @@ <Optimization>MaxSpeed</Optimization> <FunctionLevelLinking>true</FunctionLevelLinking> <IntrinsicFunctions>true</IntrinsicFunctions>- <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;WITH_NO_INDENT;HAVE_AVX2;HAVE_PCRE2;PCRE2_STATIC;HAVE_LIBZ;HAVE_LIBBZ2;HAVE_LIBLZMA;HAVE_LIBLZ4;HAVE_LIBZSTD;WITH_COLOR;WITH_NO_HIDDEN;ZLIB_WINAPI;NO_GZCOMPRESS;LZMA_API_STATIC;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>+ <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;WITH_NO_INDENT;WITH_NO_CODEGEN;HAVE_AVX2;HAVE_PCRE2;PCRE2_STATIC;HAVE_LIBZ;HAVE_LIBBZ2;HAVE_LIBLZMA;HAVE_LIBLZ4;HAVE_LIBZSTD;WITH_COLOR;WITH_NO_HIDDEN;ZLIB_WINAPI;NO_GZCOMPRESS;LZMA_API_STATIC;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions> <SDLCheck>true</SDLCheck> <RuntimeLibrary>MultiThreaded</RuntimeLibrary>- <AdditionalIncludeDirectories>$(ProjectDir)\include;$(ProjectDir)\..\pcre2-10.37\src;$(ProjectDir)\..\zlib-1.2.11;$(ProjectDir)\..\bzip2-1.0.5;$(ProjectDir)\..\api;$(ProjectDir)\..\lz4-dev\lib;$(ProjectDir)\..\zstd-dev\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>+ <AdditionalIncludeDirectories>$(ProjectDir)\include;$(ProjectDir)\..\pcre2-10.37\src;$(ProjectDir)\..\zlib-1.2.11;$(ProjectDir)\..\bzip2-1.0.5;$(ProjectDir)\..\api;$(ProjectDir)\..\lz4-dev\lib;$(ProjectDir)\..\zstd-dev\lib;$(ProjectDir)\lzma\C;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> <DisableSpecificWarnings> </DisableSpecificWarnings> <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>+ <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet> </ClCompile> <Link> <SubSystem>Console</SubSystem> <EnableCOMDATFolding>true</EnableCOMDATFolding> <OptimizeReferences>true</OptimizeReferences>- <GenerateDebugInformation>true</GenerateDebugInformation>- <AdditionalDependencies>pcre2-x32.lib;liblzma-x32.lib;libzstd_static.lib;%(AdditionalDependencies)</AdditionalDependencies>+ <GenerateDebugInformation>DebugFull</GenerateDebugInformation>+ <AdditionalDependencies>pcre2-x32.lib;liblzma-x32.lib;libzstd_static.lib;viiz-x32.lib;Ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalLibraryDirectories>$(ProjectDir)\..;$(ProjectDir)\..\zstd-dev\build\VS2010\bin\Win32_Release;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> </Link> <Manifest>@@ -238,18 +243,19 @@ <Optimization>MaxSpeed</Optimization> <FunctionLevelLinking>true</FunctionLevelLinking> <IntrinsicFunctions>true</IntrinsicFunctions>- <PreprocessorDefinitions>NDEBUG;_CONSOLE;WITH_NO_INDENT;HAVE_AVX2;HAVE_PCRE2;PCRE2_STATIC;HAVE_LIBZ;HAVE_LIBBZ2;HAVE_LIBLZMA;HAVE_LIBLZ4;HAVE_LIBZSTD;WITH_COLOR;WITH_NO_HIDDEN;ZLIB_WINAPI;NO_GZCOMPRESS;LZMA_API_STATIC;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>+ <PreprocessorDefinitions>NDEBUG;_CONSOLE;WITH_NO_INDENT;WITH_NO_CODEGEN;HAVE_AVX2;HAVE_PCRE2;PCRE2_STATIC;HAVE_LIBZ;HAVE_LIBBZ2;HAVE_LIBLZMA;HAVE_LIBLZ4;HAVE_LIBZSTD;WITH_COLOR;WITH_NO_HIDDEN;ZLIB_WINAPI;NO_GZCOMPRESS;LZMA_API_STATIC;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions> <SDLCheck>true</SDLCheck> <RuntimeLibrary>MultiThreaded</RuntimeLibrary>- <AdditionalIncludeDirectories>$(ProjectDir)\include;$(ProjectDir)\..\pcre2-10.37\src;$(ProjectDir)\..\zlib-1.2.11;$(ProjectDir)\..\bzip2-1.0.5;$(ProjectDir)\..\api;$(ProjectDir)\..\lz4-dev\lib;$(ProjectDir)\..\zstd-dev\lib</AdditionalIncludeDirectories>+ <AdditionalIncludeDirectories>$(ProjectDir)\include;$(ProjectDir)\..\pcre2-10.37\src;$(ProjectDir)\..\zlib-1.2.11;$(ProjectDir)\..\bzip2-1.0.5;$(ProjectDir)\..\api;$(ProjectDir)\..\lz4-dev\lib;$(ProjectDir)\..\zstd-dev\lib;$(ProjectDir)\lzma\C</AdditionalIncludeDirectories> <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>+ <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet> </ClCompile> <Link> <SubSystem>Console</SubSystem> <EnableCOMDATFolding>true</EnableCOMDATFolding> <OptimizeReferences>true</OptimizeReferences>- <GenerateDebugInformation>true</GenerateDebugInformation>- <AdditionalDependencies>pcre2-x64.lib;liblzma-x64.lib;libzstd_static.lib;%(AdditionalDependencies)</AdditionalDependencies>+ <GenerateDebugInformation>DebugFull</GenerateDebugInformation>+ <AdditionalDependencies>pcre2-x64.lib;liblzma-x64.lib;libzstd_static.lib;viiz-x64.lib;Ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalLibraryDirectories>$(ProjectDir)\..;$(ProjectDir)\..\zstd-dev\build\VS2010\bin\x64_Release;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries> </Link>
vs/ugrep/ugrep/ugrep.vcxproj.filters
@@ -203,12 +203,6 @@ <ClInclude Include="include\reflex\error.h"> <Filter>Header Files</Filter> </ClInclude>- <ClInclude Include="include\zlib.h">- <Filter>Header Files</Filter>- </ClInclude>- <ClInclude Include="include\zconf.h">- <Filter>Header Files</Filter>- </ClInclude> <ClInclude Include="src\zopen.h"> <Filter>Header Files</Filter> </ClInclude>@@ -257,5 +251,14 @@ <ClInclude Include="include\reflex\simd.h"> <Filter>Header Files</Filter> </ClInclude>+ <ClInclude Include="include\reflex\pcre2matcher.h">+ <Filter>Header Files</Filter>+ </ClInclude>+ <ClInclude Include="..\zlib-1.2.11\zlib.h">+ <Filter>Header Files</Filter>+ </ClInclude>+ <ClInclude Include="..\zlib-1.2.11\zconf.h">+ <Filter>Header Files</Filter>+ </ClInclude> </ItemGroup> </Project>